@workos/oagen-emitters 0.12.0 → 0.12.2

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","names":[],"sources":["../src/plugin.ts"],"mappings":";;;cA0Ba,oBAAA,EAAsB,IAAA,CAAK,WAAA"}
+{"version":3,"file":"plugin.d.mts","names":[],"sources":["../src/plugin.ts"],"mappings":";;;cA0Ba,oBAAA,EAAsB,IAAI,CAAC,WAAA"}

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-C408Wh-o.mjs";
+import { t as workosEmittersPlugin } from "./plugin-eCuvoL1T.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -38,22 +38,22 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.5.3",
-    "@commitlint/config-conventional": "^20.5.3",
-    "@types/node": "^25.6.0",
+    "@commitlint/cli": "^21.0.1",
+    "@commitlint/config-conventional": "^21.0.1",
+    "@types/node": "^25.8.0",
     "husky": "^9.1.7",
-    "oxfmt": "^0.48.0",
-    "oxlint": "^1.63.0",
+    "oxfmt": "^0.50.0",
+    "oxlint": "^1.65.0",
     "prettier": "^3.8.3",
-    "tsdown": "^0.21.10",
-    "tsx": "^4.21.0",
+    "tsdown": "^0.22.0",
+    "tsx": "^4.22.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.6"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.18.1"
+    "@workos/oagen": "^0.19.0"
   }
 }

package/renovate.json

@@ -1,25 +1,65 @@
 {
-  "extends": ["config:recommended"],
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
   "dependencyDashboard": false,
-  "schedule": ["on the 15th day of the month before 12pm"],
+  "schedule": [
+    "on the 15th day of the month before 12pm"
+  ],
   "timezone": "UTC",
   "rebaseWhen": "conflicted",
   "packageRules": [
     {
-      "matchManagers": ["github-actions"],
+      "matchManagers": [
+        "github-actions"
+      ],
+      "pinDigests": true,
       "extractVersion": "^v(?<version>\\d+\\.\\d+\\.\\d+)$"
     },
     {
-      "matchUpdateTypes": ["minor", "patch"],
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ],
       "automerge": true,
       "groupName": "minor and patch updates"
     },
     {
-      "matchUpdateTypes": ["major"],
+      "matchUpdateTypes": [
+        "major"
+      ],
       "automerge": false
     },
     {
-      "matchUpdateTypes": ["digest"],
+      "matchUpdateTypes": [
+        "digest"
+      ],
+      "automerge": false
+    },
+    {
+      "matchManagers": [
+        "github-actions"
+      ],
+      "matchUpdateTypes": [
+        "minor",
+        "patch",
+        "digest",
+        "pinDigest"
+      ],
+      "groupName": "github actions non-major",
+      "groupSlug": "github-actions-non-major",
+      "automerge": true
+    },
+    {
+      "matchManagers": [
+        "github-actions"
+      ],
+      "matchUpdateTypes": [
+        "major"
+      ],
+      "groupName": "github actions major",
+      "groupSlug": "github-actions-major",
       "automerge": false
     }
   ]

package/src/node/client.ts

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile } from '@workos/oagen';
 
