@workos/oagen-emitters 0.14.3 → 0.15.0

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.3",
+  "version": "0.15.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -38,22 +38,22 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@commitlint/cli": "^21.0.1",
-    "@commitlint/config-conventional": "^21.0.1",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
-    "oxfmt": "^0.51.0",
-    "oxlint": "^1.66.0",
+    "oxfmt": "^0.52.0",
+    "oxlint": "^1.67.0",
     "prettier": "^3.8.3",
-    "tsdown": "^0.22.0",
-    "tsx": "^4.22.3",
+    "tsdown": "^0.22.1",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.20.0"
+    "@workos/oagen": "^0.21.1"
   }
 }

package/renovate.json

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

package/src/go/client.ts

@@ -17,7 +17,7 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
 }
 
 /**
- * Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+ * Non-spec services marked with `hasClientAccessor: true` (e.g. passwordless)
  * are included in the generated Client struct, constructor, and accessor methods
  * — identical to spec-driven services. Their service type (e.g. PasswordlessService)
  * is defined in a hand-written @oagen-ignore-file, but the Client wiring is generated.

package/src/go/enums.ts

@@ -96,6 +96,8 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     content: lines.join('\n'),
     overwriteExisting: true,
   });
+  const eventConstantsFile = generateEventConstantsFile(enums);
+  if (eventConstantsFile) files.push(eventConstantsFile);
 
   return files;
 }
@@ -173,6 +175,81 @@ function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
   return aliasOf;
 }
 
+function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
+  const enumDef = findWebhookEventEnum(enums);
+  if (!enumDef) return null;
+
+  const lines: string[] = [];
+  lines.push('package events');
+  lines.push('');
+  lines.push('// Event is a WorkOS event type.');
+  lines.push('type Event string');
+  lines.push('');
+  lines.push('const (');
+
+  const seenValues = new Set<string>();
+  const usedNames = new Set<string>();
+  for (const value of enumDef.values) {
+    const valueStr = String(value.value);
+    if (seenValues.has(valueStr)) continue;
+    seenValues.add(valueStr);
+
+    const constName = uniqueEventConstantName(valueStr, usedNames);
+    usedNames.add(constName);
+
+    if (value.description) {
+      lines.push(`\t// ${constName} is ${value.description}.`);
+    }
+    if (value.deprecated) {
+      if (value.description) lines.push('\t//');
+      lines.push('\t// Deprecated: this value is deprecated.');
+    }
+    // Keep constants untyped so callers can use them as plain strings,
+    // events.Event values, or typed root-package enum values.
+    lines.push(`\t${constName} = "${escapeGoString(valueStr)}"`);
+  }
+
+  lines.push(')');
+  lines.push('');
+
+  return {
+    path: 'pkg/events/events.go',
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  };
+}
+
+function findWebhookEventEnum(enums: Enum[]): Enum | null {
+  return (
+    enums.find((enumDef) => enumDef.name === 'CreateWebhookEndpointEvents') ??
+    enums.find(
+      (enumDef) =>
+        isWebhookEventEnumName(enumDef.name) &&
+        enumDef.values.length > 0 &&
+        enumDef.values.every((value) => typeof value.value === 'string' && value.value.includes('.')),
+    ) ??
+    null
+  );
+}
+
+function isWebhookEventEnumName(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return normalized.includes('webhook') && normalized.includes('event');
+}
+
+function uniqueEventConstantName(value: string, usedNames: Set<string>): string {
+  const base = className(value);
+  if (!usedNames.has(base)) return base;
+
+  let suffix = 2;
+  while (usedNames.has(`${base}${suffix}`)) suffix++;
+  return `${base}${suffix}`;
+}
+
+function escapeGoString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
   const enumToService = new Map<string, string>();
   const enumNames = new Set(enums.map((e) => e.name));

package/src/kotlin/enums.ts

@@ -41,12 +41,19 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
 
   // Within each group, pick the shortest className as canonical.
   const aliasOf = new Map<string, string>(); // enum name → canonical enum name
+  const sharedSortEmitters = new Set<string>();
   for (const [, group] of hashGroups) {
-    if (group.length <= 1) continue;
+    if (group.length <= 1) {
+      if (group.length === 1 && isSharedSortOrderEnum(group[0])) {
+        enumCanonicalMap.set(group[0].name, 'SortOrder');
+        sharedSortEmitters.add(group[0].name);
+      }
+      continue;
+    }
     if (group.every(isSharedSortOrderEnum)) {
       const [canonical, ...rest] = [...group].sort((a, b) => a.name.localeCompare(b.name));
-      enumCanonicalMap.set(canonical.name, canonical.name);
-      for (const enumDef of rest) enumCanonicalMap.set(enumDef.name, 'SortOrder');
+      sharedSortEmitters.add(canonical.name);
+      for (const enumDef of [canonical, ...rest]) enumCanonicalMap.set(enumDef.name, 'SortOrder');
       continue;
     }
     const sorted = [...group].sort(
@@ -68,7 +75,7 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
     const typeName = canonicalEnumTypeName(enumDef);
 
     // Non-canonical enum: emit a typealias instead of a full enum class.
-    const sharedSortEmitter = isSharedSortOrderEnum(enumDef) && enumCanonicalMap.get(enumDef.name) === enumDef.name;
+    const sharedSortEmitter = sharedSortEmitters.has(enumDef.name);
     const canonicalName = sharedSortEmitter
       ? undefined
       : (aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name));

package/src/node/client.ts

@@ -18,9 +18,11 @@ import {
   isListWrapperModel,
   computeNonEventReachable,
 } from './utils.js';
+import { isNodeOwnedService, nodeOptions } from './options.js';
 import { resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generatedResourceInterfaceModelNames } from './models.js';
 import { assignEnumsToServices } from './enums.js';
+import { liveSurfaceInterfacePath } from './live-surface.js';
 
 export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
@@ -129,6 +131,46 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   };
 }
 
+function sourceFileForExportedType(ctx: EmitterContext, typeName: string): string | undefined {
+  return (
+    (ctx.apiSurface?.interfaces?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.typeAliases?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.enums?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    liveSurfaceInterfacePath(typeName)
+  );
+}
+
+function exportedNamesForSource(ctx: EmitterContext, sourceFile: string): string[] {
+  const names = new Set<string>();
+  const addNamesFromSurface = (items: Record<string, unknown> | undefined) => {
+    if (!items) return;
+    for (const [name, item] of Object.entries(items)) {
+      if ((item as { sourceFile?: string }).sourceFile === sourceFile) {
+        names.add(name);
+      }
+    }
+  };
+
+  addNamesFromSurface(ctx.apiSurface?.interfaces);
+  addNamesFromSurface(ctx.apiSurface?.typeAliases);
+  addNamesFromSurface(ctx.apiSurface?.enums);
+
+  const rootDir = ctx.targetDir ?? ctx.outputDir;
+  if (rootDir) {
+    try {
+      const content = fs.readFileSync(path.join(rootDir, sourceFile), 'utf-8');
+      for (const match of content.matchAll(/export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/g)) {
+        names.add(match[1]);
+      }
+    } catch {
+      // The live source map is best-effort; apiSurface/livesurface names above
+      // are enough when the file is not readable.
+    }
+  }
+
+  return [...names];
+}
+
 /**
  * Generate per-service barrel files (interfaces/index.ts) that re-export
  * all interface and enum files for each service directory. This reduces
@@ -146,6 +188,12 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // from one file and a domain type from another).
   const dirExports = new Map<string, string[]>();
   const dirSymbols = new Map<string, Set<string>>();
+  const ownedDirNames = new Set<string>();
+  for (const service of spec.services) {
+    if (isNodeOwnedService(ctx, service.name)) {
+      ownedDirNames.add(resolveDir(service.name));
+    }
+  }
 
   // Pre-seed dirSymbols with names already exported by existing interface files.
   // When the existing SDK has an interface file in a directory that already
@@ -160,6 +208,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
     if (!match) return;
     const dirName = match[1];
+    if (ownedDirNames.has(dirName)) return;
     const fileStem = match[2];
     if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, new Set());
     dirSymbols.get(dirName)!.add(name);
@@ -260,14 +309,82 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     dirExports.get(dirName)!.push(`export * from './${fileName(enumDef.name)}.interface';`);
   }
 
+  const overrideWildcardSources = new Set<string>();
+  const overrideNamedExports = new Set<string>();
+  const addOverrideTypeExport = (typeName: string | undefined) => {
+    if (!typeName) return;
+    const sourceFile = sourceFileForExportedType(ctx, typeName);
+    if (!sourceFile) return;
+    const match = sourceFile?.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+    if (!match) return;
+    const dirName = match[1];
+    const stem = match[2].replace(/\.ts$/, '');
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    const sourceKey = `${dirName}/${stem}`;
+    if (overrideWildcardSources.has(sourceKey)) return;
+
+    const sourceNames = exportedNamesForSource(ctx, sourceFile);
+    const hasConflictingNeighbor = sourceNames.some((name) => name !== typeName && globalExistingSymbols.has(name));
+    if (hasConflictingNeighbor) {
+      const exportKey = `${sourceKey}:${typeName}`;
+      if (overrideNamedExports.has(exportKey)) return;
+      dirExports.get(dirName)!.push(`export type { ${typeName} } from './${stem}';`);
+      overrideNamedExports.add(exportKey);
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      return;
+    }
+
+    dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    overrideWildcardSources.add(sourceKey);
+    const namesToRegister = sourceNames.length > 0 ? sourceNames : [typeName];
+    for (const name of namesToRegister) {
+      symbols.add(name);
+      globalExistingSymbols.add(name);
+    }
+  };
+
+  for (const override of Object.values(nodeOptions(ctx).operationOverrides ?? {})) {
+    addOverrideTypeExport(override.optionsType);
+    for (const typeName of override.returnTypeImports ?? []) {
+      addOverrideTypeExport(typeName);
+    }
+  }
+
+  const generatedOptionExports = (ctx as any)._nodeGeneratedOptionInterfaceExports as
+    | Map<string, Array<{ stem: string; typeName: string }>>
+    | undefined;
+  for (const [dirName, options] of generatedOptionExports ?? []) {
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    for (const { stem, typeName } of options) {
+      if (globalExistingSymbols.has(typeName)) continue;
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    }
+  }
+
   for (const [dirName, exports] of dirExports) {
     const exportSet = new Set(exports);
+    const isDirOwned = ownedDirNames.has(dirName);
 
     // 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) {
+    if (ctx.apiSurface && !isDirOwned) {
       const addBaselineExports = (items: Record<string, any> | undefined) => {
         if (!items) return;
         for (const item of Object.values(items)) {
@@ -288,7 +405,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
       // corresponding file still exists on disk.  This prevents dropping
       // hand-written types (e.g., Factor in multi-factor-auth) when a
       // generated model in the same file causes a symbol collision.
-      if (ctx.targetDir) {
+      if (ctx.targetDir && !isDirOwned) {
         const interfacesDir = path.join(ctx.targetDir, 'src', dirName, 'interfaces');
         try {
           const barrelPath = path.join(interfacesDir, 'index.ts');

package/src/node/discriminated-models.ts

@@ -69,6 +69,8 @@ interface DiscriminatedShape {
   discriminatorProperty: string;
   /** Field name in domain (camelCase). */
   discriminatorPropertyDomain: string;
