@workos/oagen-emitters 0.12.5 → 0.13.0

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/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;
+}