@lunora/codegen 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/SCHEMA_SNAPSHOT_VERSION-wWGP2_5E.mjs

@@ -0,0 +1,245 @@
+const SCHEMA_SNAPSHOT_VERSION = 1;
+const encodeShardMode = (mode) => {
+  if (mode === "global" || mode === "root") {
+    return mode;
+  }
+  return `shardBy:${mode.field}`;
+};
+const fieldSnapshotOf = (validator) => {
+  if (validator.kind === "optional") {
+    return { kind: validator.inner?.kind ?? "unknown", optional: true };
+  }
+  return { kind: validator.kind, optional: false };
+};
+const tableSnapshotOf = (table) => {
+  const fields = {};
+  for (const [name, validator] of Object.entries(table.shape)) {
+    fields[name] = fieldSnapshotOf(validator);
+  }
+  const indexes = {};
+  for (const index of table.indexes) {
+    indexes[index.name] = { fields: [...index.fields], unique: index.unique ?? false };
+  }
+  const relations = {};
+  for (const relation of table.relations) {
+    relations[relation.name] = { field: relation.field, kind: relation.kind, table: relation.table };
+  }
+  return { fields, indexes, relations, shardMode: encodeShardMode(table.shardMode) };
+};
+const sortKeys = (record) => {
+  const sorted = {};
+  for (const key of Object.keys(record).toSorted((a, b) => a.localeCompare(b))) {
+    sorted[key] = record[key];
+  }
+  return sorted;
+};
+const buildSchemaSnapshot = (schema, migrationIds) => {
+  const tables = {};
+  for (const table of schema.tables) {
+    tables[table.name] = tableSnapshotOf(table);
+  }
+  return {
+    jurisdiction: schema.jurisdiction,
+    migrationIds: [...migrationIds].toSorted((a, b) => a.localeCompare(b)),
+    tables: sortKeys(tables),
+    version: SCHEMA_SNAPSHOT_VERSION
+  };
+};
+const serializeSchemaSnapshot = (snapshot) => `${JSON.stringify(snapshot, void 0, 2)}
+`;
+class SchemaSnapshotParseError extends Error {
+  name = "SchemaSnapshotParseError";
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isValidTableSnapshot = (value) => isRecord(value) && isRecord(value.fields) && isRecord(value.indexes) && isRecord(value.relations) && typeof value.shardMode === "string";
+const parseSchemaSnapshot = (content) => {
+  if (content === void 0 || content.trim() === "") {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    throw new SchemaSnapshotParseError(`baseline is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed) || parsed.version !== SCHEMA_SNAPSHOT_VERSION || !isRecord(parsed.tables)) {
+    throw new SchemaSnapshotParseError(`baseline is malformed or written by an incompatible version (expected version ${String(SCHEMA_SNAPSHOT_VERSION)})`);
+  }
+  for (const [name, table] of Object.entries(parsed.tables)) {
+    if (!isValidTableSnapshot(table)) {
+      throw new SchemaSnapshotParseError(`baseline table "${name}" has an invalid structure`);
+    }
+  }
+  const jurisdiction = typeof parsed.jurisdiction === "string" ? parsed.jurisdiction : void 0;
+  return {
+    jurisdiction,
+    migrationIds: Array.isArray(parsed.migrationIds) ? parsed.migrationIds : [],
+    tables: parsed.tables,
+    version: SCHEMA_SNAPSHOT_VERSION
+  };
+};
+const indexesEqual = (a, b) => a.unique === b.unique && a.fields.length === b.fields.length && a.fields.every((field, index) => field === b.fields[index]);
+const diffExistingField = (tableName, name, old, field) => {
+  const changes = [];
+  if (old.kind !== field.kind) {
+    changes.push({
+      severity: "breaking",
+      summary: `field ${tableName}.${name} changed type: ${old.kind} → ${field.kind} — add a data migration to convert existing values`,
+      type: "changedFieldKind"
+    });
+  }
+  if (old.optional && !field.optional) {
+    changes.push({
+      severity: "breaking",
+      summary: `field ${tableName}.${name} became required — rows missing it would be invalid; add a data migration to backfill it`,
+      type: "fieldOptionalToRequired"
+    });
+  } else if (!old.optional && field.optional) {
+    changes.push({ severity: "safe", summary: `field ${tableName}.${name} became optional`, type: "fieldRequiredToOptional" });
+  }
+  return changes;
+};
+const addedFieldChange = (tableName, name, field) => field.optional ? { severity: "safe", summary: `added optional field ${tableName}.${name}`, type: "addedOptionalField" } : {
+  severity: "breaking",
+  summary: `added required field ${tableName}.${name} — existing rows have no value; add a data migration to backfill it`,
+  type: "addedRequiredField"
+};
+const diffFields = (tableName, baseline, current, changes) => {
+  for (const [name, field] of Object.entries(current.fields)) {
+    const old = baseline.fields[name];
+    if (old === void 0) {
+      changes.push(addedFieldChange(tableName, name, field));
+    } else {
+      changes.push(...diffExistingField(tableName, name, old, field));
+    }
+  }
+  for (const name of Object.keys(baseline.fields)) {
+    if (current.fields[name] === void 0) {
+      changes.push({
+        severity: "breaking",
+        summary: `removed field ${tableName}.${name} — add a data migration if stored data must be cleaned up`,
+        type: "removedField"
+      });
+    }
+  }
+};
+const diffIndexes = (tableName, baseline, current, changes) => {
+  for (const [name, index] of Object.entries(current.indexes)) {
+    const old = baseline.indexes[name];
+    if (old === void 0) {
+      changes.push({ severity: "safe", summary: `added index ${name} on ${tableName}`, type: "addedIndex" });
+      continue;
+    }
+    if (!indexesEqual(old, index)) {
+      changes.push({
+        severity: "breaking",
+        summary: `index ${name} on ${tableName} changed shape — a query may have relied on the old index`,
+        type: "changedIndex"
+      });
+    }
+  }
+  for (const name of Object.keys(baseline.indexes)) {
+    if (current.indexes[name] === void 0) {
+      changes.push({
+        severity: "breaking",
+        summary: `removed index ${name} on ${tableName} — a query that used \`.withIndex("${name}")\` would break`,
+        type: "removedIndex"
+      });
+    }
+  }
+};
+const diffRelations = (tableName, baseline, current, changes) => {
+  for (const name of Object.keys(current.relations)) {
+    if (baseline.relations[name] === void 0) {
+      changes.push({ severity: "safe", summary: `added relation ${tableName}.${name}`, type: "addedRelation" });
+    }
+  }
+  for (const name of Object.keys(baseline.relations)) {
+    if (current.relations[name] === void 0) {
+      changes.push({ severity: "breaking", summary: `removed relation ${tableName}.${name}`, type: "removedRelation" });
+    }
+  }
+};
+const diffExistingTable = (tableName, baseline, current, changes) => {
+  if (baseline.shardMode !== current.shardMode) {
+    changes.push({
+      severity: "breaking",
+      summary: `table ${tableName} changed shard mode: ${baseline.shardMode} → ${current.shardMode} — its physical storage moves; add a data migration / re-shard plan`,
+      type: "changedShardMode"
+    });
+  }
+  diffFields(tableName, baseline, current, changes);
+  diffIndexes(tableName, baseline, current, changes);
+  diffRelations(tableName, baseline, current, changes);
+};
+const diffSchemaSnapshots = (baseline, current) => {
+  const changes = [];
+  const baselineTables = baseline?.tables ?? {};
+  for (const [tableName, table] of Object.entries(current.tables)) {
+    const old = baselineTables[tableName];
+    if (old === void 0) {
+      changes.push({ severity: "safe", summary: `added table ${tableName}`, type: "addedTable" });
+      continue;
+    }
+    diffExistingTable(tableName, old, table, changes);
+  }
+  for (const tableName of Object.keys(baselineTables)) {
+    if (current.tables[tableName] === void 0) {
+      changes.push({
+        severity: "breaking",
+        summary: `removed table ${tableName} — add a data migration if its data must be archived/cleaned up`,
+        type: "removedTable"
+      });
+    }
+  }
+  if (baseline !== void 0 && baseline.jurisdiction !== current.jurisdiction) {
+    const from = baseline.jurisdiction ?? "(none)";
+    const to = current.jurisdiction ?? "(none)";
+    changes.push({
+      severity: "breaking",
+      summary: `Durable Object jurisdiction changed from ${from} to ${to} — this re-homes every DO and strands all existing shard, scheduler, and session-DO data in the old region (no in-place migration; export then import to move it). Revert the change, or override the gate to proceed intentionally.`,
+      type: "changedJurisdiction"
+    });
+  }
+  return { changes };
+};
+const evaluateSchemaDrift = (options) => {
+  const { allowDrift = false, baseline, current } = options;
+  const drift = diffSchemaSnapshots(baseline, current);
+  const breaking = drift.changes.filter((change) => change.severity === "breaking");
+  const newMigrationIds = current.migrationIds.filter((id) => !(baseline?.migrationIds ?? []).includes(id));
+  if (drift.changes.length === 0 || baseline === void 0) {
+    return { blocked: false, changes: drift.changes, newMigrationIds, reason: "" };
+  }
+  if (breaking.length === 0) {
+    const summary = drift.changes.map((change) => `  - ${change.summary}`).join("\n");
+    return { blocked: false, changes: drift.changes, newMigrationIds, reason: `schema drift detected (all additive/safe):
+${summary}` };
+  }
+  const breakingSummary = breaking.map((change) => `  - ${change.summary}`).join("\n");
+  if (newMigrationIds.length > 0) {
+    return {
+      blocked: false,
+      changes: drift.changes,
+      newMigrationIds,
+      reason: `breaking schema drift detected, but ${String(newMigrationIds.length)} new migration(s) were added (${newMigrationIds.join(", ")}):
+${breakingSummary}`
+    };
+  }
+  const reason = `deploy blocked: ${String(breaking.length)} breaking schema change(s) detected since the last blessed schema baseline — these changes are incompatible with existing data without a migration:
+${breakingSummary}
+
+To fix:
+  • For breaking changes: add a \`defineMigration({ id, table, up })\` in lunora/ for each affected table, then run \`lunora migrate\` (or \`lunora codegen\`) to apply and re-bless the baseline.
+  • For backward-compatible changes (e.g. adding an optional field): pass \`--allow-schema-drift\` to skip the block.
+  • To accept the new shape without a migration (you know data is compatible): pass \`--update-schema-baseline\`.
+Docs: https://lunora.dev/docs/migrations`;
+  if (allowDrift) {
+    return { blocked: false, changes: drift.changes, newMigrationIds, reason: `${reason}
+
+(overridden by --allow-schema-drift)` };
+  }
+  return { blocked: true, changes: drift.changes, newMigrationIds, reason };
+};
+
+export { SCHEMA_SNAPSHOT_VERSION, SchemaSnapshotParseError, buildSchemaSnapshot, diffSchemaSnapshots, evaluateSchemaDrift, parseSchemaSnapshot, serializeSchemaSnapshot };

