@workos/oagen-emitters 0.13.0 → 0.14.0

package/src/node/index.ts

@@ -16,6 +16,8 @@ import { generateEnums as generateEnumFiles } from './enums.js';
 import { generateResources, resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests as generateTestFiles } from './tests.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+import { planDiscriminatedModels, generateDiscriminatedFiles } from './discriminated-models.js';
 import { buildLiveSurface, emptyLiveSurface, setActiveLiveSurface, type LiveSurface } from './live-surface.js';
 import {
   setBaselineSerializedNames,
@@ -214,7 +216,10 @@ function computeOwnedServiceDirs(ctx: EmitterContext): Set<string> {
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -233,7 +238,10 @@ function computeAdoptedServiceDirs(ctx: EmitterContext, surface: LiveSurface): S
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -350,19 +358,58 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
   return out;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields from the raw spec onto each
+ * model. `enrichModelsFromSpec` produces (a) extra optional fields on models
+ * whose schema is `allOf [base, oneOf [...]]`, and (b) synthetic models /
+ * enums for inline objects encountered inside variants (e.g. the inline
+ * `redirect_uris` item shape on `ConnectApplication`).
+ *
+ * Node, like Go / Kotlin / .NET, emits flat interfaces rather than a sum
+ * type, so on `enrichModelsFromSpec`-marked discriminated bases we restore
+ * the original IR fields — otherwise the base interface would be empty.
+ * A future change can emit a real TS discriminated union; for now the goal
+ * is parity with the other flat-emit languages so every variant field is
+ * at least reachable.
+ */
+function enrichModelsForNode(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const nodeEmitter: Emitter = {
   language: 'node',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateModelsAndSerializers(models, nodeCtx), nodeCtx, surface);
+    const enriched = enrichModelsForNode(models);
+    // Detect `allOf [base, oneOf [variant, …]]` schemas and hand them off
+    // to the discriminated-models module. Leave the model in the standard
+    // pipeline's input so its field-type deps stay reachable, but stash the
+    // name set on ctx so models.ts skips emitting an interface/serializer —
+    // the discriminated module owns those paths instead.
+    const discPlans = planDiscriminatedModels(enriched, nodeCtx);
+    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = new Set(discPlans.keys());
+    const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
+    const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
+    return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateEnumFiles(enums, nodeCtx), nodeCtx, surface);
+    const syntheticEnums = getSyntheticEnums();
+    return applyLiveSurface(generateEnumFiles([...enums, ...syntheticEnums], nodeCtx), nodeCtx, surface);
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
@@ -374,7 +421,11 @@ export const nodeEmitter: Emitter = {
   generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateClient(spec, nodeCtx), nodeCtx, surface);
+    // `nodeCtx.spec` has the synthetic models that `enrichModelsFromSpec`
+    // produced (e.g. inline-object item types like `ConnectApplicationRedirectUri`).
+    // The `spec` param is the engine's pre-enrichment spec, so the barrel
+    // generator would miss those synthetic interfaces. Use the enriched one.
+    return applyLiveSurface(generateClient(nodeCtx.spec, nodeCtx), nodeCtx, surface);
   },
 
   // workos-node ships its own exception hierarchy under src/common/exceptions/.

package/src/node/models.ts

@@ -130,6 +130,13 @@ function isSupportedFieldType(
       // silently dropped on first emission because the target interface
       // (`UserObject` under the adopted `connect/` dir) hasn't landed yet.
       if (isAdoptedModelName(ref.name)) return true;
+      // Synthetic models produced by `enrichModelsFromSpec` (e.g. the
+      // inline-object item type for `ConnectApplication.redirect_uris`)
+      // are added to the models list passed into this generation pass —
+      // and hence into `shared.modelToService` — but won't yet exist on
+      // disk or in `apiSurface`. Accept them so their parent field
+      // survives field-projection.
+      if (shared.modelToService.has(ref.name)) return true;
       const relPath = `src/${shared.resolveDir(shared.modelToService.get(ref.name))}/interfaces/${fileName(ref.name)}.interface.ts`;
       return liveSurfaceHasManagedFile(relPath);
     }
@@ -201,12 +208,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
     }
   }
 
