@workos/oagen-emitters 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -58,7 +58,7 @@
     "sdk:extract:rust": "oagen extract --lang rust --sdk-path ../backend/workos-rust --output ./sdk-rust-surface.json"
   },
   "dependencies": {
-    "@workos/oagen": "^0.2.0"
+    "@workos/oagen": "^0.3.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",

package/smoke/sdk-dotnet.ts

@@ -115,7 +115,12 @@ function createProxyServer(apiKey: string, captures: ProxyCapture[]): Promise<{
             }
 
             captures.push({
-              request: { method: req.method!, path: url.pathname, queryParams, body },
+              request: {
+                method: req.method!,
+                path: url.pathname,
+                queryParams,
+                body,
+              },
               response: { status: proxyRes.statusCode!, body: resBody },
             });
 
@@ -689,7 +694,11 @@ async function main(): Promise<void> {
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -858,7 +867,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-elixir.ts

@@ -103,7 +103,12 @@ function startProxy(
           }
         }
 
-        const capturedReq: CapturedRequest = { method, path, queryParams, body: reqBody };
+        const capturedReq: CapturedRequest = {
+          method,
+          path,
+          queryParams,
+          body: reqBody,
+        };
 
         // Forward to real API
         const forwardHeaders: Record<string, string> = {
@@ -467,7 +472,11 @@ async function main(): Promise<void> {
 
     // Build planned calls for this wave, resolving methods
     const plannedCalls: PlannedCall[] = [];
-    const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+    const waveSkipped: Array<{
+      op: Operation;
+      irService: string;
+      reason: string;
+    }> = [];
 
     for (const { op, irService, pathParams } of wave.calls) {
       const resolution = resolveMethod(op, irService, manifest);
@@ -726,7 +735,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-go.ts

@@ -257,7 +257,12 @@ class CaptureProxy {
       }
     }
 
-    const capturedReq: CapturedRequest = { method, path, queryParams, body: parsedReqBody };
+    const capturedReq: CapturedRequest = {
+      method,
+      path,
+      queryParams,
+      body: parsedReqBody,
+    };
 
     // Forward to the real API
     const targetUrl = new URL(path, this.targetBaseUrl);
@@ -580,7 +585,11 @@ async function main(): Promise<void> {
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -655,7 +664,10 @@ async function main(): Promise<void> {
         execSync('go build -o smoke-driver main.go', {
           cwd: tmpDir,
           timeout: 120_000,
-          env: { ...process.env, GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go') },
+          env: {
+            ...process.env,
+            GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go'),
+          },
           encoding: 'utf-8',
           stdio: ['pipe', 'pipe', 'pipe'],
         });
@@ -903,7 +915,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-kotlin.ts

@@ -123,7 +123,12 @@ function createProxyServer(
             }
 
             captures.push({
-              request: { method: req.method!, path: url.pathname, queryParams, body },
+              request: {
+                method: req.method!,
+                path: url.pathname,
+                queryParams,
+                body,
+              },
               response: { status: proxyRes.statusCode!, body: resBody },
             });
 
@@ -135,7 +140,12 @@ function createProxyServer(
         proxyReq.on('error', (err) => {
           console.error('Proxy request error:', err.message);
           captures.push({
-            request: { method: req.method!, path: url.pathname, queryParams, body },
+            request: {
+              method: req.method!,
+              path: url.pathname,
+              queryParams,
+              body,
+            },
             response: { status: 502, body: { error: err.message } },
           });
           res.writeHead(502);
@@ -499,7 +509,11 @@ async function main(): Promise<void> {
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -754,7 +768,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-node.ts

@@ -52,7 +52,10 @@ interface CapturedResponse {
 // HTTP Interception
 // ---------------------------------------------------------------------------
 
-let currentCapture: { request: CapturedRequest; response: CapturedResponse } | null = null;
+let currentCapture: {
+  request: CapturedRequest;
+  response: CapturedResponse;
+} | null = null;
 const originalFetch = globalThis.fetch;
 
 function interceptFetch(): void {
@@ -259,7 +262,11 @@ async function main(): Promise<void> {
   const groups = planOperations(spec);
   const ids = new IdRegistry();
   const exchanges: CapturedExchange[] = [];
-  const createdEntities: Array<{ service: string; id: string; deleteFn?: () => Promise<void> }> = [];
+  const createdEntities: Array<{
+    service: string;
+    id: string;
+    deleteFn?: () => Promise<void>;
+  }> = [];
   const delayMs = Number(process.env.SMOKE_DELAY_MS) || 200;
 
   let successCount = 0;
@@ -452,7 +459,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-ruby.ts

@@ -160,7 +160,12 @@ function startProxy(
           }
         }
 
-        const capturedReq: CapturedRequest = { method, path, queryParams, body: reqBody };
+        const capturedReq: CapturedRequest = {
+          method,
+          path,
+          queryParams,
+          body: reqBody,
+        };
 
         // Forward to real API
         const forwardHeaders: Record<string, string> = {
@@ -420,7 +425,11 @@ async function main(): Promise<void> {
 
     // Build planned calls for this wave, resolving methods
     const plannedCalls: PlannedCall[] = [];
-    const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+    const waveSkipped: Array<{
+      op: Operation;
+      irService: string;
+      reason: string;
+    }> = [];
 
     for (const { op, irService, pathParams } of wave.calls) {
       const resolution = resolveMethod(op, irService, manifest);
@@ -678,7 +687,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/smoke/sdk-rust.ts

@@ -452,7 +452,11 @@ serde_json = "1"
 
       // Build planned calls for this wave, resolving methods
       const plannedCalls: PlannedCall[] = [];
-      const waveSkipped: Array<{ op: Operation; irService: string; reason: string }> = [];
+      const waveSkipped: Array<{
+        op: Operation;
+        irService: string;
+        reason: string;
+      }> = [];
 
       for (const { op, irService, pathParams } of wave.calls) {
         const resolution = resolveMethod(op, irService, manifest);
@@ -534,7 +538,11 @@ serde_json = "1"
         await new Promise<void>((resolvePromise, rejectPromise) => {
           const child = spawn(join(tmpDir, 'target', 'debug', 'smoke-driver'), [], {
             cwd: tmpDir,
-            env: { ...process.env, WORKOS_API_KEY: apiKey, WORKOS_BASE_URL: `http://localhost:${proxy.port}` },
+            env: {
+              ...process.env,
+              WORKOS_API_KEY: apiKey,
+              WORKOS_BASE_URL: `http://localhost:${proxy.port}`,
+            },
             stdio: ['pipe', 'pipe', 'pipe'],
           });
 
@@ -729,7 +737,12 @@ function makeSkippedExchange(op: Operation, service: string, reason: string): Ca
     operationId: op.name,
     service,
     operationName: op.name,
-    request: { method: op.httpMethod.toUpperCase(), path: op.path, queryParams: {}, body: null },
+    request: {
+      method: op.httpMethod.toUpperCase(),
+      path: op.path,
+      queryParams: {},
+      body: null,
+    },
     response: { status: 0, body: null },
     outcome: 'skipped',
     error: reason,

package/src/node/client.ts

@@ -1,5 +1,5 @@
 import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { fileName, serviceDirName, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import { fileName, resolveServiceDir, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
 import {
   docComment,
   createServiceDirResolver,
@@ -46,7 +46,7 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   for (const service of spec.services) {
     if (coveredServices.has(service.name)) continue;
     const resolvedName = resolveResourceClassName(service, ctx);
-    const serviceDir = serviceDirName(resolvedName);
+    const serviceDir = resolveServiceDir(resolvedName);
     lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
   }
 
@@ -99,7 +99,11 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   lines.push('}');
 
-  return { path: 'src/workos.ts', content: lines.join('\n'), skipIfExists: true };
+  return {
+    path: 'src/workos.ts',
+    content: lines.join('\n'),
+    skipIfExists: true,
+  };
 }
 
 /**
@@ -315,10 +319,68 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   // Track directories that have already been wildcard-exported
   const exportedDirs = new Set<string>();
 
+  // Pre-compute all names per interfaces directory (generated + baseline) to detect
+  // cross-directory conflicts before emitting any star exports.  A star export is
+  // unsafe when two different directories export the same name (e.g., Factor in
+  // both mfa/interfaces and user-management/interfaces).
+  const dirAllNames = new Map<string, Set<string>>();
+  for (const service of spec.services) {
+    const iDir = resolveDir(service.name);
+    if (!dirAllNames.has(iDir)) dirAllNames.set(iDir, new Set());
+    const names = dirAllNames.get(iDir)!;
+    for (const model of spec.models) {
+      if (modelToService.get(model.name) !== service.name) continue;
+      if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
+      names.add(resolveInterfaceName(model.name, ctx));
+      names.add(wireInterfaceName(resolveInterfaceName(model.name, ctx)));
+    }
+  }
+  // Add baseline names per directory
+  if (ctx.apiSurface?.interfaces) {
+    for (const [name, iface] of Object.entries(ctx.apiSurface.interfaces)) {
+      const sourceFile = (iface as any).sourceFile as string | undefined;
+      if (!sourceFile) continue;
+      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
+      if (match) {
+        const dirName = match[1];
+        if (!dirAllNames.has(dirName)) dirAllNames.set(dirName, new Set());
+        dirAllNames.get(dirName)!.add(name);
+      }
+    }
+  }
+  if (ctx.apiSurface?.typeAliases) {
+    for (const [name, alias] of Object.entries(ctx.apiSurface.typeAliases)) {
+      const sourceFile = (alias as any).sourceFile as string | undefined;
+      if (!sourceFile) continue;
+      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
+      if (match) {
+        const dirName = match[1];
+        if (!dirAllNames.has(dirName)) dirAllNames.set(dirName, new Set());
+        dirAllNames.get(dirName)!.add(name);
+      }
+    }
+  }
+  // Detect directories with cross-directory name conflicts
+  const unsafeStarDirs = new Set<string>();
+  const allDirEntries = [...dirAllNames.entries()];
+  for (let i = 0; i < allDirEntries.length; i++) {
+    for (let j = i + 1; j < allDirEntries.length; j++) {
+      const [dirA, namesA] = allDirEntries[i];
+      const [dirB, namesB] = allDirEntries[j];
+      for (const name of namesA) {
+        if (namesB.has(name)) {
+          unsafeStarDirs.add(dirA);
+          unsafeStarDirs.add(dirB);
+          break;
+        }
+      }
+    }
+  }
+
   // Per-service exports: service barrel + resource class
   for (const service of spec.services) {
     const resolvedName = resolveResourceClassName(service, ctx);
-    const serviceDir = serviceDirName(resolvedName);
+    const serviceDir = resolveServiceDir(resolvedName);
     // The interfaces directory may differ from the resource class directory when
     // a service's class name is remapped (e.g., WebhooksEndpoints class lives in
     // webhooks-endpoints/ but its model interfaces live in webhooks/).
@@ -338,13 +400,25 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
       return enumService === service.name;
     });
 
-    // Check whether any model or enum in this service conflicts with existingSdkExports.
-    // If so, fall back to individual exports to avoid shadowing hand-written types.
+    // Check whether any model or enum in this service conflicts with names already
+    // exported (from earlier star exports or the existing SDK baseline).  If so, fall
+    // back to individual named exports to avoid duplicate-export TS2308 errors.
     const hasConflict =
-      serviceModels.some((m) => existingSdkExports.has(resolveInterfaceName(m.name, ctx))) ||
-      serviceEnums.some((e) => existingSdkExports.has(e.name));
-
-    if ((serviceModels.length > 0 || serviceEnums.length > 0) && !exportedDirs.has(interfacesDir) && !hasConflict) {
+      serviceModels.some((m) => {
+        const name = resolveInterfaceName(m.name, ctx);
+        return existingSdkExports.has(name) || exportedNames.has(name) || exportedNames.has(wireInterfaceName(name));
+      }) || serviceEnums.some((e) => existingSdkExports.has(e.name) || exportedNames.has(e.name));
+
+    // Skip star export for covered services — their directory may have hand-written types
+    // (e.g., Factor in mfa/) that conflict with types in the covering service's directory.
+    const isCovered = coveredServicesBarrel.has(service.name);
+    if (
+      (serviceModels.length > 0 || serviceEnums.length > 0) &&
+      !exportedDirs.has(interfacesDir) &&
+      !hasConflict &&
+      !unsafeStarDirs.has(interfacesDir) &&
+      !isCovered
+    ) {
       exportedDirs.add(interfacesDir);
       lines.push(`export * from './${interfacesDir}/interfaces';`);
       // Track the individual names so they don't get re-exported below
@@ -446,7 +520,11 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     lines.push("export { WorkOS } from './workos';");
   }
 
-  return { path: 'src/index.ts', content: lines.join('\n'), skipIfExists: true };
+  return {
+    path: 'src/index.ts',
+    content: lines.join('\n'),
+    skipIfExists: true,
+  };
 }
 
 /**
@@ -459,7 +537,11 @@ function generateWorkerBarrel(_spec: ApiSpec, _ctx: EmitterContext): GeneratedFi
   // Re-export everything from the main index — keeps type exports in sync
   lines.push("export * from './index';");
 
-  return { path: 'src/index.worker.ts', content: lines.join('\n'), skipIfExists: true };
+  return {
+    path: 'src/index.worker.ts',
+    content: lines.join('\n'),
+    skipIfExists: true,
+  };
 }
 
 function findEnumService(enumName: string, services: Service[]): string | undefined {

package/src/node/common.ts

@@ -225,7 +225,7 @@ export function fetchBody({ raw = false } = {}): any {
 export function testUnauthorized(fn: () => Promise<any>) {
   it('throws on unauthorized', async () => {
     fetchOnce({ message: 'Unauthorized' }, { status: 401 });
-    await expect(fn()).rejects.toThrow('Unauthorized');
+    await expect(fn()).rejects.toThrow('Could not authorize the request');
   });
 }
 

package/src/node/enums.ts

@@ -1,6 +1,6 @@
 import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { walkTypeRef } from '@workos/oagen';
-import { fileName, serviceDirName, buildServiceNameMap } from './naming.js';
+import { toPascalCase, walkTypeRef } from '@workos/oagen';
+import { fileName, resolveServiceDir, buildServiceNameMap } from './naming.js';
 import { docComment } from './utils.js';
 
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
@@ -9,7 +9,7 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   const enumToService = assignEnumsToServices(enums, ctx.spec.services);
   const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
   const resolveDir = (irService: string | undefined) =>
-    irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : 'common';
+    irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : 'common';
   const files: GeneratedFile[] = [];
 
   for (const enumDef of enums) {
@@ -41,7 +41,7 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       // Append new values from the spec that the baseline is missing
       for (const val of missingValues) {
         // Derive a PascalCase member name from the value
-        const memberName = val.replace(/[^a-zA-Z0-9]+/g, '');
+        const memberName = toPascalCase(val);
         lines.push(`  ${memberName} = '${val}',`);
       }
       lines.push('}');

package/src/node/errors.ts

@@ -258,7 +258,11 @@ function collectTypedErrors(
   ctx: EmitterContext,
 ): { modelName: string; statusCode: number; baseException: string | null }[] {
   const seen = new Set<string>();
-  const results: { modelName: string; statusCode: number; baseException: string | null }[] = [];
+  const results: {
+    modelName: string;
+    statusCode: number;
+    baseException: string | null;
+  }[] = [];
 
   for (const service of ctx.spec.services) {
     for (const op of service.operations) {

package/src/node/fixtures.ts

@@ -1,5 +1,5 @@
 import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
-import { wireFieldName, fileName, serviceDirName } from './naming.js';
+import { wireFieldName, fileName, resolveServiceDir } from './naming.js';
 import { resolveResourceClassName } from './resources.js';
 import { createServiceDirResolver, assignModelsToServices, isListMetadataModel, isListWrapperModel } from './utils.js';
 
@@ -42,7 +42,7 @@ export function generateFixtures(
     ? createServiceDirResolver(spec.models, ctx.spec.services, ctx)
     : {
         modelToService: assignModelsToServices(spec.models, spec.services),
-        resolveDir: (irService: string | undefined) => (irService ? serviceDirName(irService) : 'common'),
+        resolveDir: (irService: string | undefined) => (irService ? resolveServiceDir(irService) : 'common'),
       };
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -66,7 +66,7 @@ export function generateFixtures(
   // Generate list fixtures for models that appear in paginated responses
   for (const service of spec.services) {
     const resolvedName = ctx ? resolveResourceClassName(service, ctx) : service.name;
-    const serviceDir = serviceDirName(resolvedName);
+    const serviceDir = resolveServiceDir(resolvedName);
     for (const op of service.operations) {
       if (op.pagination) {
         let itemModel = op.pagination.itemType.kind === 'model' ? modelMap.get(op.pagination.itemType.name) : null;
@@ -175,7 +175,9 @@ function generateFieldValue(
       }
       return null;
     case 'map':
-      return { key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap) };
+      return {
+        key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap),
+      };
   }
 }