// ---------------------------------------------------------------------------// OpenAPI ↔ generic auth-method converters.//// The generic Accounts hub speaks in plugin-agnostic `AuthMethod` /// `Placement` values (`@executor-js/react/lib/auth-placements`). The OpenAPI// plugin stores auth as the HTTP-transport-specific `APIKeyAuthentication`// template (header/query slots templated with `variable("token")`). These two// converters bridge the wire template to/from the generic placement model, so// they live with the OpenAPI plugin — they touch the openapi sdk// `Authentication` types and would pull transport specifics into core.// --------------------------------------------------------------------------- import { AuthTemplateSlug } from "@executor-js/sdk/shared";import type { AuthMethod, Placement } from "@executor-js/react/lib/auth-placements";import type { AuthTemplateEditorValue } from "@executor-js/react/components/auth-template-editor"; import {  TOKEN_VARIABLE,  variable,  type APIKeyAuthentication,  type Authentication,  type AuthenticationTemplateValue,} from "../sdk/types"; // ---------------------------------------------------------------------------// Template value → placement prefix.//// A header/query slot serializes the credential as `name -> [prefix, token]`,// where `prefix` is the leading literal string before the `variable("token")`// part. A bare `[token]` (or string-only) value has an empty prefix.// --------------------------------------------------------------------------- const isVariablePart = (part: string | { readonly type: "variable"; readonly name: string }) =>  typeof part !== "string" && part.type === "variable"; /** Extract the literal prefix preceding the credential variable, plus the *  variable name that placement renders from (`token` for single-input methods, *  a distinct name per input for multi-input ones). */const parseTemplateValue = (  value: AuthenticationTemplateValue,): { readonly prefix: string; readonly variable: string } => {  if (typeof value === "string") return { prefix: "", variable: TOKEN_VARIABLE };  const parts: string[] = [];  for (const part of value) {    if (isVariablePart(part)) {      return { prefix: parts.join(""), variable: (part as { readonly name: string }).name };    }    if (typeof part === "string") parts.push(part);  }  return { prefix: parts.join(""), variable: TOKEN_VARIABLE };}; export const placementsFromApiKey = (template: APIKeyAuthentication): Placement[] => {  const placements: Placement[] = [];  for (const [name, value] of Object.entries(template.headers ?? {})) {    const { prefix, variable } = parseTemplateValue(value);    placements.push({ carrier: "header", name, prefix, variable });  }  for (const [name, value] of Object.entries(template.queryParams ?? {})) {    const { prefix, variable } = parseTemplateValue(value);    placements.push({ carrier: "query", name, prefix, variable });  }  return placements;}; // ---------------------------------------------------------------------------// Templates → generic methods.// --------------------------------------------------------------------------- const labelForApiKey = (slug: string, placements: readonly Placement[]): string => {  const first = placements[0];  if (first) return `API key (${first.name || (first.carrier === "header" ? "header" : "query")})`;  return `API key (${slug})`;}; /** Map each stored auth template to a generic `AuthMethod`. */export function authMethodsFromConfig(templates: readonly Authentication[]): AuthMethod[] {  return templates.map((template: Authentication): AuthMethod => {    const slug = String(template.slug);    const source: "spec" | "custom" = slug.startsWith("custom_") ? "custom" : "spec";    if (template.type === "oauth") {      return {        id: slug,        label: "OAuth2",        kind: "oauth",        source,        template: AuthTemplateSlug.make(slug),        placements: [],        // Carry the integration's declared endpoints/scopes so the        // client-registration form pre-fills them.        oauth: {          authorizationUrl: template.authorizationUrl,          tokenUrl: template.tokenUrl,          scopes: template.scopes,        },      };    }    const placements = placementsFromApiKey(template);    return {      id: slug,      label: labelForApiKey(slug, placements),      kind: "apikey",      source,      template: AuthTemplateSlug.make(slug),      placements,    };  });} // ---------------------------------------------------------------------------// Generic placements → apiKey template (inverse).//// Each placement becomes a header/query slot whose value is// `prefix ? [prefix, variable("token")] : [variable("token")]`. A custom method// may omit `slug`; the backend backfills `custom_<id>`.// --------------------------------------------------------------------------- /** Slugify a placement name into a variable identifier: `DD-API-KEY` → *  `dd_api_key`. */const slugifyVariable = (name: string): string =>  name    .toLowerCase()    .replace(/[^a-z0-9]+/g, "_")    .replace(/^_+|_+$/g, ""); /** Assign an input variable to each (named) placement. A lone input is the *  canonical `token`; multiple inputs each get their own distinct variable so a *  connection can carry a different value per location. An explicit *  `placement.variable` (from a round-trip) is honored. */const assignVariables = (placements: readonly Placement[]): Map<Placement, string> => {  const named = placements.filter((p) => p.name);  const out = new Map<Placement, string>();  if (named.length <= 1) {    for (const p of named) out.set(p, p.variable ?? TOKEN_VARIABLE);    return out;  }  const taken = new Set<string>();  for (const p of named) {    const base = slugifyVariable(p.name) || "input";    let candidate = p.variable ?? base;    let n = 2;    while (taken.has(candidate)) candidate = `${base}_${n++}`;    taken.add(candidate);    out.set(p, candidate);  }  return out;}; const valueFromPlacement = (placement: Placement, varName: string): AuthenticationTemplateValue =>  placement.prefix ? [placement.prefix, variable(varName)] : [variable(varName)]; /** Build an `APIKeyAuthentication` template from generic placements. When *  `slug` is omitted the backend assigns a `custom_<id>` slug. */export function templateFromPlacements(  placements: readonly Placement[],  slug?: string,): APIKeyAuthentication {  const variables = assignVariables(placements);  const headers: Record<string, AuthenticationTemplateValue> = {};  const queryParams: Record<string, AuthenticationTemplateValue> = {};  for (const placement of placements) {    if (!placement.name) continue;    const varName = variables.get(placement) ?? TOKEN_VARIABLE;    if (placement.carrier === "header") {      headers[placement.name] = valueFromPlacement(placement, varName);    } else {      queryParams[placement.name] = valueFromPlacement(placement, varName);    }  }  return {    slug: AuthTemplateSlug.make(slug ?? ""),    type: "apiKey",    ...(Object.keys(headers).length > 0 ? { headers } : {}),    ...(Object.keys(queryParams).length > 0 ? { queryParams } : {}),  };} // ---------------------------------------------------------------------------// Stored `Authentication` ⇆ generic `AuthTemplateEditorValue`.//// The shared add-time `AuthTemplateEditor` edits a plugin-agnostic value; these// bridge it to/from the OpenAPI wire template so a spec-detected method seeds an// editable default and the user's edits round-trip back to `Authentication[]`// on submit. apiKey → placements; oauth → endpoints + scopes.// --------------------------------------------------------------------------- /** Convert one stored `Authentication` template into a generic editor value. */export function editorValueFromAuthentication(template: Authentication): AuthTemplateEditorValue {  if (template.type === "oauth") {    return {      kind: "oauth",      authorizationUrl: template.authorizationUrl ?? "",      tokenUrl: template.tokenUrl ?? "",      scopes: template.scopes ?? [],    };  }  return { kind: "apikey", placements: placementsFromApiKey(template) };} /** Build an `OAuthAuthentication` template from a generic oauth editor value. */const oauthTemplateFromEditorValue = (  value: Extract<AuthTemplateEditorValue, { kind: "oauth" }>,  slug?: string,): Authentication => ({  slug: AuthTemplateSlug.make(slug ?? ""),  type: "oauth",  authorizationUrl: value.authorizationUrl,  tokenUrl: value.tokenUrl,  scopes: [...value.scopes],}); /** Convert one generic editor value back into a stored `Authentication`, or *  `null` for `none` (no method to register). The optional `slug` names the *  template; when omitted the backend backfills `custom_<id>`. */export function authenticationFromEditorValue(  value: AuthTemplateEditorValue,  slug?: string,): Authentication | null {  if (value.kind === "none") return null;  if (value.kind === "oauth") return oauthTemplateFromEditorValue(value, slug);  return templateFromPlacements(value.placements, slug);}