+  /** Description from the OpenAPI spec, if present. */
+  discriminatorDescription?: string;
   variants: VariantSpec[];
 }
 
@@ -124,20 +126,23 @@ export function detectDiscriminatedShape(
       return {
         nameSuffix: variantNameSuffix(discValue),
         discriminatorValue: discValue,
-        fields: variantFields(fv, discProp, modelName, rawSchemas),
+        fields: variantFields(fv, discProp, modelName),
       };
     })
     .filter((v): v is VariantSpec => v !== null);
 
   if (variants.length !== flattenedVariants.length) return null;
 
-  const baseFields = baseObject ? collectObjectFields(baseObject, modelName, rawSchemas) : [];
+  const baseFields = baseObject ? collectObjectFields(baseObject, modelName) : [];
+
+  const discriminatorDescription = flattenedVariants[0].alwaysProperties.get(discProp)?.description;
 
   return {
     modelName,
     baseFields,
     discriminatorProperty: discProp,
     discriminatorPropertyDomain: toCamelCase(discProp),
+    discriminatorDescription,
     variants,
   };
 }
@@ -146,7 +151,7 @@ function mergeBase(prev: RawSchema | null, next: RawSchema): RawSchema {
   if (!prev) return next;
   return {
     type: 'object',
-    properties: { ...(prev.properties ?? {}), ...(next.properties ?? {}) },
+    properties: { ...prev.properties, ...next.properties },
     required: [...new Set([...(prev.required ?? []), ...(next.required ?? [])])],
   };
 }
