@workos/oagen-emitters 0.16.0 → 0.16.1

package/src/node/resources.ts

@@ -225,7 +225,12 @@ function ignoredResourceMethodNames(ctx: EmitterContext, resourcePath: string):
   const methods = new Set<string>();
   for (const block of content.matchAll(/@oagen-ignore-start[\s\S]*?@oagen-ignore-end/g)) {
     for (const line of block[0].split('\n')) {
-      const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/);
+      // Match the method name followed by `(` or by `<` — the latter covers
+      // generic methods (`getProfile<T extends ...>(...)`), including
+      // multi-line type-parameter lists where the line ends right after `<`.
+      // Matching only up to the opening bracket sidesteps balancing nested
+      // angle brackets like `<T extends Record<string, unknown> = ...>`.
+      const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*[<(]/);
       if (match) methods.add(match[1]);
     }
   }
@@ -310,6 +315,18 @@ function renderOptionsParam(param: OptionsObjectParam): string {
   return `options${param.optional ? '?' : ''}: ${param.type}`;
 }
 
+/**
+ * Whether a baseline-derived type reference is a plain TypeScript identifier
+ * that can appear in a named import. Baseline (live-SDK) method params can
+ * carry inline object-literal TYPES (e.g. `{ intent: GenerateLinkIntent; ... }`);
+ * treating that literal text as a type NAME would slugify it into a filename
+ * and emit a named import of a brace-expression — both invalid. Literal types
+ * are kept inline in the emitted signature instead and never imported.
+ */
+function isValidTypeIdentifier(name: string): boolean {
+  return /^[A-Za-z_$][\w$]*$/.test(name);
+}
+
 function autoPaginatableItemType(returnType: string | undefined): string | undefined {
   // Match both AutoPaginatable<T> and the legacy List<T> pattern so baseline
   // item types are extracted even when the hand-written code predates AutoPaginatable.
@@ -933,6 +950,9 @@ function generateResourceClass(service: Service, ctx: EmitterContext): Generated
 
   const importedTypeNames = new Set<string>();
   for (const optionType of optionObjectTypes) {
+    // Inline object-literal types from the baseline surface are rendered
+    // inline in the method signature — they have no importable name or file.
+    if (!isValidTypeIdentifier(optionType)) continue;
     if (importedTypeNames.has(optionType)) continue;
     importedTypeNames.add(optionType);
     const sourceFile = baselineTypeSourceFile(ctx, optionType);
@@ -1675,7 +1695,17 @@ function renderOptionsObjectMethod(
     const wireType = wireInterfaceName(itemType);
     const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
     const needsWireSerializer = extraParams.some((p) => fieldName(p.name) !== wireFieldName(p.name));
-    const paginationType = needsWireSerializer ? 'PaginationOptions' : optionParam.type;
+    // When path params are destructured out of the options object, the value
+    // passed to AutoPaginatable (and to fetchAndDeserialize) is the REST
+    // object — typed Omit<FullOptions, pathFields> — not the full options
+    // interface. Declaring the full interface as the second type argument
+    // fails TS2322 because the rest object lacks the required path-param
+    // fields, so parameterize over the rest type actually passed.
+    const restOptionsType =
+      pathBindings.length > 0
+        ? `Omit<${optionParam.type}, ${pathBindings.map((b) => `'${b}'`).join(' | ')}>`
+        : optionParam.type;
+    const paginationType = needsWireSerializer ? 'PaginationOptions' : restOptionsType;
     const returnType = needsWireSerializer
       ? `Promise<AutoPaginatable<${itemType}, ${paginationType}>>`
       : (preferredBaselineReturnType(ctx, baselineMethod?.returnType) ??
@@ -1793,7 +1823,13 @@ function renderOptionsObjectMethod(
 
     lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${methodReturnType} {`);
     renderOptionsObjectDestructure(lines, pathBindings);
-    lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${queryOptionsArg});`);
+    // POST/PUT/PATCH require the entity argument even without a request body —
+    // the client signature is `post(path, entity, options?)`, so a body-less
+    // call must still pass `{}` or the generated code fails with TS2554.
+    const emptyBodyArg = httpMethodNeedsBody(op.httpMethod) ? ', {}' : '';
+    lines.push(
+      `    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${emptyBodyArg}${queryOptionsArg});`,
+    );
     if (override?.returnExpression) {
       lines.push(`    const result = ${returnExpr};`);
       lines.push(`    return ${override.returnExpression};`);

package/src/node/utils.ts

@@ -11,12 +11,15 @@ import { mapTypeRef } from './type-map.js';
 import {
   resolveInterfaceName,
   fieldName,
+  fileName,
   resolveServiceDir,
   resolveMethodName,
   buildServiceNameMap,
 } from './naming.js';
-import { getMountTarget } from '../shared/resolved-ops.js';
-import { assignModelsToServices } from '@workos/oagen';
+import { getMountTarget, groupByMount } from '../shared/resolved-ops.js';
+import { assignModelsToServices, collectModelRefs, collectFieldDependencies } from '@workos/oagen';
+import { isNodeOwnedService } from './options.js';
+import { liveSurfaceHasExistingSdk, liveSurfaceHasFile } from './live-surface.js';
 
 /**
  * Compute a relative import path between two files within the generated SDK.
@@ -203,7 +206,7 @@ export function createServiceDirResolver(
   serviceNameMap: Map<string, string>;
   resolveDir: (irService: string | undefined) => string;
 } {
-  const modelToService = assignModelsToServices(models, services, ctx.modelHints);
+  const modelToService = assignModelsToEmittableServices(models, services, ctx);
   const serviceNameMap = buildServiceNameMap(services, ctx);
 
   // Per-name → directory override, harvested from the live SDK surface.
@@ -212,25 +215,7 @@ export function createServiceDirResolver(
   // baseline directory string (e.g., "user-management"). The override map is
   // attached by tagging the model name with a directory prefix that bypasses
   // the IR-service lookup. Concretely we keep a side map.
-  const baselineDirByModel = new Map<string, string>();
-  const recordSource = (name: string, info: { sourceFile?: string } | undefined) => {
-    const sourceFile = info?.sourceFile;
-    if (!sourceFile) return;
-    const m = sourceFile.match(/^src\/([^/]+)\//);
-    if (!m) return;
-    baselineDirByModel.set(name, m[1]);
-  };
-  // Both interfaces and type aliases can shadow IR model names — e.g.
-  // `type Role = EnvironmentRole | OrganizationRole;` is the live SDK's
-  // canonical Role definition even though the IR represents Role as a model.
-  for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) {
-    recordSource(name, info as { sourceFile?: string });
-  }
-  for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) {
-    if (!baselineDirByModel.has(name)) {
-      recordSource(name, info as { sourceFile?: string });
-    }
-  }
+  const baselineDirByModel = harvestBaselineDirByModel(ctx);
 
   // Override modelToService for any IR model that has a baseline sourceFile.
   // We invent a synthetic IR-service key that maps directly to the baseline
@@ -255,6 +240,139 @@ export function createServiceDirResolver(
   return { modelToService, serviceNameMap, resolveDir };
 }
 
+/**
+ * Map baseline interface / type-alias names to the top-level `src/<dir>/`
+ * their `sourceFile` lives in. Both kinds can shadow IR model names — e.g.
+ * `type Role = EnvironmentRole | OrganizationRole;` is the live SDK's
+ * canonical Role definition even though the IR represents Role as a model.
+ */
+function harvestBaselineDirByModel(ctx: EmitterContext): Map<string, string> {
+  const baselineDirByModel = new Map<string, string>();
+  const recordSource = (name: string, info: { sourceFile?: string } | undefined) => {
+    const sourceFile = info?.sourceFile;
+    if (!sourceFile) return;
+    const m = sourceFile.match(/^src\/([^/]+)\//);
+    if (!m) return;
+    baselineDirByModel.set(name, m[1]);
+  };
+  for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) {
+    recordSource(name, info as { sourceFile?: string });
+  }
+  for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) {
+    if (!baselineDirByModel.has(name)) {
+      recordSource(name, info as { sourceFile?: string });
+    }
+  }
+  return baselineDirByModel;
+}
+
+/**
+ * `assignModelsToServices` plus an owned-service correction pass.
+ *
+ * The engine's assignment is first-reference-wins: a model referenced by both
+ * Organizations and AuditLogs lands in `organizations/` even when only
+ * AuditLogs is owned this run. Against an existing SDK, `applyLiveSurface`
+ * then drops the model file (a non-owned, non-adopted directory cannot
+ * receive new paths) while the owned resource still imports
+ * `../organizations/interfaces/<model>.interface` — an import that resolves
+ * to nothing (TS2307).
+ *
+ * The correction re-homes such models to the owned service that references
+ * them, so emission and import planning agree on a directory that is allowed
+ * to receive files. It only fires when:
+ *  1. `ownedServices` is configured and the run targets an existing SDK;
+ *  2. the model has no baseline `sourceFile` (otherwise the baseline-dir
+ *     override keeps imports pointing at the on-disk location);
+ *  3. the model's computed interface path does not already exist on disk;
+ *  4. the assigned service is neither owned itself nor sharing a directory
+ *     with an owned service.
+ */
+export function assignModelsToEmittableServices(
+  models: Model[],
+  services: Service[],
+  ctx?: EmitterContext,
+): Map<string, string> {
+  const modelToService = assignModelsToServices(models, services, ctx?.modelHints);
+  if (ctx) {
+    reassignOwnedServiceDependencies(modelToService, models, services, ctx);
+  }
+  return modelToService;
+}
+
+function reassignOwnedServiceDependencies(
+  modelToService: Map<string, string>,
+  models: Model[],
+  services: Service[],
+  ctx: EmitterContext,
+): void {
+  const serviceNameMap = buildServiceNameMap(services, ctx);
+  // Ownership is a property of the MOUNT target, not the IR service: an op
+  // can live on a non-owned IR service (e.g. Organizations, because its path
+  // starts with /organizations) while being mounted on an owned service via
+  // `resolvedOperations` (e.g. AuditLogs' retention endpoints). Walking only
+  // IR services misses such ops entirely, so the models they reference stay
+  // assigned to the unemittable IR directory and are never emitted anywhere.
+  // Regroup by mount target when resolved operations exist — same as
+  // `buildGeneratedResourceModelUsage` and `computeOwnedServiceDirs`.
+  const mountGroups = groupByMount(ctx);
+  const candidateServices: Service[] =
+    mountGroups.size > 0 ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations })) : services;
+  const ownedServices = candidateServices.filter((s) => isNodeOwnedService(ctx, s.name, serviceNameMap.get(s.name)));
+  if (ownedServices.length === 0) return;
+  // Greenfield generation emits every directory; nothing is unemittable.
+  if (!liveSurfaceHasExistingSdk()) return;
+
+  const dirOf = (irService: string | undefined): string =>
+    irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : 'common';
+  const ownedDirs = new Set(ownedServices.map((s) => dirOf(s.name)));
+  const baselineDirByModel = harvestBaselineDirByModel(ctx);
+  const modelsByName = new Map(models.map((m) => [m.name, m]));
+
+  for (const service of ownedServices) {
+    for (const name of collectServiceModelClosure(service, modelsByName)) {
+      if (!modelsByName.has(name)) continue;
+      if (baselineDirByModel.has(name)) continue; // declared in the baseline → on disk
+      const assigned = modelToService.get(name);
+      if (assigned && isNodeOwnedService(ctx, assigned, serviceNameMap.get(assigned))) continue;
+      const assignedDir = dirOf(assigned);
+      if (ownedDirs.has(assignedDir)) continue;
+      if (liveSurfaceHasFile(`src/${assignedDir}/interfaces/${fileName(name)}.interface.ts`)) continue;
+      modelToService.set(name, service.name);
+    }
+  }
+}
+
+/** Model names referenced by a service's operations, expanded through fields. */
+function collectServiceModelClosure(service: Service, modelsByName: Map<string, Model>): Set<string> {
+  const referenced = new Set<string>();
+  const add = (ref: TypeRef | undefined): void => {
+    if (!ref) return;
+    for (const name of collectModelRefs(ref)) referenced.add(name);
+  };
+  for (const op of service.operations) {
+    add(op.requestBody);
+    add(op.response);
+    for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
+      add(param.type);
+    }
+    if (op.pagination) add(op.pagination.itemType);
+  }
+
+  const queue = [...referenced];
+  while (queue.length > 0) {
+    const name = queue.pop()!;
+    const model = modelsByName.get(name);
+    if (!model) continue;
+    for (const dep of collectFieldDependencies(model).models) {
+      if (!referenced.has(dep)) {
+        referenced.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return referenced;
+}
+
 /**
  * Check if baseline interface fields appear to contain generic type parameters.
  *

package/test/node/enums.test.ts

@@ -1,7 +1,13 @@
-import { describe, it, expect } from 'vitest';
-import type { EmitterContext, ApiSpec, Enum } from '@workos/oagen';
+import { describe, it, expect, vi } from 'vitest';
+import type { EmitterContext, ApiSpec, Enum, Model } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
 import { generateEnums } from '../../src/node/enums.js';
+import { nodeEmitter } from '../../src/node/index.js';
+import { emptyLiveSurface, setActiveLiveSurface } from '../../src/node/live-surface.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 
 const emptySpec: ApiSpec = {
   name: 'Test',
@@ -126,3 +132,234 @@ describe('generateEnums', () => {
     expect(result[0].content).toContain('/** @deprecated */');
   });
 });