-import { fileName, resolveServiceDir, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import { fileName, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import { isInlineEnum } from './type-map.js';
 import {
   docComment,
   createServiceDirResolver,
@@ -11,7 +12,9 @@ import {
   isListWrapperModel,
   computeNonEventReachable,
 } from './utils.js';
-import { resolveResourceClassName } from './resources.js';
+import { resolveResourceClassName, resolveResourceDir } from './resources.js';
+import { generatedResourceInterfaceModelNames } from './models.js';
+import { assignEnumsToServices } from './enums.js';
 
 export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
@@ -48,7 +51,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 = resolveServiceDir(resolvedName);
+    const serviceDir = resolveResourceDir(service, ctx);
     lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
   }
 
@@ -126,6 +129,7 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
   const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+  const enumToService = assignEnumsToServices(spec.enums, spec.services, spec.models, ctx);
 
   // Group interface files by directory, tracking exported symbol names
   // to prevent TS2308 duplicate export errors when two files in the same
@@ -189,7 +193,8 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // from common utils, so no per-resource interface file is generated.
   // Also skip unreachable models — use the same non-event reachability as model
   // generation so every barrel entry has a corresponding generated file.
-  const barrelReachable = computeNonEventReachable(spec.services, spec.models);
+  const barrelReachable =
+    generatedResourceInterfaceModelNames(spec.models, ctx) ?? computeNonEventReachable(spec.services, spec.models);
   for (const model of spec.models) {
     if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
     if (!barrelReachable.has(model.name)) continue;
@@ -226,7 +231,10 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
 
   // Enums -> service directories
   for (const enumDef of spec.enums) {
-    const enumService = findEnumService(enumDef.name, spec.services);
+    // Inlined enums have no file to re-export.
+    if (isInlineEnum(enumDef.name)) continue;
+
+    const enumService = enumToService.get(enumDef.name);
     const dirName = resolveDir(enumService);
     if (!dirExports.has(dirName)) {
       dirExports.set(dirName, []);
@@ -368,6 +376,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
 function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   const lines: string[] = [];
   const { modelToService, resolveDir } = createServiceDirResolver(spec.models, spec.services, ctx);
+  const enumToService = assignEnumsToServices(spec.enums, spec.services, spec.models, ctx);
 
   // Track all exported names to prevent duplicates.
   // Pre-seed with names already exported by the existing SDK to avoid generating
@@ -492,7 +501,7 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   // Per-service exports: service barrel + resource class
   for (const service of spec.services) {
     const resolvedName = resolveResourceClassName(service, ctx);
-    const serviceDir = resolveServiceDir(resolvedName);
+    const serviceDir = resolveResourceDir(service, ctx);
     // 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/).
@@ -508,7 +517,7 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
       return true;
     });
     const serviceEnums = spec.enums.filter((e) => {
-      const enumService = findEnumService(e.name, spec.services);
+      const enumService = enumToService.get(e.name);
       return enumService === service.name;
     });
 
@@ -575,7 +584,7 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   const reachable = computeNonEventReachable(spec.services, spec.models);
   const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name) && reachable.has(m.name));
   const commonEnums = spec.enums.filter((e) => {
-    const enumService = findEnumService(e.name, spec.services);
+    const enumService = enumToService.get(e.name);
     return !enumService;
   });
 
@@ -615,7 +624,7 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     if (exportedNames.has(enumDef.name)) continue;
     if (existingSdkExports.has(enumDef.name)) continue;
     exportedNames.add(enumDef.name);
-    const enumService = findEnumService(enumDef.name, spec.services);
+    const enumService = enumToService.get(enumDef.name);
     const dir = resolveDir(enumService);
     if (!exportedDirs.has(dir)) {
       const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
@@ -643,28 +652,6 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   };
 }
 
-function findEnumService(enumName: string, services: Service[]): string | undefined {
-  for (const service of services) {
-    for (const op of service.operations) {
-      const refs: string[] = [];
-      const collect = (ref: any) => {
-        if (ref?.kind === 'enum' && ref.name === enumName) refs.push(ref.name);
-        if (ref?.items) collect(ref.items);
-        if (ref?.inner) collect(ref.inner);
-        if (ref?.variants) ref.variants.forEach(collect);
-        if (ref?.valueType) collect(ref.valueType);
-      };
-      if (op.requestBody) collect(op.requestBody);
-      collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams]) {
-        collect(p.type);
-      }
-      if (refs.length > 0) return service.name;
-    }
-  }
-  return undefined;
-}
-
 /**
  * Determine whether the spec's auth scheme requires overriding the
  * default bearer auth in WorkOSBase.setAuthHeaders().

package/src/node/enums.ts

@@ -1,42 +1,43 @@
-import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { toPascalCase, walkTypeRef } from '@workos/oagen';
+import type { Enum, EmitterContext, GeneratedFile, Model, Service } from '@workos/oagen';
+import { assignModelsToServices, collectFieldDependencies, toPascalCase, walkTypeRef } from '@workos/oagen';
 import { fileName, resolveServiceDir, buildServiceNameMap } from './naming.js';
 import { docComment } from './utils.js';
+import { isInlineEnum } from './type-map.js';
+import { liveSurfaceConstEnumMembers, liveSurfaceInterfacePath } from './live-surface.js';
 
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
   if (enums.length === 0) return [];
 
-  const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+  const enumToService = assignEnumsToServices(enums, ctx.spec.services, ctx.spec.models, ctx);
   const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
   const resolveDir = (irService: string | undefined) =>
     irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : 'common';
   const files: GeneratedFile[] = [];
 
   for (const enumDef of enums) {
+    // Inlined enums get expanded at usage sites by `type-map`. No file needed.
+    if (isInlineEnum(enumDef.name)) continue;
+
     const service = enumToService.get(enumDef.name);
     const dirName = resolveDir(service);
 
-    // 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;
+    const baselineSourceFile =
+      (baselineEnum as any)?.sourceFile ?? (baselineAlias as any)?.sourceFile ?? liveSurfaceInterfacePath(enumDef.name);
+    if (dirName === 'common' && !baselineSourceFile && (ctx.outputDir || ctx.targetDir || ctx.apiSurface)) {
+      continue;
+    }
     if (baselineSourceFile && baselineSourceFile !== generatedPath) {
       continue;
     }
 
     const lines: string[] = [];
-
-    // Track whether the generated content has new values not in the baseline.
-    // When it does, skipIfExists must be false so the file gets updated.
     let hasNewValues = false;
 
     if (baselineEnum?.members) {
-      // Generate TS `enum` using baseline member names and values, merging
-      // any new IR values that the baseline is missing.
       const existingValues = new Set(Object.values(baselineEnum.members).map(String));
       const irValues = enumDef.values.map((v) => String(v.value));
       const missingValues = irValues.filter((v) => !existingValues.has(v));
@@ -47,21 +48,17 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
         const valueStr = typeof memberValue === 'string' ? `'${memberValue}'` : String(memberValue);
         lines.push(`  ${memberName} = ${valueStr},`);
       }
-      // 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 = toPascalCase(val);
         lines.push(`  ${memberName} = '${val}',`);
       }
       lines.push('}');
     } else if (baselineAlias?.value) {
-      // Use the baseline type alias value, but merge in any new IR values the baseline is missing.
       const baselineValues = extractLiteralUnionValues(baselineAlias.value);
       const irValues = enumDef.values.map((v) => String(v.value));
       const missing = irValues.filter((v) => !baselineValues.has(v));
       hasNewValues = missing.length > 0;
       if (missing.length > 0) {
-        // Baseline is missing values from the spec — regenerate with all values merged
         const allValues = [...baselineValues, ...missing];
         const parts = allValues.map((v) => `'${v}'`);
         lines.push(`export type ${enumDef.name} = ${parts.join(' | ')};`);
@@ -69,11 +66,36 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
         lines.push(`export type ${enumDef.name} = ${baselineAlias.value};`);
       }
     } else {
-      // No baseline — generate string literal union from IR values
+      // No baseline form available — emit the workos-node house style:
+      //
+      //   export const X = { Member: 'value', ... } as const;
+      //   export type X = (typeof X)[keyof typeof X];
+      //
+      // This dual declaration lets callers use either the type (`X`) or the
+      // namespace (`X.Member`) without paying for a TypeScript `enum`'s
+      // runtime overhead. Emitting only the type alias would compile but
+      // break hand-written test files that import the enum as a value.
+      //
+      // Member name resolution, per value:
+      //   1. If the live SDK already declares this enum as a const-object
+      //      with a member for this exact value, reuse the existing member
+      //      name. This preserves acronym casing (`DSync`, `SAML`, `JWT`)
+      //      that the simpler `toPascalCase` would otherwise flatten.
+      //   2. Otherwise PascalCase the value.
+      //   3. Skip duplicate values and duplicate member names — the union
+      //      type derived from the const captures every kept value.
       const values = enumDef.values;
-      lines.push(`export type ${enumDef.name} =`);
-      for (let i = 0; i < values.length; i++) {
-        const v = values[i];
+      const existingMembers = liveSurfaceConstEnumMembers(enumDef.name);
+      const seenMembers = new Set<string>();
+      const seenValues = new Set<string>();
+      lines.push(`export const ${enumDef.name} = {`);
+      for (const v of values) {
+        const valueKey = String(v.value);
+        if (seenValues.has(valueKey)) continue;
+        seenValues.add(valueKey);
+        const memberName = existingMembers?.get(valueKey) ?? toPascalCase(valueKey);
+        if (seenMembers.has(memberName)) continue;
+        seenMembers.add(memberName);
         const valueStr = typeof v.value === 'string' ? `'${v.value}'` : String(v.value);
         if (v.description || v.deprecated) {
           const parts: string[] = [];
@@ -81,16 +103,17 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
           if (v.deprecated) parts.push('@deprecated');
           lines.push(...docComment(parts.join('\n'), 2));
         }
-        const suffix = i === values.length - 1 ? ';' : '';
-        lines.push(`  | ${valueStr}${suffix}`);
+        lines.push(`  ${memberName}: ${valueStr},`);
       }
+      lines.push(`} as const;`);
+      lines.push('');
+      lines.push(`export type ${enumDef.name} =`);
+      lines.push(`  (typeof ${enumDef.name})[keyof typeof ${enumDef.name}];`);
     }
 
     files.push({
       path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
       content: lines.join('\n'),
-      // When the spec has new values the baseline is missing, allow the file
-      // to be updated so the SDK picks up the full set of enum values.
       skipIfExists: !hasNewValues,
     });
   }
@@ -98,13 +121,8 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   return files;
 }
 
-/**
- * Parse a TypeScript string literal union type alias value (e.g., "'a' | 'b' | 'c'")
- * into a set of its string values.
- */
 function extractLiteralUnionValues(aliasValue: string): Set<string> {
   const values = new Set<string>();
-  // Match all single-quoted string literals in the union
   const regex = /'([^']+)'/g;
   let match;
   while ((match = regex.exec(aliasValue)) !== null) {
@@ -113,7 +131,12 @@ function extractLiteralUnionValues(aliasValue: string): Set<string> {
   return values;
 }
 
-export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
+export function assignEnumsToServices(
+  enums: Enum[],
+  services: Service[],
+  models: Model[] = [],
+  ctx?: EmitterContext,
+): Map<string, string> {
   const enumToService = new Map<string, string>();
   const enumNames = new Set(enums.map((e) => e.name));
 
@@ -136,5 +159,19 @@ export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<s
     }
   }
 