package/dist/packem_shared/WORKFLOWS_FILENAME-D62dcBGg.mjs

@@ -0,0 +1,84 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { workflowDefaultName, workflowClassName, workflowBindingName } from '@lunora/workflow';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+
+const WORKFLOWS_FILENAME = "workflows.ts";
+const isDefineWorkflow = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineWorkflow";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/workflow") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineWorkflow";
+  }
+  return false;
+};
+const stringProperty = (expression, exportName, property) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `workflow "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const workflowFromCall = (call, exportName) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(call, `workflow "${exportName}": defineWorkflow must be passed an inline object literal`);
+  }
+  const ir = {
+    bindingName: workflowBindingName(exportName),
+    className: workflowClassName(exportName),
+    exportName,
+    name: workflowDefaultName(exportName)
+  };
+  const nameProperty = argument.getProperty("name");
+  if (nameProperty && Node.isPropertyAssignment(nameProperty)) {
+    ir.name = stringProperty(nameProperty.getInitializerOrThrow(), exportName, "name");
+  }
+  return ir;
+};
+const workflowsFromSource = (source) => {
+  const workflows = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = initializer;
+    const callee = call.getExpression();
+    if (!Node.isIdentifier(callee) || !isDefineWorkflow(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineWorkflow exports must be plain named exports (no destructuring)");
+    }
+    workflows.push(workflowFromCall(call, nameNode.getText()));
+  }
+  return workflows;
+};
+const discoverWorkflows = (project, lunoraDirectory) => {
+  const workflowsPath = join(lunoraDirectory, WORKFLOWS_FILENAME);
+  if (!existsSync(workflowsPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(workflowsPath) ?? project.addSourceFileAtPath(workflowsPath);
+  const workflows = workflowsFromSource(source);
+  workflows.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return workflows;
+};
+
+export { WORKFLOWS_FILENAME, discoverWorkflows };

package/dist/packem_shared/buildOpenApiDocument-Cu3mZl-8.mjs

@@ -0,0 +1,183 @@
+import { GENERATED_HEADER } from './GENERATED_HEADER-BiFXNUvo.mjs';
+import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
+import { LUNORA_ERROR_CODES, objectSchema, argsObjectSchema, validatorIrToJsonSchema } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const ERROR_COMPONENT_REF = "#/components/responses/LunoraError";
+const ROUTE_PARAM_RE = /:([A-Za-z_$][\w$]*)/gu;
+const pathParameterNames = (path) => [...path.matchAll(ROUTE_PARAM_RE)].map((match) => match[1]);
+const toOpenApiPath = (path) => path.replaceAll(ROUTE_PARAM_RE, "{$1}");
+const buildParameters = (route) => {
+  const declaredPathNames = new Set(pathParameterNames(route.path));
+  const parameters = [];
+  for (const [name, validator] of Object.entries(route.searchParams)) {
+    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
+    parameters.push({
+      description: `Query parameter \`${name}\``,
+      in: "query",
+      name,
+      required: validator.kind !== "optional",
+      schema: validatorIrToJsonSchema(inner)
+    });
+  }
+  for (const [name, validator] of Object.entries(route.params)) {
+    const inner = validator.kind === "optional" ? validator.inner ?? validator : validator;
+    parameters.push({
+      description: `Path parameter \`${name}\``,
+      // A path param the template doesn't name is still surfaced (OpenAPI
+      // requires path params to be `required: true`), but flagged so the
+      // mismatch is visible rather than silently dropped.
+      in: declaredPathNames.has(name) ? "path" : "query",
+      name,
+      required: declaredPathNames.has(name) ? true : validator.kind !== "optional",
+      schema: validatorIrToJsonSchema(inner)
+    });
+  }
+  return parameters;
+};
+const successResponse = (output) => {
+  if (output) {
+    return {
+      content: { "application/json": { schema: validatorIrToJsonSchema(output) } },
+      description: "Successful response."
+    };
+  }
+  return {
+    content: { "application/json": { schema: { description: "Return shape is TS-inferred (no `.output()` declared); best-effort — any JSON." } } },
+    description: "Successful response. The return shape is TypeScript-inferred and not declared via `.output()`, so it is documented best-effort."
+  };
+};
+const httpRouteOperation = (route) => {
+  const tag = sanitizeNamespace(route.filePath);
+  const parameters = buildParameters(route);
+  const operation = {
+    description: `${route.stream ? "Streaming (SSE) " : ""}HTTP route handler \`${route.exportName}\` (${route.method} ${route.path}).`,
+    operationId: `${route.method.toLowerCase()}_${sanitizeNamespace(route.path)}`,
+    responses: {
+      "200": successResponse(route.output),
+      "204": { description: "No content (handler returned `undefined`)." },
+      default: { $ref: ERROR_COMPONENT_REF }
+    },
+    summary: `${route.method} ${route.path}`,
+    tags: [tag]
+  };
+  if (parameters.length > 0) {
+    operation.parameters = parameters;
+  }
+  if (Object.keys(route.body).length > 0) {
+    operation.requestBody = {
+      content: { "application/json": { schema: objectSchema(route.body) } },
+      required: true
+    };
+  }
+  if (route.stream) {
+    operation["x-lunora-stream"] = "text/event-stream";
+  }
+  return operation;
+};
+const rpcOperation = (definition) => {
+  const functionPath = `${sanitizeNamespace(definition.filePath)}:${definition.exportName}`;
+  const tag = sanitizeNamespace(definition.filePath);
+  const requestSchema = {
+    additionalProperties: false,
+    properties: {
+      args: argsObjectSchema(definition.args),
+      functionPath: { const: functionPath, type: "string" },
+      shardKey: { description: "Optional shard key; omitted routes to the default shard.", type: "string" }
+    },
+    required: ["functionPath"],
+    type: "object"
+  };
+  const operation = {
+    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc).`,
+    operationId: functionPath,
+    requestBody: {
+      content: { "application/json": { schema: requestSchema } },
+      required: true
+    },
+    responses: {
+      "200": {
+        content: {
+          "application/json": {
+            schema: { description: "RPC result. The shape is TS-inferred from the function's return type; best-effort — any JSON." }
+          }
+        },
+        description: "Successful RPC result (TypeScript-inferred return shape, documented best-effort)."
+      },
+      default: { $ref: ERROR_COMPONENT_REF }
+    },
+    summary: `${definition.kind}: ${functionPath}`,
+    tags: [tag],
+    "x-lunora-function-kind": definition.kind
+  };
+  return { operation, pathKey: `/_lunora/rpc#${functionPath}` };
+};
+const buildOpenApiDocument = (input) => {
+  const version = input.version ?? "0.0.0";
+  const paths = {};
+  const tagNames = /* @__PURE__ */ new Set();
+  for (const route of input.httpRoutes) {
+    const openApiPath = toOpenApiPath(route.path);
+    const pathItem = paths[openApiPath] ?? {};
+    pathItem[route.method.toLowerCase()] = httpRouteOperation(route);
+    paths[openApiPath] = pathItem;
+    tagNames.add(sanitizeNamespace(route.filePath));
+  }
+  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
+  for (const definition of rpcFunctions) {
+    const { operation, pathKey } = rpcOperation(definition);
+    paths[pathKey] = { post: operation };
+    tagNames.add(sanitizeNamespace(definition.filePath));
+  }
+  const tags = [...tagNames].toSorted((a, b) => a.localeCompare(b)).map((name) => {
+    return { description: `Operations declared in \`lunora/${name}\`.`, name };
+  });
+  const document = {
+    components: {
+      responses: {
+        LunoraError: {
+          content: {
+            "application/json": {
+              schema: {
+                additionalProperties: false,
+                description: "Standard Lunora error envelope.",
+                properties: {
+                  error: {
+                    additionalProperties: false,
+                    properties: {
+                      code: {
+                        description: "Machine-readable error code. Clients switch on this value.",
+                        enum: LUNORA_ERROR_CODES,
+                        type: "string"
+                      },
+                      message: { description: "Human-readable error message (never echoes internal details).", type: "string" }
+                    },
+                    required: ["code", "message"],
+                    type: "object"
+                  }
+                },
+                required: ["error"],
+                type: "object"
+              }
+            }
+          },
+          description: "A Lunora error response. The HTTP status reflects the error code (e.g. BAD_REQUEST→400, UNAUTHORIZED→401, FORBIDDEN→403, NOT_FOUND→404)."
+        }
+      }
+    },
+    info: {
+      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
+      title: "Lunora API",
+      version
+    },
+    openapi: "3.1.0",
+    paths,
+    tags
+  };
+  return document;
+};
+const emitOpenApi = (input) => `${JSON.stringify(buildOpenApiDocument(input), void 0, 2)}
+`;
+const emitOpenApiModule = (document_) => `${GENERATED_HEADER}export const openApiSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
+`;
+
+export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule };

package/dist/packem_shared/discover-ast-CT6BgBr4.mjs

@@ -0,0 +1,13 @@
+import { Node } from 'ts-morph';
+
+const TS_EXTENSION_RE = /\.ts$/u;
+const enclosingExportName = (call) => {
+  for (const ancestor of call.getAncestors()) {
+    if (Node.isVariableDeclaration(ancestor) && ancestor.getVariableStatement()?.hasExportKeyword() === true) {
+      return ancestor.getName();
+    }
+  }
+  return "";
+};
+
+export { TS_EXTENSION_RE as T, enclosingExportName as e };

package/dist/packem_shared/discoverAuthApiCalls-CoirYbg6.mjs

@@ -0,0 +1,62 @@
+import { relative, sep } from 'node:path';
+import { SyntaxKind, Node } from 'ts-morph';
+import { T as TS_EXTENSION_RE, e as enclosingExportName } from './discover-ast-CT6BgBr4.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-BWMczzBx.mjs';
+
+const isAuthApiCall = (call) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee)) {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver)) {
+    return receiver.getName() === "authApi";
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "authApi";
+};
+const hasHeadersProp = (call) => {
+  const argument = call.getArguments()[0];
+  if (argument === void 0) {
+    return false;
+  }
+  if (!Node.isObjectLiteralExpression(argument)) {
+    return true;
+  }
+  for (const property of argument.getProperties()) {
+    if ((Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property)) && property.getName() === "headers") {
+      return true;
+    }
+    if (Node.isSpreadAssignment(property)) {
+      return true;
+    }
+  }
+  return false;
+};
+const discoverAuthApiCalls = (project, lunoraDirectory) => {
+  const calls = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = relative(lunoraDirectory, filePath).replace(TS_EXTENSION_RE, "").split(sep).join("/");
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      if (!isAuthApiCall(call)) {
+        continue;
+      }
+      const exportName = enclosingExportName(call);
+      if (exportName === "") {
+        continue;
+      }
+      const callee = call.getExpression();
+      const method = Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+      calls.push({
+        exportName,
+        file: relativePath,
+        hasHeaders: hasHeadersProp(call),
+        line: call.getStartLineNumber(),
+        method
+      });
+    }
+  }
+  return calls;
+};
+
+export { discoverAuthApiCalls as default };