@elench/testkit 0.1.80 → 0.1.82

package/lib/config-api/profiles.mjs

@@ -1,640 +0,0 @@
-import { runtimeHttp, runtimeJson } from "./runtime.mjs";
-
-export function customProfile(profile) {
-  return profile || {};
-}
-
-export function rawProfile(options = {}) {
-  const headerBuilder = createCompositeHeaderBuilder({
-    defaultActor: null,
-    headers: options.headers,
-    resolveSessionData() {
-      return null;
-    },
-  });
-
-  return customProfile({
-    env: options.env,
-    options: options.options,
-    auth: null,
-    headers: (_setupData, context) => headerBuilder(null, context?.env),
-    rawHeaders: (_setupData, context) => headerBuilder(null, context?.env),
-  });
-}
-
-export function sessionProfile(options = {}) {
-  const actor = normalizeActorConfig(options.actor, "profiles.session actor");
-  const profileHeaders = options.headers || {};
-  const headerBuilder = createCompositeHeaderBuilder({
-    defaultActor: "primary",
-    headers: profileHeaders,
-    resolveSessionData(setupData) {
-      return setupData || null;
-    },
-  });
-
-  return customProfile({
-    env: options.env,
-    options: options.options,
-    auth: {
-      setup({ env }) {
-        return resolveActorSession({
-          actorName: "primary",
-          actorConfig: actor,
-          env,
-        });
-      },
-      headers(setupData) {
-        return buildAuthHeaders({
-          sessionData: setupData || null,
-          auth: actor.session?.auth,
-        });
-      },
-    },
-    headers(setupData, context) {
-      return headerBuilder(setupData || null, context?.env);
-    },
-    rawHeaders(setupData, context) {
-      return headerBuilder(setupData || null, context?.env);
-    },
-  });
-}
-
-export function multiActorProfile(options = {}) {
-  const normalizedActors = normalizeActorMap(options.actors);
-  const actorNames = Object.keys(normalizedActors);
-  if (actorNames.length === 0) {
-    throw new Error("profiles.multiActor(...) requires at least one actor");
-  }
-  const primaryActor = options.primaryActor || actorNames[0];
-  if (!normalizedActors[primaryActor]) {
-    throw new Error(`profiles.multiActor(...) primaryActor "${primaryActor}" is not defined`);
-  }
-
-  const headerBuilder = createCompositeHeaderBuilder({
-    defaultActor: primaryActor,
-    headers: options.headers || {},
-    resolveSessionData(setupData, entry) {
-      const targetActor = entry?.actor || primaryActor;
-      return setupData?.[targetActor] || null;
-    },
-  });
-
-  return customProfile({
-    env: options.env,
-    options: options.options,
-    auth: {
-      setup({ env }) {
-        const setupData = {};
-        actorNames.forEach((actorName, index) => {
-          setupData[actorName] = resolveActorSession({
-            actorName,
-            actorIndex: index,
-            actorConfig: normalizedActors[actorName],
-            env,
-          });
-        });
-        return setupData;
-      },
-      headers(setupData) {
-        return buildAuthHeaders({
-          sessionData: setupData?.[primaryActor] || null,
-          auth: normalizedActors[primaryActor].session?.auth,
-        });
-      },
-    },
-    headers(setupData, context) {
-      return headerBuilder(setupData || {}, context?.env);
-    },
-    rawHeaders(setupData, context) {
-      return headerBuilder(setupData || {}, context?.env);
-    },
-  });
-}
-
-export function localJsonProfile(options = {}) {
-  const baseOptions = normalizeLocalJsonBaseOptions(options);
-
-  return {
-    raw(overrides = {}) {
-      const mergedHeaders = mergeLocalJsonHeaderOptions(baseOptions.headers, overrides.headers);
-      return rawProfile({
-        env: overrides.env ?? baseOptions.env,
-        options: overrides.options ?? baseOptions.options,
-        headers: buildLocalJsonHeaderConfig(mergedHeaders),
-      });
-    },
-    session(overrides = {}) {
-      const actorName = overrides.actor || "primary";
-      const actorConfig = createLocalJsonActorConfig({
-        actorName,
-        baseOptions,
-        identityOverride: overrides.identity,
-      });
-      const mergedHeaders = mergeLocalJsonHeaderOptions(baseOptions.headers, overrides.headers);
-      return sessionProfile({
-        env: overrides.env ?? baseOptions.env,
-        options: overrides.options ?? baseOptions.options,
-        actor: actorConfig,
-        headers: buildLocalJsonHeaderConfig(mergedHeaders),
-      });
-    },
-    multiActor(overrides = {}) {
-      const actorEntries = resolveLocalJsonActorEntries({
-        actors: overrides.actors,
-        identities: baseOptions.identities,
-      });
-      if (actorEntries.length === 0) {
-        throw new Error("profiles.localJson(...).multiActor(...) requires at least one actor");
-      }
-      const primaryActor = overrides.primaryActor || actorEntries[0].actorName;
-      const actorMap = {};
-      actorEntries.forEach(({ actorName, identity }) => {
-        actorMap[actorName] = createLocalJsonActorConfig({
-          actorName,
-          baseOptions,
-          identityOverride: identity,
-        });
-      });
-      const mergedHeaders = mergeLocalJsonHeaderOptions(baseOptions.headers, overrides.headers);
-      return multiActorProfile({
-        env: overrides.env ?? baseOptions.env,
-        options: overrides.options ?? baseOptions.options,
-        primaryActor,
-        actors: actorMap,
-        headers: buildLocalJsonHeaderConfig(mergedHeaders),
-      });
-    },
-  };
-}
-
-function normalizeActorConfig(actor, label) {
-  if (!actor || typeof actor !== "object" || Array.isArray(actor)) {
-    throw new Error(`${label} must be an object`);
-  }
-  if (!actor.login || typeof actor.login !== "object" || Array.isArray(actor.login)) {
-    throw new Error(`${label}.login is required`);
-  }
-  if (!actor.session || typeof actor.session !== "object" || Array.isArray(actor.session)) {
-    throw new Error(`${label}.session is required`);
-  }
-
-  return {
-    bootstrap: normalizeRequestList(actor.bootstrap),
-    login: actor.login,
-    session: actor.session,
-  };
-}
-
-function normalizeActorMap(actors) {
-  if (!actors || typeof actors !== "object" || Array.isArray(actors)) {
-    throw new Error("profiles.multiActor(...) actors must be an object");
-  }
-  const normalized = {};
-  for (const [actorName, actorConfig] of Object.entries(actors)) {
-    normalized[actorName] = normalizeActorConfig(actorConfig, `profiles.multiActor actors.${actorName}`);
-  }
-  return normalized;
-}
-
-function normalizeRequestList(value) {
-  if (value == null) return [];
-  return Array.isArray(value) ? [...value] : [value];
-}
-
-function normalizeLocalJsonBaseOptions(options) {
-  return {
-    env: options.env,
-    headers: normalizeLocalJsonHeaderOptions(options.headers),
-    identities: options.identities && typeof options.identities === "object" && !Array.isArray(options.identities)
-      ? { ...options.identities }
-      : {},
-    login: normalizeLocalJsonLoginOptions(options.login),
-    options: options.options,
-    password: options.password,
-    session: normalizeLocalJsonSessionOptions(options.session),
-    signup: normalizeLocalJsonSignupOptions(options.signup),
-  };
-}
-
-function normalizeLocalJsonSignupOptions(options) {
-  if (options === false) {
-    return { enabled: false };
-  }
-
-  const normalized = options && typeof options === "object" && !Array.isArray(options) ? { ...options } : {};
-  return {
-    enabled: normalized.enabled !== false,
-    expect: normalized.expect ?? [201, 409],
-    path: normalized.path || "/api/v1/auth/signup",
-  };
-}
-
-function normalizeLocalJsonLoginOptions(options) {
-  const normalized = options && typeof options === "object" && !Array.isArray(options) ? { ...options } : {};
-  return {
-    expect: normalized.expect ?? 200,
-    path: normalized.path || "/api/v1/auth/login",
-  };
-}
-
-function normalizeLocalJsonSessionOptions(options) {
-  const normalized = options && typeof options === "object" && !Array.isArray(options) ? { ...options } : {};
-  return {
-    auth: normalized.auth && typeof normalized.auth === "object" && !Array.isArray(normalized.auth)
-      ? { ...normalized.auth }
-      : {},
-    authCookie: normalized.authCookie || null,
-    cookies: normalized.cookies && typeof normalized.cookies === "object" && !Array.isArray(normalized.cookies)
-      ? { ...normalized.cookies }
-      : {},
-    fields: normalized.fields && typeof normalized.fields === "object" && !Array.isArray(normalized.fields)
-      ? { ...normalized.fields }
-      : {},
-    organizationIdPath: normalized.organizationIdPath || null,
-    refreshCookie: normalized.refreshCookie || null,
-  };
-}
-
-function normalizeLocalJsonHeaderOptions(options) {
-  const normalized = options && typeof options === "object" && !Array.isArray(options) ? { ...options } : {};
-  return {
-    contentTypeJson: normalized.contentTypeJson,
-    forwardedFor: normalized.forwardedFor,
-    organization: normalized.organization === undefined ? "X-Organization-Id" : normalized.organization,
-    values: normalized.values,
-  };
-}
-
-function mergeLocalJsonHeaderOptions(baseOptions, overrideOptions) {
-  const normalizedBase = normalizeLocalJsonHeaderOptions(baseOptions);
-  const normalizedOverride = normalizeLocalJsonHeaderOptions(overrideOptions);
-  return {
-    contentTypeJson:
-      normalizedOverride.contentTypeJson !== undefined
-        ? normalizedOverride.contentTypeJson
-        : normalizedBase.contentTypeJson,
-    forwardedFor:
-      normalizedOverride.forwardedFor !== undefined
-        ? normalizedOverride.forwardedFor
-        : normalizedBase.forwardedFor,
-    organization:
-      normalizedOverride.organization !== undefined
-        ? normalizedOverride.organization
-        : normalizedBase.organization,
-    values: normalizedOverride.values !== undefined ? normalizedOverride.values : normalizedBase.values,
-  };
-}
-
-function resolveLocalJsonActorEntries({ actors, identities }) {
-  if (Array.isArray(actors)) {
-    return actors.map((actorName) => ({
-      actorName,
-      identity: identities?.[actorName],
-    }));
-  }
-  if (actors && typeof actors === "object") {
-    return Object.entries(actors).map(([actorName, identity]) => ({
-      actorName,
-      identity,
-    }));
-  }
-
-  const identityEntries = Object.entries(identities || {}).filter(([actorName]) => actorName !== "*");
-  return identityEntries.map(([actorName, identity]) => ({ actorName, identity }));
-}
-
-function createLocalJsonActorConfig({ actorName, baseOptions, identityOverride }) {
-  const identity = resolveLocalJsonIdentity({
-    actorName,
-    identities: baseOptions.identities,
-    identityOverride,
-  });
-  const password = resolveLocalJsonIdentityValue(identity.password ?? baseOptions.password, actorName, `password for actor "${actorName}"`);
-  const email = resolveLocalJsonIdentityValue(identity.email, actorName, `email for actor "${actorName}"`);
-  const name = resolveLocalJsonIdentityOptionalValue(identity.name, actorName);
-  const organizationName = resolveLocalJsonIdentityOptionalValue(identity.organizationName, actorName);
-
-  const signupBody = {
-    email,
-    password,
-    ...(name ? { name } : {}),
-    ...(organizationName ? { organizationName } : {}),
-    ...normalizeObject(identity.signupBody),
-  };
-  const loginBody = {
-    email,
-    password,
-    ...normalizeObject(identity.loginBody),
-  };
-
-  return {
-    bootstrap: baseOptions.signup.enabled
-      ? {
-          path: baseOptions.signup.path,
-          expect: baseOptions.signup.expect,
-          body: () => signupBody,
-        }
-      : [],
-    login: {
-      path: baseOptions.login.path,
-      expect: baseOptions.login.expect,
-      body: () => loginBody,
-    },
-    session: buildLocalJsonSessionCaptureConfig(baseOptions.session),
-  };
-}
-
-function resolveLocalJsonIdentity({ actorName, identities, identityOverride }) {
-  const baseIdentity = normalizeObject(identities?.["*"]);
-  const namedIdentity = normalizeObject(identities?.[actorName]);
-  return {
-    ...baseIdentity,
-    ...namedIdentity,
-    ...normalizeObject(identityOverride),
-  };
-}
-
-function resolveLocalJsonIdentityValue(value, actorName, label) {
-  const resolved = resolveLocalJsonIdentityOptionalValue(value, actorName);
-  if (resolved == null || resolved === "") {
-    throw new Error(`profiles.localJson(...) requires ${label}`);
-  }
-  return resolved;
-}
-
-function resolveLocalJsonIdentityOptionalValue(value, actorName) {
-  if (typeof value === "function") {
-    return value({ actor: actorName });
-  }
-  if (typeof value !== "string") {
-    return value ?? null;
-  }
-  return value.replaceAll("{actor}", actorName);
-}
-
-function normalizeObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
-function buildLocalJsonSessionCaptureConfig(sessionOptions) {
-  const cookies = {
-    ...(sessionOptions.authCookie
-      ? { [(sessionOptions.auth?.sourceKey || "jwt")]: sessionOptions.authCookie }
-      : {}),
-    ...(sessionOptions.refreshCookie ? { refreshToken: sessionOptions.refreshCookie } : {}),
-    ...sessionOptions.cookies,
-  };
-  const fields = {
-    ...(sessionOptions.organizationIdPath ? { organizationId: sessionOptions.organizationIdPath } : {}),
-    ...sessionOptions.fields,
-  };
-
-  return {
-    cookies,
-    fields,
-    ...(sessionOptions.authCookie || sessionOptions.auth?.sourceKey
-      ? {
-          auth: {
-            header: sessionOptions.auth?.header,
-            prefix: sessionOptions.auth?.prefix,
-            source: {
-              key: sessionOptions.auth?.sourceKey || "jwt",
-            },
-          },
-        }
-      : {}),
-  };
-}
-
-function buildLocalJsonHeaderConfig(headerOptions) {
-  const fromSession = [];
-  if (headerOptions.organization !== false) {
-    if (typeof headerOptions.organization === "string") {
-      fromSession.push({
-        header: headerOptions.organization,
-        field: "organizationId",
-      });
-    } else if (headerOptions.organization && typeof headerOptions.organization === "object") {
-      fromSession.push({
-        actor: headerOptions.organization.actor,
-        field: headerOptions.organization.field || "organizationId",
-        header: headerOptions.organization.header || "X-Organization-Id",
-      });
-    }
-  }
-
-  return {
-    ...(headerOptions.contentTypeJson !== undefined ? { contentTypeJson: headerOptions.contentTypeJson } : {}),
-    ...(headerOptions.forwardedFor !== undefined ? { forwardedFor: headerOptions.forwardedFor } : {}),
-    ...(fromSession.length > 0 ? { fromSession } : {}),
-    ...(headerOptions.values !== undefined ? { values: headerOptions.values } : {}),
-  };
-}
-
-function resolveActorSession({ actorName, actorConfig, env, actorIndex = 0 }) {
-  const requestContext = { actor: actorName, actorIndex, env };
-  actorConfig.bootstrap.forEach((requestConfig, index) => {
-    runProfileRequest({
-      requestConfig,
-      context: { ...requestContext, phase: `bootstrap:${index}` },
-      label: `profiles bootstrap request for actor "${actorName}"`,
-    });
-  });
-
-  const loginResponse = runProfileRequest({
-    requestConfig: actorConfig.login,
-    context: { ...requestContext, phase: "login" },
-    label: `profiles login request for actor "${actorName}"`,
-  });
-
-  return extractSessionData(loginResponse, actorConfig.session);
-}
-
-function runProfileRequest({ requestConfig, context, label }) {
-  const method = normalizeMethod(requestConfig.method);
-  const path = requestConfig.path;
-  if (typeof path !== "string" || path.trim().length === 0) {
-    throw new Error(`${label} requires a non-empty path`);
-  }
-
-  const bodyValue = resolveFactoryValue(requestConfig.body, context);
-  const headersValue = resolveFactoryValue(requestConfig.headers, context) || {};
-  const headers = {
-    ...(requestConfig.contentTypeJson === false ? {} : { "Content-Type": "application/json" }),
-    ...(context.env?.routeParams || {}),
-    ...headersValue,
-  };
-  const expectedStatuses = normalizeExpectedStatuses(requestConfig.expect);
-  const url = `${context.env.BASE}${path}`;
-  const response = dispatchProfileRequest(method, url, bodyValue, headers);
-
-  if (!expectedStatuses.includes(Number(response?.status))) {
-    throw new Error(
-      `${label} failed (${response?.status ?? "unknown"}): ${response?.body ?? "no response body"}`
-    );
-  }
-
-  return response;
-}
-
-function dispatchProfileRequest(method, url, body, headers) {
-  if (method === "GET") return runtimeHttp.get(url, { headers });
-  if (method === "DELETE") return runtimeHttp.del(url, body == null ? null : JSON.stringify(body), { headers });
-  if (method === "PUT") return runtimeHttp.put(url, JSON.stringify(body ?? null), { headers });
-  if (method === "PATCH") return runtimeHttp.patch(url, JSON.stringify(body ?? null), { headers });
-  return runtimeHttp.post(url, JSON.stringify(body ?? null), { headers });
-}
-
-function normalizeMethod(value) {
-  const method = String(value || "POST").trim().toUpperCase();
-  if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-    throw new Error(`Unsupported profile request method "${method}"`);
-  }
-  return method;
-}
-
-function normalizeExpectedStatuses(value) {
-  if (value == null) return [200];
-  return Array.isArray(value) ? value.map((entry) => Number(entry)) : [Number(value)];
-}
-
-function resolveFactoryValue(value, context) {
-  if (typeof value === "function") {
-    return value(context);
-  }
-  return value;
-}
-
-function extractSessionData(response, sessionConfig) {
-  const data = {};
-  const body = safeRuntimeJson(response);
-
-  for (const [fieldName, cookieName] of Object.entries(sessionConfig.cookies || {})) {
-    data[fieldName] = extractCookieValue(response, cookieName);
-  }
-
-  for (const [fieldName, fieldPath] of Object.entries(sessionConfig.fields || {})) {
-    data[fieldName] = readValueAtPath(body, fieldPath);
-  }
-
-  return data;
-}
-
-function buildAuthHeaders({ sessionData, auth }) {
-  if (!auth) return {};
-  const source = auth.source || {};
-  const value = sessionData?.[source.key];
-  if (!value) return {};
-
-  const header = auth.header || "Authorization";
-  const prefix = auth.prefix === undefined ? "Bearer " : String(auth.prefix);
-  return {
-    [header]: `${prefix}${value}`,
-  };
-}
-
-function createCompositeHeaderBuilder({ defaultActor, headers, resolveSessionData }) {
-  const normalized = headers || {};
-
-  return function buildHeaders(setupData, env) {
-    const actorContext = normalized.forwardedFor && typeof normalized.forwardedFor === "object"
-      ? normalized.forwardedFor.actor || defaultActor || null
-      : defaultActor || null;
-    const sessionDataForValues = resolveSessionData(setupData, { actor: actorContext });
-    const valueContext = {
-      actor: actorContext,
-      env,
-      session: sessionDataForValues,
-    };
-    const staticValues = resolveFactoryValue(normalized.values, valueContext) || {};
-    const builtHeaders = {
-      ...(normalized.contentTypeJson ? { "Content-Type": "application/json" } : {}),
-      ...staticValues,
-    };
-
-    const forwardedFor = buildForwardedForHeader(normalized.forwardedFor, env, actorContext);
-    if (forwardedFor) {
-      builtHeaders[forwardedFor.header] = forwardedFor.value;
-    }
-
-    for (const entry of normalized.fromSession || []) {
-      const sessionData = resolveSessionData(setupData, entry);
-      const value = sessionData ? readValueAtPath(sessionData, entry.field) : null;
-      if (value != null && value !== "") {
-        builtHeaders[entry.header] = String(value);
-      }
-    }
-
-    return builtHeaders;
-  };
-}
-
-function buildForwardedForHeader(config, env, actorName) {
-  if (!config) return null;
-  const header = typeof config === "object" && config.header ? config.header : "X-Forwarded-For";
-  const seed =
-    typeof config === "object" && config.seed
-      ? config.seed
-      : `${env?.BASE || "testkit"}:${actorName || "raw"}`;
-  return {
-    header,
-    value: deriveDeterministicIp(seed),
-  };
-}
-
-function deriveDeterministicIp(seed) {
-  const text = String(seed || "testkit");
-  const octets = [0, 0, 0, 0];
-  for (let index = 0; index < text.length; index += 1) {
-    octets[index % 4] = (octets[index % 4] * 31 + text.charCodeAt(index)) % 250;
-  }
-  return `10.${octets[0] + 1}.${octets[1] + 1}.${octets[2] + 1}`;
-}
-
-function extractCookieValue(response, cookieName) {
-  const cookies = response?.cookies?.[cookieName];
-  if (Array.isArray(cookies) && cookies[0]?.value) {
-    return cookies[0].value;
-  }
-
-  const headerValues = [];
-  for (const [headerName, headerValue] of Object.entries(response?.headers || {})) {
-    if (String(headerName).toLowerCase() !== "set-cookie") continue;
-    if (Array.isArray(headerValue)) headerValues.push(...headerValue);
-    else if (headerValue) headerValues.push(headerValue);
-  }
-
-  const pattern = new RegExp(`(?:^|,\\s*)${cookieName}=([^;,]+)`);
-  for (const value of headerValues) {
-    const match = pattern.exec(String(value));
-    if (match?.[1]) return match[1];
-  }
-
-  return null;
-}
-
-function safeRuntimeJson(response) {
-  try {
-    return runtimeJson(response);
-  } catch {
-    return null;
-  }
-}
-
-function readValueAtPath(value, path) {
-  if (value == null || typeof path !== "string" || path.trim().length === 0) {
-    return null;
-  }
-  const parts = String(path)
-    .replace(/\[(\d+)\]/g, ".$1")
-    .split(".")
-    .filter(Boolean);
-
-  let current = value;
-  for (const part of parts) {
-    if (current == null) return null;
-    current = current[part];
-  }
-  return current ?? null;
-}