@workos/oagen-emitters 0.2.0 → 0.3.0

package/src/node/client.ts

@@ -1,5 +1,6 @@
 import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { fileName, serviceDirName, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import { collectReferencedNames } from '@workos/oagen';
+import { fileName, resolveServiceDir, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
 import {
   docComment,
   createServiceDirResolver,
@@ -15,9 +16,7 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
   files.push(generateWorkOSClient(spec, ctx));
   files.push(...generateServiceBarrels(spec, ctx));
   files.push(generateBarrel(spec, ctx));
-  files.push(generateWorkerBarrel(spec, ctx));
-  files.push(generatePackageJson(ctx));
-  files.push(generateTsConfig());
+  // worker barrel, package.json, tsconfig.json are now hand-maintained in the target SDK
 
   return files;
 }
@@ -46,7 +45,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 +98,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,
+  };
 }
 
 /**
@@ -124,47 +127,36 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // exports a name (e.g., AuditLogSchema from create-audit-log-schema-options),
   // the generated model with the same name must be skipped to prevent the
   // merger from adding a duplicate `export *` that causes TS2308.
+  //
+  // Also track baseline file stems per directory so we can detect when the
+  // barrel needs updating with new export lines (see hasNewExports below).
+  const dirSymbolsFromBaseline = new Map<string, Set<string>>();
+  const seedFromBaseline = (sourceFile: string, name: string) => {
+    const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+    if (!match) return;
+    const dirName = match[1];
+    const fileStem = match[2];
+    if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, new Set());
+    dirSymbols.get(dirName)!.add(name);
+    if (!dirSymbolsFromBaseline.has(dirName)) dirSymbolsFromBaseline.set(dirName, new Set());
+    dirSymbolsFromBaseline.get(dirName)!.add(fileStem);
+  };
   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;
-      // Match paths like "src/audit-logs/interfaces/foo.interface.ts" to directory "audit-logs"
-      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
-      if (match) {
-        const dirName = match[1];
-        if (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, name);
     }
   }
   if (ctx.apiSurface?.enums) {
     for (const [name, enumDef] of Object.entries(ctx.apiSurface.enums)) {
       const sourceFile = (enumDef as any).sourceFile as string | undefined;
-      if (!sourceFile) continue;
-      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
-      if (match) {
-        const dirName = match[1];
-        if (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, 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 (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, name);
     }
   }
 
@@ -183,8 +175,12 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // Models -> service directories
   // Skip list wrapper and list metadata models — they use shared List<T>/ListMetadata
   // from common utils, so no per-resource interface file is generated.
+  // Also skip unreachable models — oagen only passes service-referenced models
+  // to generateModels, so unreachable models have no interface file to export.
+  const barrelReachable = collectReferencedNames(spec.services, spec.models);
   for (const model of spec.models) {
     if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
+    if (!barrelReachable.models.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
     if (!dirExports.has(dirName)) {
@@ -236,14 +232,57 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   }
 
   for (const [dirName, exports] of dirExports) {
-    // Deduplicate (an enum and model could theoretically share a file name)
-    const uniqueExports = [...new Set(exports)];
+    const exportSet = new Set(exports);
+
+    // When integrating into an existing SDK, include baseline exports from
+    // the api-surface so the barrel is comprehensive.  This ensures stale
+    // entries (e.g., renamed files from previous generations) are removed
+    // when overwriteExisting replaces the barrel.
+    if (ctx.apiSurface) {
+      const addBaselineExports = (items: Record<string, any> | undefined) => {
+        if (!items) return;
+        for (const item of Object.values(items)) {
+          const sourceFile = (item as any).sourceFile as string | undefined;
+          if (!sourceFile) continue;
+          const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+          if (match && match[1] === dirName) {
+            exportSet.add(`export * from './${match[2].replace(/\.ts$/, '')}';`);
+          }
+        }
+      };
+      addBaselineExports(ctx.apiSurface.interfaces);
+      addBaselineExports(ctx.apiSurface.typeAliases);
+      addBaselineExports(ctx.apiSurface.enums);
+    }
+
+    // Deduplicate and sort
+    const uniqueExports = [...exportSet];
     uniqueExports.sort();
-    files.push({
-      path: `src/${dirName}/interfaces/index.ts`,
-      content: uniqueExports.join('\n'),
-      skipIfExists: true,
-    });
+
+    if (ctx.apiSurface) {
+      // Integration mode: overwrite the barrel so stale entries are removed.
+      files.push({
+        path: `src/${dirName}/interfaces/index.ts`,
+        content: uniqueExports.join('\n'),
+        overwriteExisting: true,
+      });
+    } else {
+      // Standalone generation: only update if there are new exports.
+      const baselineSymbols = dirSymbolsFromBaseline.get(dirName);
+      const hasNewExports = baselineSymbols
+        ? uniqueExports.some((exp) => {
+            const match = exp.match(/from '\.\/(.*?)'/);
+            if (!match) return false;
+            return !baselineSymbols.has(match[1]);
+          })
+        : false;
+
+      files.push({
+        path: `src/${dirName}/interfaces/index.ts`,
+        content: uniqueExports.join('\n'),
+        skipIfExists: !hasNewExports,
+      });
+    }
   }
 
   return files;
@@ -315,10 +354,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 +435,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
@@ -383,7 +492,11 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   }
 
   // Unassigned models (common) — use barrel if any exist
-  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name));
+  // Filter to reachable models only: oagen's generateAllFiles passes only
+  // service-referenced models to generateModels, so unreachable models
+  // never get interface files.  Exporting them here would create broken imports.
+  const reachable = collectReferencedNames(spec.services, spec.models);
+  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name) && reachable.models.has(m.name));
   const commonEnums = spec.enums.filter((e) => {
     const enumService = findEnumService(e.name, spec.services);
     return !enumService;
@@ -446,20 +559,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 };
-}
-
-/**
- * Generate a worker-compatible barrel file that re-exports everything from
- * the main barrel. This keeps type exports in sync automatically.
- */
-function generateWorkerBarrel(_spec: ApiSpec, _ctx: EmitterContext): GeneratedFile {
-  const lines: string[] = [];
-
-  // 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.ts',
+    content: lines.join('\n'),
+    skipIfExists: true,
+  };
 }
 
 function findEnumService(enumName: string, services: Service[]): string | undefined {
@@ -528,62 +632,3 @@ function serverConstName(description: string): string {
       .toUpperCase()
   );
 }