+  if (models.length > 0) {
+    const modelToService = assignModelsToServices(models, services, ctx?.modelHints);
+    for (const model of models) {
+      const service = modelToService.get(model.name);
+      if (!service) continue;
+
+      for (const name of collectFieldDependencies(model).enums) {
+        if (enumNames.has(name) && !enumToService.has(name)) {
+          enumToService.set(name, service);
+        }
+      }
+    }
+  }
+
   return enumToService;
 }

package/src/node/errors.ts

@@ -3,7 +3,7 @@ import { fileName } from './naming.js';
 import { buildNodeStatusExceptions } from './sdk-errors.js';
 
 /**
- * Static exception classes are now hand-maintained in the target SDK.
+ * Static exception classes are hand-maintained in the target SDK.
  * Only typed exceptions derived from spec error models are generated here.
  */
 export function generateErrors(ctx?: EmitterContext): GeneratedFile[] {
@@ -45,8 +45,6 @@ export function generateErrors(ctx?: EmitterContext): GeneratedFile[] {
     exportLines.push(`export { ${exceptionClassName} } from './${fileName(modelName)}.exception';`);
   }
 
-  // Generate a barrel for typed errors only (appended to existing exceptions/index.ts
-  // via region preservation if needed)
   if (exportLines.length > 0) {
     files.push({
       path: 'src/common/exceptions/typed-errors.ts',
@@ -64,11 +62,7 @@ function collectTypedErrors(
 ): { modelName: string; statusCode: number; baseException: string | null }[] {
   const statusToBase = buildNodeStatusExceptions(ctx.spec.sdk);
   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) {