@workos/oagen-emitters 0.2.0 → 0.3.0

package/src/node/naming.ts

@@ -1,14 +1,21 @@
 import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toCamelCase, toKebabCase, toSnakeCase } from '@workos/oagen';
+import { buildResolvedLookup, lookupMethodName } from '../shared/resolved-ops.js';
+import { stripUrnPrefix } from '../shared/naming-utils.js';
+
+/** Strip spec-noise suffixes (e.g., "Dto") from an IR name. */
+export function stripNoiseSuffixes(name: string): string {
+  return name.replace(/Dto$/i, '');
+}
 
 /** PascalCase class/interface name. */
 export function className(name: string): string {
-  return toPascalCase(name);
+  return toPascalCase(stripUrnPrefix(name));
 }
 
 /** kebab-case file name (without extension). */
 export function fileName(name: string): string {
-  return toKebabCase(name);
+  return toKebabCase(stripUrnPrefix(name));
 }
 
 /** camelCase method name. */
@@ -66,33 +73,33 @@ export function buildServiceNameMap(services: Service[], ctx: EmitterContext): M
   return map;
 }
 
-/** Resolve the SDK method name for an operation, checking overlay first. */
+/**
+ * Resolve the output directory for a service.
+ * Mount rules already handle directory placement, so this is a simple kebab-case conversion.
+ */
+export function resolveServiceDir(resolvedServiceName: string): string {
+  return serviceDirName(resolvedServiceName);
+}
+
+/** Resolve the SDK method name for an operation, using resolved operations first. */
 export function resolveMethodName(op: Operation, _service: Service, ctx: EmitterContext): string {
+  const lookup = buildResolvedLookup(ctx);
+  const resolved = lookupMethodName(op, lookup);
+  if (resolved) return toCamelCase(resolved);
+  // Fallback to overlay, then spec-derived
   const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
   const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
-  if (existing) {
-    // Fix: when the path ends with a path parameter (single-resource operation)
-    // and the overlay method name is plural, prefer the singular form.
-    // E.g., getUsers → getUser when path is /user_management/users/{id}
-    const isSingleResource = /\/\{[^}]+\}$/.test(op.path);
-    if (isSingleResource && existing.methodName.endsWith('s') && !existing.methodName.endsWith('ss')) {
-      const singular = existing.methodName.slice(0, -1);
-      // Only singularize if it looks like a typical pluralization (ends in 's')
-      // and the spec-derived name agrees it should be singular
-      const specDerived = toCamelCase(op.name);
-      if (specDerived === singular || specDerived.endsWith(singular.slice(singular.length - 4))) {
-        return singular;
-      }
-    }
-    return existing.methodName;
-  }
+  if (existing) return existing.methodName;
   return toCamelCase(op.name);
 }
 
-/** Resolve the SDK class name for a service, checking overlay for existing names. */
+/** Resolve the SDK class name for a service, using resolved ops mountOn as canonical. */
 export function resolveClassName(service: Service, ctx: EmitterContext): string {
-  // Check overlay's methodByOperation for any operation in this service
-  // to find the existing class name
+  // Use resolved ops mountOn as canonical class name
+  for (const r of ctx.resolvedOperations ?? []) {
+    if (r.service.name === service.name) return r.mountOn;
+  }
+  // Fallback to overlay
   if (ctx.overlayLookup?.methodByOperation) {
     for (const op of service.operations) {
       const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
@@ -103,9 +110,29 @@ export function resolveClassName(service: Service, ctx: EmitterContext): string
   return toPascalCase(service.name);
 }
 
-/** Resolve the interface name for a model, checking overlay first. */
-export function resolveInterfaceName(name: string, ctx: EmitterContext): string {
+/** Resolve the interface name for a model, checking overlay first.
+ *
+ * @param opts.skipTypeAlias - When true, skip apiSurface typeAlias resolution.
+ *   Use this for dedup models to ensure the file exports match the import
+ *   names (preserved files export the raw name, not the resolved alias).
+ */
+export function resolveInterfaceName(name: string, ctx: EmitterContext, opts?: { skipTypeAlias?: boolean }): string {
   const existing = ctx.overlayLookup?.interfaceByName?.get(name);
   if (existing) return existing;
-  return toPascalCase(name);
+
+  // If the model name is a type alias that points to a canonical interface,
+  // use the canonical name.  This prevents the merger from generating unused
+  // backward-compat aliases (e.g., `type FlagOwner = FeatureFlagOwner`).
+  if (!opts?.skipTypeAlias && ctx.apiSurface?.typeAliases) {
+    const alias = ctx.apiSurface.typeAliases[name] as { value?: string } | undefined;
+    if (alias?.value && ctx.apiSurface.interfaces?.[alias.value]) {
+      return alias.value;
+    }
+  }
+
+  // Strip spec-noise suffixes (e.g., "Dto") only for models without a
+  // baseline.  When an overlay exists (Scenario A), the overlay check above
+  // handles existing models.  New models (no overlay entry) get clean names.
+  const cleaned = ctx.apiSurface ? name : stripNoiseSuffixes(name);
+  return toPascalCase(stripUrnPrefix(cleaned));
 }