@workos/oagen-emitters 0.12.5 → 0.14.0

package/src/ruby/client.ts

@@ -1,6 +1,14 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Service, Model, Enum } from '@workos/oagen';
 import { assignModelsToServices } from '@workos/oagen';
-import { servicePropertyName, resolveClassName, className, fileName, buildMountDirMap } from './naming.js';
+import {
+  servicePropertyName,
+  resolveClassName,
+  className,
+  fileName,
+  buildMountDirMap,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
+} from './naming.js';
 import { classifyUnassignedModel } from './models.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
@@ -89,8 +97,12 @@ function buildInflectionMap(spec: ApiSpec, ctx: EmitterContext): Map<string, str
 
   inflections.set('workos', 'WorkOS');
 
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of buildTopLevelServices(spec, ctx)) {
-    const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+    const target = resolveServiceTarget(
+      getMountTarget(service, ctx) || resolveClassName(service, ctx),
+      exportedClasses,
+    );
     const cls = className(target);
     const file = fileName(target);
     if (rubyCamelize(file) !== cls) inflections.set(file, cls);
@@ -203,10 +215,11 @@ function generateClientClass(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   lines.push('  class Client < BaseClient');
 
   const topLevelServices = buildTopLevelServices(spec, ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of topLevelServices) {
-    const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
-    const cls = className(target);
-    const prop = servicePropertyName(target);
+    const rawTarget = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+    const cls = className(resolveServiceTarget(rawTarget, exportedClasses));
+    const prop = servicePropertyName(rawTarget);
     lines.push('');
     lines.push(`    def ${prop}`);
     lines.push(`      @${prop} ||= WorkOS::${cls}.new(self)`);

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/ruby/manifest.ts

@@ -7,9 +7,14 @@ import { servicePropertyName } from './naming.js';
  * Uses each resolved operation's actual mountOn (not the service default) so
  * operations remounted via operationHints land on the correct service prop.
  * Split operations emit one entry per wrapper (keyed by wrapper name + variant).
+ *
+ * The accessor (`service` field) uses the raw mountOn — accessor names stay
+ * unsuffixed even when the underlying service class gets a `Service` suffix
+ * on collision.
  */
 export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
   void spec;
+  void ctx;
   const manifest: OperationsMap = {};
 
   for (const r of ctx.resolvedOperations ?? []) {

package/src/ruby/naming.ts

@@ -2,6 +2,10 @@ import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
 import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 
 /**
  * Ruby class names that collide with core classes. When a model name resolves
@@ -117,6 +121,32 @@ export function moduleName(name: string): string {
   return toSnakeCase(name);
 }
 
+/**
+ * Build the set of model + enum Ruby class names that the SDK exposes under
+ * `WorkOS::`. Used to detect collisions with operation-client class names —
+ * a colliding service gets a `Service` suffix (`OrganizationMembershipService`)
+ * so it doesn't shadow the model class under Zeitwerk's collapsed namespace.
+ */
+export function buildExportedClassNameSet(ctx: EmitterContext): Set<string> {
+  return buildExportedClassNameSetShared(ctx, className);
+}
+
+/**
+ * Resolve a service's mount-target identifier, appending `Service` on
+ * collision with an exported model/enum class name. The returned PascalCase
+ * value feeds `className`/`fileName` to derive matching class + file names
+ * (e.g. `OrganizationMembershipService` / `organization_membership_service`).
+ *
+ * Accessor names (`servicePropertyName`) intentionally use the RAW target —
+ * `client.organization_membership` is more readable than the suffixed form.
+ *
+ * The directory used by `loader.collapse` (the model home) likewise uses the
+ * raw target.
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /**
  * PascalCase class name for a parameter-group variant. Mirrors the Python
  * convention: group "password" + variant "plaintext" → `PasswordPlaintext`.

package/src/ruby/rbi.ts

@@ -7,6 +7,9 @@ import {
   safeParamName,
   scopedGroupVariantClassName,
   resolveMethodName,
+  servicePropertyName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -129,9 +132,11 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
   }
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
     const lines: string[] = [];
     lines.push('# typed: strong');
     lines.push('');
@@ -143,6 +148,9 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     // layout in lib/workos/<service>.rb.
     const variants = collectVariantsForMountTarget(ctx, spec.models as Model[], mountTarget);
     for (const v of variants) {
+      // Rewrite mountTarget to the (possibly pluralized) service class so the
+      // RBI's `WorkOS::<Service>::<Variant>` reference matches the runtime.
+      v.mountTarget = resolvedTarget;
       for (const line of emitInlineVariantRbi(v)) lines.push(line);
       lines.push('');
     }
@@ -183,7 +191,8 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
         if (!owner) {
           throw new Error(`No owner mount target found for parameter group '${group.name}'`);
         }
-        const variants = group.variants.map((v) => scopedGroupVariantClassName(owner, group.name, v.name));
+        const resolvedOwner = resolveServiceTarget(owner, exportedClasses);
+        const variants = group.variants.map((v) => scopedGroupVariantClassName(resolvedOwner, group.name, v.name));
         if (variants.length === 1) return variants[0];
         return `T.any(${variants.join(', ')})`;
       };
@@ -267,7 +276,7 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     lines.push('end');
 
     files.push({
-      path: `rbi/workos/${fileName(mountTarget)}.rbi`,
+      path: `rbi/workos/${fileName(resolvedTarget)}.rbi`,
       content: lines.join('\n'),
       integrateTarget: true,
       overwriteExisting: true,
@@ -283,11 +292,9 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     lines.push('  class Client < BaseClient');
 
     for (const [mountTarget] of groups) {
-      const cls = className(mountTarget);
-      const prop = mountTarget
-        .replace(/-/g, '_')
-        .replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`)
-        .replace(/^_/, '');
+      const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+      const cls = className(resolvedTarget);
+      const prop = servicePropertyName(mountTarget);
       lines.push(`    sig { returns(WorkOS::${cls}) }`);
       lines.push(`    def ${prop}; end`);
       lines.push('');

package/src/ruby/resources.ts

@@ -8,6 +8,8 @@ import {
   safeParamName,
   resolveMethodName,
   scopedGroupVariantClassName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import { mapTypeRefForYard } from './type-map.js';
 import {
@@ -48,10 +50,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   // dispatcher and YARD `@param` reference resolves variant classes through
   // this map so cross-resource references stay consistent.
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
-    const file = fileName(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
+    const file = fileName(resolvedTarget);
 
     const operations = group.operations;
     if (operations.length === 0) continue;
@@ -103,6 +107,7 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
         listWrapperModels,
         requires,
         groupOwners,
+        exportedClasses,
       });
       methodBodies.push(body);
 
@@ -182,6 +187,7 @@ function emitMethod(args: {
   listWrapperModels: Map<string, Model>;
   requires: Set<string>;
   groupOwners: Map<string, string>;
+  exportedClasses: Set<string>;
 }): string {
   const {
     op,
@@ -195,6 +201,7 @@ function emitMethod(args: {
     listWrapperModels,
     requires,
     groupOwners,
+    exportedClasses,
   } = args;
   void enumNames;
 
@@ -204,7 +211,7 @@ function emitMethod(args: {
     if (!owner) {
       throw new Error(`No owner mount target found for parameter group '${group.name}'`);
     }
-    return scopedGroupVariantClassName(owner, group.name, variantName);
+    return scopedGroupVariantClassName(resolveServiceTarget(owner, exportedClasses), group.name, variantName);
   };
 
   const plan = planOperation(op);

package/src/ruby/tests.ts

@@ -7,6 +7,8 @@ import {
   scopedGroupVariantClassName,
   servicePropertyName,
   resolveMethodName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -38,11 +40,13 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   const lookup = buildResolvedLookup(ctx);
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
     const prop = servicePropertyName(mountTarget);
-    const file = fileName(mountTarget);
+    const file = fileName(resolvedTarget);
 
     const lines: string[] = [];
     lines.push(`require 'test_helper'`);
@@ -85,7 +89,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
       const resolved = lookupResolved(op, lookup);
       const hiddenParams = buildHiddenParams(resolved);
-      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models);
+      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, exportedClasses);
       const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models);
 
       // Collect method info for the parameterized 401 test (T20).
@@ -118,7 +122,15 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
         for (let vi = 1; vi < group.variants.length; vi++) {
           const variant = group.variants[vi];
           const overrides = new Map<string, number>([[group.name, vi]]);
-          const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, overrides);
+          const variantCallArgs = buildCallArgsStub(
+            op,
+            modelByName,
+            hiddenParams,
+            groupOwners,
+            models,
+            exportedClasses,
+            overrides,
+          );
           const variantBodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models, overrides);
           const suffix = `with_${fieldName(group.name)}_${fieldName(variant.name)}`;
           lines.push('');
@@ -338,6 +350,7 @@ function buildCallArgsStub(
   hiddenParams: Set<string>,
   groupOwners: Map<string, string>,
   models: Model[],
+  exportedClasses: Set<string>,
   variantOverrides: Map<string, number> = new Map(),
 ): string {
   const parts: string[] = [];
@@ -406,7 +419,11 @@ function buildCallArgsStub(
       if (!owner) {
         throw new Error(`No owner mount target found for parameter group '${group.name}'`);
       }
-      const variantClass = scopedGroupVariantClassName(owner, group.name, variant.name);
+      const variantClass = scopedGroupVariantClassName(
+        resolveServiceTarget(owner, exportedClasses),
+        group.name,
+        variant.name,
+      );
       const fieldStubs = variant.parameters
         .map((p) => `${fieldName(p.name)}: ${stubValueFor(pickVariantParamType(p.type, bodyFieldTypes.get(p.name)))}`)
         .join(', ');

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

package/src/shared/service-name-collision.ts

@@ -0,0 +1,56 @@
+import type { EmitterContext, Model, Enum } from '@workos/oagen';
+import { isListWrapperModel, isListMetadataModel } from './model-utils.js';
+
+/**
+ * Suffix applied to an operation-client class name when it collides with an
+ * exported model/enum class name in the same SDK namespace. Standardized
+ * across emitters so colliding services look the same in every language —
+ * e.g. `OrganizationMembershipService` regardless of language.
+ *
+ * Languages whose operation clients already carry a unique suffix (Go's
+ * `…Service`, Rust's `…Api`, .NET's `…Service`) skip this helper entirely.
+ */
+export const SERVICE_COLLISION_SUFFIX = 'Service';
+
+/**
+ * Build the set of model + enum class names that the SDK exports under its
+ * top-level namespace. Each emitter passes its own `classNameFn` so the
+ * comparison happens on the language-specific class-name form (e.g. Ruby's
+ * `RoleList`, Python's `RoleList`).
+ *
+ * List-wrapper and list-metadata models are excluded — they aren't exposed
+ * as user-facing types.
+ */
+export function buildExportedClassNameSet(ctx: EmitterContext, classNameFn: (name: string) => string): Set<string> {
+  const out = new Set<string>();
+  for (const model of ctx.spec.models as Model[]) {
+    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    out.add(classNameFn(model.name));
+  }
+  for (const enumDef of ctx.spec.enums as Enum[]) {
+    out.add(classNameFn(enumDef.name));
+  }
+  return out;
+}
+
+/**
+ * Resolve the PascalCase mount-target identifier for an operation client,
+ * appending `Service` when the un-suffixed class name would shadow an
+ * exported model or enum.
+ *
+ * Operates on the PascalCase target (the mount-target string the IR carries),
+ * so the returned value feeds cleanly into each language's `className` and
+ * `fileName` helpers — e.g. `OrganizationMembership` → `OrganizationMembershipService`,
+ * then `fileName` → `organization_membership_service` / `organization-membership-service`.
+ *
+ * The accessor on the client (`client.organization_membership`) is intentionally
+ * NOT suffixed — callers should keep using the raw target for `servicePropertyName`
+ * so the accessor reads naturally.
+ */
+export function resolveServiceTarget(
+  target: string,
+  exportedClasses: Set<string>,
+  classNameFn: (name: string) => string,
+): string {
+  return exportedClasses.has(classNameFn(target)) ? `${target}${SERVICE_COLLISION_SUFFIX}` : target;
+}