@@ -328,48 +333,33 @@ function variantNameSuffix(constValue: string): string {
 // Field extraction
 // ---------------------------------------------------------------------------
 
-function collectObjectFields(
-  schema: RawSchema,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec[] {
+function collectObjectFields(schema: RawSchema, parentName: string): FieldSpec[] {
   const props = schema.properties ?? {};
   const required = new Set(schema.required ?? []);
   const fields: FieldSpec[] = [];
   for (const [name, propSchema] of Object.entries(props)) {
-    fields.push(buildField(name, propSchema, required.has(name), parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, required.has(name), parentName));
   }
   return fields;
 }
 
-function variantFields(
-  fv: FlattenedVariant,
-  discriminatorProperty: string,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec[] {
+function variantFields(fv: FlattenedVariant, discriminatorProperty: string, parentName: string): FieldSpec[] {
   const fields: FieldSpec[] = [];
   for (const [name, propSchema] of fv.alwaysProperties) {
     if (name === discriminatorProperty) continue;
-    fields.push(buildField(name, propSchema, fv.required.has(name), parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, fv.required.has(name), parentName));
   }
   for (const [name, propSchema] of fv.optionalProperties) {
     if (name === discriminatorProperty) continue;
-    fields.push(buildField(name, propSchema, false, parentName, rawSchemas));
+    fields.push(buildField(name, propSchema, false, parentName));
   }
   return fields;
 }
 
-function buildField(
-  rawName: string,
-  schema: RawSchema,
-  required: boolean,
-  parentName: string,
-  rawSchemas: Record<string, RawSchema>,
-): FieldSpec {
+function buildField(rawName: string, schema: RawSchema, required: boolean, parentName: string): FieldSpec {
   const modelDeps = new Set<string>();
-  const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps, rawSchemas);
-  const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps, rawSchemas);
+  const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps);
+  const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps);
   return {
     name: rawName,
     description: schema.description,
@@ -404,7 +394,6 @@ function rawSchemaToTS(
   fieldName: string,
   isWire: boolean,
   modelDeps: Set<string>,
-  rawSchemas: Record<string, RawSchema>,
 ): string {
   if (schema.$ref) {
     const refName = schema.$ref.split('/').pop()!;
@@ -428,7 +417,7 @@ function rawSchemaToTS(
   } else if (baseType === 'boolean') {
     core = 'boolean';
   } else if (baseType === 'array' && schema.items) {
-    const items = rawSchemaToTS(schema.items, parentName, singularize(fieldName), isWire, modelDeps, rawSchemas);
+    const items = rawSchemaToTS(schema.items, parentName, singularize(fieldName), isWire, modelDeps);
     core = `${parenthesizeUnion(items)}[]`;
   } else if (baseType === 'object' && schema.properties) {
     // Inline object — refer to the synthetic model name that
@@ -543,6 +532,9 @@ function buildInterfaceBody(name: string, shape: DiscriminatedShape, variant: Va
   }
   // Discriminator (typed as the variant's const value)
   const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
+  if (shape.discriminatorDescription) {
+    lines.push(`  /** ${shape.discriminatorDescription} */`);
+  }
   lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
   // Variant-specific fields
   for (const field of variant.fields) {