+
+describe('assignEnumsToServices owned-service dependency reassignment', () => {
+  it('follows a reassigned dependency model into the owned service', () => {
+    // The enum is referenced only through `AuditLogsRetention`, whose
+    // first-reference assignment is Organizations (unemittable this run).
+    // When the owned AuditLogs service pulls the model into `audit-logs/`,
+    // the enum must follow — otherwise the model file imports an enum file
+    // that is emitted nowhere.
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    setActiveLiveSurface(surface);
+    try {
+      const enums: Enum[] = [
+        {
+          name: 'RetentionPeriod',
+          values: [
+            { name: 'THIRTY_DAYS', value: '30d' },
+            { name: 'NINETY_DAYS', value: '90d' },
+          ],
+        },
+      ];
+      const models = [
+        {
+          name: 'AuditLogsRetention',
+          fields: [
+            {
+              name: 'period',
+              type: { kind: 'enum' as const, name: 'RetentionPeriod', values: ['30d', '90d'] },
+              required: true,
+            },
+          ],
+        },
+      ];
+      const retentionOp = (name: string, path: string) => ({
+        name,
+        httpMethod: 'get' as const,
+        path,
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model' as const, name: 'AuditLogsRetention' },
+        errors: [],
+        injectIdempotencyKey: false,
+      });
+      const services = [
+        { name: 'Organizations', operations: [retentionOp('getRetention', '/organizations/{id}/retention')] },
+        { name: 'AuditLogs', operations: [retentionOp('getAuditLogsRetention', '/audit_logs/retention')] },
+      ];
+      const ctxOwned: EmitterContext = {
+        ...ctx,
+        spec: { ...emptySpec, enums, models, services },
+        emitterOptions: { ownedServices: ['AuditLogs'] },
+      } as EmitterContext;
+
+      const result = generateEnums(enums, ctxOwned);
+      expect(result).toHaveLength(1);
+      expect(result[0].path).toBe('src/audit-logs/interfaces/retention-period.interface.ts');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+});
+
+describe('owned-service enum emission under the live-surface skip', () => {
+  function ownedDomainSpec(enums: Enum[], models: Model[]): ApiSpec {
+    return {
+      ...emptySpec,
+      enums,
+      models,
+      services: [
+        {
+          name: 'OrganizationDomains',
+          operations: [
+            {
+              name: 'getOrganizationDomain',
+              httpMethod: 'get',
+              path: '/organization_domains/{id}',
+              pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'OrganizationDomain' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  const stateEnum: Enum = {
+    name: 'OrganizationDomainState',
+    values: [
+      { name: 'VERIFIED', value: 'verified' },
+      { name: 'PENDING', value: 'pending' },
+    ],
+  };
+  const domainModel: Model = {
+    name: 'OrganizationDomain',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      {
+        name: 'state',
+        type: { kind: 'enum', name: 'OrganizationDomainState', values: ['verified', 'pending'] },
+        required: true,
+      },
+    ],
+  };
+
+  it('still emits the union module when the name is declared in a file the owned regeneration overwrites', () => {
+    // Real instance (OrganizationDomains rebuild, service OWNED): the
+    // on-disk organization-domain.interface.ts declared the enum names, so
+    // the live-surface skip suppressed emitting the canonical modules — but
+    // that very file was simultaneously being OVERWRITTEN by the owned
+    // regeneration, leaving the names declared nowhere.
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    surface.files.add('src/organization-domains/interfaces/organization-domain.interface.ts');
+    surface.interfaces.set('OrganizationDomainState', {
+      filePath: 'src/organization-domains/interfaces/organization-domain.interface.ts',
+      fields: new Set(),
+    });
+    setActiveLiveSurface(surface);
+    try {
+      const ctxOwned: EmitterContext = {
+        ...ctx,
+        spec: ownedDomainSpec([stateEnum], [domainModel]),
+        emitterOptions: { ownedServices: ['OrganizationDomains'] },
+      } as EmitterContext;
+
+      const result = generateEnums([stateEnum], ctxOwned);
+      const enumFile = result.find(
+        (f) => f.path === 'src/organization-domains/interfaces/organization-domain-state.interface.ts',
+      );
+      expect(enumFile).toBeDefined();
+      expect(enumFile!.content).toContain('export const OrganizationDomainState = {');
+      expect(enumFile!.content).toContain('export type OrganizationDomainState =');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('keeps the skip for non-owned services whose enum genuinely lives elsewhere', () => {
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts');
+    surface.interfaces.set('OrganizationDomainState', {
+      filePath: 'src/common/interfaces/organization-domain-state.interface.ts',
+      fields: new Set(),
+    });
+    setActiveLiveSurface(surface);
+    try {
+      const ctxNotOwned: EmitterContext = {
+        ...ctx,
+        spec: ownedDomainSpec([stateEnum], [domainModel]),
+      } as EmitterContext;
+
+      const result = generateEnums([stateEnum], ctxNotOwned);
+      expect(result).toHaveLength(0);
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('emits the module, resolves the barrel export, and imports the name in the model file', () => {
+    // End-to-end shape of the OrganizationDomains failure: generated
+    // organization-domain.interface.ts used `OrganizationDomainState` with
+    // NO import, and interfaces/index.ts exported
+    // ./organization-domain-state.interface — a module no hook ever emitted.
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'node-owned-enum-'));
+    try {
+      const ifaceDir = path.join(tmpRoot, 'src', 'organization-domains', 'interfaces');
+      fs.mkdirSync(ifaceDir, { recursive: true });
+      fs.writeFileSync(path.join(tmpRoot, 'src', 'workos.ts'), 'export class WorkOS {}\n');
+      fs.writeFileSync(
+        path.join(ifaceDir, 'organization-domain.interface.ts'),
+        [
+          "export type OrganizationDomainState = 'verified' | 'pending';",
+          '',
+          'export interface OrganizationDomain {',
+          '  id: string;',
+          '  state: OrganizationDomainState;',
+          '}',
+        ].join('\n'),
+      );
+      execFileSync('git', ['init'], { cwd: tmpRoot, stdio: 'ignore' });
+      execFileSync('git', ['add', 'src'], { cwd: tmpRoot, stdio: 'ignore' });
+
+      const spec = ownedDomainSpec([stateEnum], [domainModel]);
+      const runCtx = {
+        ...ctx,
+        spec,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['OrganizationDomains'] },
+      } as EmitterContext;
+
+      const modelFiles = nodeEmitter.generateModels([domainModel], runCtx);
+      const enumFiles = nodeEmitter.generateEnums([stateEnum], runCtx);
+      const clientFiles = nodeEmitter.generateClient(spec, runCtx);
+
+      // The canonical union module IS emitted…
+      const enumPath = 'src/organization-domains/interfaces/organization-domain-state.interface.ts';
+      expect(enumFiles.some((f) => f.path === enumPath)).toBe(true);
+
+      // …the model file imports the name from it…
+      const modelFile = modelFiles.find(
+        (f) => f.path === 'src/organization-domains/interfaces/organization-domain.interface.ts',
+      );
+      expect(modelFile).toBeDefined();
+      expect(modelFile!.content).toContain(
+        "import type { OrganizationDomainState } from './organization-domain-state.interface';",
+      );
+
+      // …and the barrel export resolves to an emitted module instead of a
+      // phantom the import-invariant pass has to drop.
+      const barrel = clientFiles.find((f) => f.path === 'src/organization-domains/interfaces/index.ts');
+      expect(barrel).toBeDefined();
+      expect(barrel!.content).toContain("export * from './organization-domain-state.interface';");
+
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        nodeEmitter.generateTests(spec, runCtx);
+        const dropped = warnSpy.mock.calls.filter((call) => String(call[0]).includes('dropped unresolvable'));
+        expect(dropped).toEqual([]);
+      } finally {
+        warnSpy.mockRestore();
+      }
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});