+  const discriminatedSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
     if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
+    if (discriminatedSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
@@ -723,6 +732,7 @@ export function generateSerializers(
     }
   }
 
+  const discriminatedSerializerSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -730,6 +740,7 @@ export function generateSerializers(
     if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
+    if (discriminatedSerializerSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
@@ -928,7 +939,10 @@ function buildGeneratedResourceModelUsage(
   const mountGroups = groupByMount(ctx);
   const services: Service[] =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
 
   for (const service of services) {

package/src/node/node-overrides.ts

@@ -1,4 +1,5 @@
-import type { EmitterContext, ResolvedOperation } from '@workos/oagen';
+import type { EmitterContext, Model, ResolvedOperation } from '@workos/oagen';
+import { enrichModelsFromSpec } from '../shared/model-utils.js';
 
 type OperationOverride = {
   methodName?: string;
@@ -42,17 +43,52 @@ function operationKey(resolved: ResolvedOperation): string {
   return `${resolved.operation.httpMethod.toUpperCase()} ${resolved.operation.path}`;
 }
 
+/**
+ * Apply oneOf / allOf+oneOf enrichment (flattening variant fields onto the
+ * parent model, plus synthetic models/enums for inline shapes) so the rest
+ * of the Node emitter sees a richer `spec.models`.
+ *
+ * Without this, `ConnectApplication` (and any other `allOf [base, oneOf [...]]`
+ * schema whose first variant is itself wrapped in `allOf`) loses every
+ * non-M2M field — the IR parser's discriminator detection silently skips
+ * variants whose properties live behind another `allOf`. Mirrors what the
+ * Go / Kotlin / .NET emitters already do.
+ *
+ * Discriminated bases produced by `enrichModelsFromSpec` get their original
+ * fields restored — Node emits flat interfaces today, not TS sum types, so
+ * an empty base would otherwise drop the common fields.
+ */
+function enrichSpecModels(models: readonly Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models as Model[]);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext {
   const cached = contextCache.get(ctx);
   if (cached) return cached;
 
+  const enrichedModels = enrichSpecModels(ctx.spec.models);
+  const specChanged =
+    enrichedModels.length !== ctx.spec.models.length || enrichedModels.some((m, i) => m !== ctx.spec.models[i]);
+  const enrichedSpec = specChanged ? { ...ctx.spec, models: enrichedModels } : ctx.spec;
+
   const resolvedOperations = ctx.resolvedOperations;
   if (!resolvedOperations?.length) {
-    contextCache.set(ctx, ctx);
-    return ctx;
+    const next = specChanged ? { ...ctx, spec: enrichedSpec } : ctx;
+    contextCache.set(ctx, next);
+    return next;
   }
 
-  let changed = false;
+  let opsChanged = false;
   const nextResolved = resolvedOperations.map((resolved) => {
     const override = OPERATION_OVERRIDES[operationKey(resolved)];
     if (!override) return resolved;
@@ -63,7 +99,7 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
       return resolved;
     }
 
-    changed = true;
+    opsChanged = true;
     return {
       ...resolved,
       methodName,
@@ -71,7 +107,14 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
     };
   });
 
-  const next = changed ? { ...ctx, resolvedOperations: nextResolved } : ctx;
+  const next =
+    opsChanged || specChanged
+      ? {
+          ...ctx,
+          ...(opsChanged ? { resolvedOperations: nextResolved } : {}),
+          ...(specChanged ? { spec: enrichedSpec } : {}),
+        }
+      : ctx;
   contextCache.set(ctx, next);
   return next;
 }

package/src/php/index.ts

@@ -18,6 +18,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { initializeEnumDedup } from './naming.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Initialize enum deduplication from spec data. */
 function ensureNamingInitialized(ctx: EmitterContext): void {
@@ -34,17 +35,39 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+ * in synthetic models / enums for inline variant shapes. PHP emits flat
+ * classes (no sum types), so a discriminated base whose IR fields the
+ * parser stripped (post-allOf-aware detection) gets its original fields
+ * restored to avoid silently dropping variant data.
+ */
+function enrichModelsForPhp(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const phpEmitter: Emitter = {
   language: 'php',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateModels(models, ctx));
+    return ensureTrailingNewlines(generateModels(enrichModelsForPhp(models), ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

package/src/ruby/index.ts

@@ -15,6 +15,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { generateRbiFiles } from './rbi.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -26,16 +27,40 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pick
+ * up the synthetic models / enums `enrichModelsFromSpec` produces for inline
+ * variant shapes. Ruby emits flat hash-backed models, not sum types, so a
+ * discriminated base whose IR fields were stripped (the new EventSchema-
+ * style behaviour after the parser learned to walk allOf-wrapped variants)
+ * has its original fields restored — otherwise `ConnectApplication`-style
+ * bases would silently lose every variant field they had previously.
+ */
+function enrichModelsForRuby(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const rubyEmitter: Emitter = {
   language: 'ruby',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
-    const modelFiles = generateModels(models, ctx);
+    const modelFiles = generateModels(enrichModelsForRuby(models), ctx);
     return ensureTrailingNewlines(modelFiles);
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

package/src/rust/index.ts

@@ -16,6 +16,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { UnionRegistry } from './type-map.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /**
  * Shared per-emit registry that collects synthesised oneOf-style unions
@@ -34,16 +35,39 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+ * in synthetic models / enums for inline variant shapes. Rust emits flat
+ * structs (a synthesised enum-union from `UnionRegistry` exists, but the
+ * field-on-base pattern is what matches `ConnectApplication` today). A
+ * discriminated base whose IR fields the parser stripped gets its original
+ * fields restored to avoid losing variant data.
+ */
+function enrichModelsForRust(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const rustEmitter: Emitter = {
   language: 'rust',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     unionRegistry.reset();
-    return ensureTrailingNewlines(generateModels(models, ctx, unionRegistry));
+    return ensureTrailingNewlines(generateModels(enrichModelsForRust(models), ctx, unionRegistry));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

package/src/shared/model-utils.ts

@@ -1,5 +1,5 @@
 import type { Model, Field, TypeRef, Enum } from '@workos/oagen';
-import { toSnakeCase } from '@workos/oagen';
+import { toSnakeCase, toUpperSnakeCase } from '@workos/oagen';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 // @ts-ignore -- js-yaml has no type declarations in this project
@@ -83,7 +83,7 @@ function discoverSpecPath(): string | null {
 let _rawSpecCache: Record<string, any> | null = null;
 let _rawSpecLoaded = false;
 
-function loadRawSpec(): Record<string, any> | null {
+export function loadRawSpec(): Record<string, any> | null {
   if (_rawSpecLoaded) return _rawSpecCache;
   _rawSpecLoaded = true;
   const specPath = discoverSpecPath();
@@ -114,7 +114,10 @@ function lookupRawSchema(name: string): Record<string, any> | null {
  */
 interface SyntheticCollector {
   models: Model[];
-  enums: Array<{ name: string; values: Array<{ value: string; description?: string }> }>;
+  enums: Array<{
+    name: string;
+    values: Array<{ value: string; description?: string }>;
+  }>;
   /** Track names already used to avoid duplicates. */
   usedNames: Set<string>;
 }
@@ -582,10 +585,17 @@ export function enrichModelsFromSpec(models: Model[]): Model[] {
     return modified ? { ...model, fields: newFields } : model;
   });
 
-  // Convert synthetic enum collector entries to proper Enum objects
+  // Convert synthetic enum collector entries to proper Enum objects. PHP's
+  // emitter (and others built on top of `EnumValue.name`) crash when this
+  // field is missing, so derive it from the value via the same upper-snake
+  // transform the parser uses for declared enums.
   _lastSyntheticEnums = collector.enums.map((e) => ({
     name: e.name,
-    values: e.values.map((v) => ({ value: v.value, description: v.description })),
+    values: e.values.map((v) => ({
+      name: toUpperSnakeCase(String(v.value)),
+      value: v.value,
+      description: v.description,
+    })),
   })) as Enum[];
 
   // Append synthetic models, skipping those whose snake_case name collides