-
-function generatePackageJson(ctx: EmitterContext): GeneratedFile {
-  const pkg = {
-    name: `@${ctx.namespace}/sdk`,
-    version: '0.0.0',
-    type: 'module',
-    main: 'src/index.ts',
-    types: 'src/index.ts',
-    exports: {
-      '.': './src/index.ts',
-    },
-    scripts: {
-      test: 'jest',
-      build: 'tsc',
-    },
-    devDependencies: {
-      typescript: '^5.0.0',
-      jest: '^29.0.0',
-      'jest-fetch-mock': '^3.0.0',
-      '@types/jest': '^29.0.0',
-      'ts-jest': '^29.0.0',
-    },
-  };
-
-  return {
-    path: 'package.json',
-    content: JSON.stringify(pkg, null, 2),
-    skipIfExists: true,
-    integrateTarget: false,
-  };
-}
-
-function generateTsConfig(): GeneratedFile {
-  const config = {
-    compilerOptions: {
-      target: 'ES2020',
-      module: 'CommonJS',
-      lib: ['ES2020'],
-      declaration: true,
-      strict: true,
-      exactOptionalPropertyTypes: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      forceConsistentCasingInFileNames: true,
-      resolveJsonModule: true,
-      outDir: './lib',
-      rootDir: './src',
-    },
-    include: ['src/**/*'],
-    exclude: ['node_modules', 'lib', '**/*.spec.ts'],
-  };
-
-  return {
-    path: 'tsconfig.json',
-    content: JSON.stringify(config, null, 2),
-    skipIfExists: true,
-    integrateTarget: false,
-  };
-}

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) {
@@ -19,6 +19,15 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     // Check baseline surface for representation and values
     const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
     const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
+    const generatedPath = `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`;
+
+    // If the baseline already provides this enum from a different file (e.g., `.enum.ts`),
+    // skip generation to avoid duplicate exports from the same barrel.
+    const baselineSourceFile = (baselineEnum as any)?.sourceFile ?? (baselineAlias as any)?.sourceFile;
+    if (baselineSourceFile && baselineSourceFile !== generatedPath) {
+      continue;
+    }
+
     const lines: string[] = [];
 
     // Track whether the generated content has new values not in the baseline.
@@ -41,7 +50,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('}');