@workos/oagen-emitters 0.4.0 → 0.5.0

package/src/dotnet/models.ts

@@ -1,14 +1,20 @@
 import type { Model, EmitterContext, GeneratedFile, TypeRef } from '@workos/oagen';
-import { mapTypeRef, isValueTypeRef, isEnumRef, emitJsonPropertyAttributes } from './type-map.js';
+import {
+  mapTypeRef,
+  isValueTypeRef,
+  isEnumRef,
+  emitJsonPropertyAttributes,
+  setModelAliases,
+  isModelAlias,
+} from './type-map.js';
 import {
   articleFor,
-  className,
-  escapeXml,
   fieldName,
   humanize,
   emitXmlDoc,
   deprecationMessage,
   escapeCsAttributeString,
+  modelClassName,
 } from './naming.js';
 
 // Import and re-export shared model detection utilities
@@ -35,90 +41,23 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
   const files: GeneratedFile[] = [];
 
-  // Build structural hash for deduplication. Run the hash → canonical pass
-  // iteratively so that parent classes whose only structural difference is
-  // an already-aliased child type also collapse. Terminates when a full
-  // round produces no new aliases.
-  const eligibleModels = models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m));
-  const aliasOf = new Map<string, string>();
-  while (true) {
-    const hashGroups = new Map<string, string[]>();
-    for (const model of eligibleModels) {
-      const hash = structuralHash(model, aliasOf);
-      if (!hashGroups.has(hash)) hashGroups.set(hash, []);
-      hashGroups.get(hash)!.push(model.name);
-    }
-
-    let added = false;
-    for (const [hash, names] of hashGroups) {
-      if (names.length <= 1) continue;
-      if (hash === '') continue;
-      const sorted = [...names].sort();
-      const canonical = sorted[0];
-      for (let i = 1; i < sorted.length; i++) {
-        const name = sorted[i];
-        if (aliasOf.get(name) !== canonical) {
-          aliasOf.set(name, canonical);
-          added = true;
-        }
-      }
-    }
-    if (!added) break;
-  }
+  // Compute and publish model aliases so mapTypeRef rewrites references.
+  primeModelAliases(models);
 
   for (const model of models) {
     if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
 
-    const csClassName = className(model.name);
-    const canonicalName = aliasOf.get(model.name);
-
-    if (canonicalName) {
-      // Emit alias as subclass of canonical
-      const canonicalClass = className(canonicalName);
-      const lines: string[] = [];
-      lines.push(`namespace ${ctx.namespacePascal}`);
-      lines.push('{');
-      if (model.description) {
-        const descLines = model.description
-          .split('\n')
-          .map((l) => l.trim())
-          .filter((l) => l);
-        lines.push(`    /// <summary>${escapeXml(descLines[0])}</summary>`);
-        if (descLines.length > 1) {
-          lines.push(`    /// <remarks>`);
-          for (const remark of descLines.slice(1)) {
-            lines.push(`    /// ${escapeXml(remark)}`);
-          }
-          lines.push(`    /// Structurally identical to <see cref="${canonicalClass}"/>.`);
-          lines.push(`    /// </remarks>`);
-        } else {
-          lines.push(`    /// <remarks>Structurally identical to <see cref="${canonicalClass}"/>.</remarks>`);
-        }
-      } else {
-        const human = humanize(model.name);
-        lines.push(`    /// <summary>Represents ${articleFor(human)} ${human}.</summary>`);
-        lines.push(`    /// <remarks>Structurally identical to <see cref="${canonicalClass}"/>.</remarks>`);
-      }
-      lines.push(`    public class ${csClassName} : ${canonicalClass} { }`);
-      lines.push('}');
+    const csClassName = modelClassName(model.name);
 
-      files.push({
-        path: `Entities/${csClassName}.cs`,
-        content: lines.join('\n'),
-        overwriteExisting: true,
-      });
-      continue;
-    }
+    // Skip alias models — all references are already rewritten to the
+    // canonical type by mapTypeRef, so the alias class would be dead code.
+    if (isModelAlias(model.name)) continue;
 
     const lines: string[] = [];
-    const needsCollections = model.fields.some((f) => {
-      const csType = mapTypeRef(f.type);
-      return csType.startsWith('List<') || csType.startsWith('Dictionary<');
-    });
-    const needsSystem = model.fields.some((f) => {
-      const csType = mapTypeRef(f.type);
-      return csType.includes('DateTimeOffset');
-    });
+    const fieldTypes = model.fields.map((f) => mapTypeRef(f.type));
+    const needsCollections = fieldTypes.some((t) => t.startsWith('List<') || t.startsWith('Dictionary<'));
+    const needsSystem = fieldTypes.some((t) => t.includes('DateTimeOffset'));
+    const needsJsonAttrs = model.fields.some((f) => f.required && isEnumRef(f.type));
 
     lines.push(`namespace ${ctx.namespacePascal}`);
     lines.push('{');
@@ -128,8 +67,10 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     if (needsCollections) {
       lines.push('    using System.Collections.Generic;');
     }
-    lines.push('    using Newtonsoft.Json;');
-    lines.push('    using STJS = System.Text.Json.Serialization;');
+    if (needsJsonAttrs) {
+      lines.push('    using Newtonsoft.Json;');
+      lines.push('    using STJS = System.Text.Json.Serialization;');
+    }
     lines.push('');
 
     // XML doc comment
@@ -305,6 +246,41 @@ function singleValueConstInitializer(ref: TypeRef, enumConstByName: Map<string,
   return JSON.stringify(wire);
 }
 
+/**
+ * Compute and publish the model alias map. Safe to call multiple times
+ * (idempotent for a given set of models). Must be invoked before any emitter
+ * phase that calls `mapTypeRef` with model references.
+ */
+export function primeModelAliases(models: Model[]): void {
+  const eligibleModels = models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m));
+  const aliasOf = new Map<string, string>();
+  while (true) {
+    const hashGroups = new Map<string, string[]>();
+    for (const model of eligibleModels) {
+      const hash = structuralHash(model, aliasOf);
+      if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+      hashGroups.get(hash)!.push(model.name);
+    }
+
+    let added = false;
+    for (const [hash, names] of hashGroups) {
+      if (names.length <= 1) continue;
+      if (hash === '') continue;
+      const sorted = [...names].sort();
+      const canonical = sorted[0];
+      for (let i = 1; i < sorted.length; i++) {
+        const name = sorted[i];
+        if (aliasOf.get(name) !== canonical) {
+          aliasOf.set(name, canonical);
+          added = true;
+        }
+      }
+    }
+    if (!added) break;
+  }
+  setModelAliases(aliasOf);
+}
+
 /**
  * Normalize a TypeRef for structural comparison.
  * Enum references are normalized to their values (not names) so that

package/src/dotnet/naming.ts

@@ -1,6 +1,6 @@
 import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
-import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
+import { buildResolvedLookup, lookupMethodName, lookupResolved, getMountTarget } from '../shared/resolved-ops.js';
 import { stripUrnPrefix } from '../shared/naming-utils.js';
 
 /** PascalCase class/type name. */
@@ -8,6 +8,17 @@ export function className(name: string): string {
   return toPascalCase(stripUrnPrefix(name));
 }
 
+/** Display name for a model type, including consumer-friendly aliases. */
+export function modelClassName(name: string): string {
+  switch (name) {
+    case 'EmailChangeConfirmationUser':
+    case 'UserlandUser':
+      return 'User';
+    default:
+      return className(name);
+  }
+}
+
 /** PascalCase file name (without extension). */
 export function fileName(name: string): string {
   return toPascalCase(stripUrnPrefix(name));
@@ -57,15 +68,42 @@ export function resolveServiceDir(resolvedServiceName: string): string {
   return moduleName(resolvedServiceName);
 }
 
-/** Resolve the SDK method name for an operation. */
-export function resolveMethodName(op: Operation, _service: Service, ctx: EmitterContext): string {
+function trimAsyncSuffix(name: string): string {
+  return name.endsWith('Async') ? name.slice(0, -5) : name;
+}
+
+/** Append Async once for TAP-style method names. */
+export function appendAsyncSuffix(name: string): string {
+  return name.endsWith('Async') ? name : `${name}Async`;
+}
+
+/** Resolve the stable method stem for an operation (without any Async suffix). */
+export function resolveMethodStem(op: Operation, _service: Service, ctx: EmitterContext): string {
   const lookup = buildResolvedLookup(ctx);
   const resolved = lookupMethodName(op, lookup);
-  if (resolved) return trimMountedResourceFromMethod(methodName(resolved), resolveClassName(_service, ctx));
+  if (resolved) {
+    return trimMountedResourceFromMethod(methodName(trimAsyncSuffix(resolved)), resolveClassName(_service, ctx));
+  }
   const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
   const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
-  if (existing) return trimMountedResourceFromMethod(methodName(existing.methodName), resolveClassName(_service, ctx));
-  return trimMountedResourceFromMethod(methodName(op.name), resolveClassName(_service, ctx));
+  if (existing) {
+    return trimMountedResourceFromMethod(
+      methodName(trimAsyncSuffix(existing.methodName)),
+      resolveClassName(_service, ctx),
+    );
+  }
+  return trimMountedResourceFromMethod(methodName(trimAsyncSuffix(op.name)), resolveClassName(_service, ctx));
+}
+
+/** Resolve the SDK method name for an operation. */
+export function resolveMethodName(op: Operation, service: Service, ctx: EmitterContext): string {
+  const stem = resolveMethodStem(op, service, ctx);
+  const resolved = lookupResolved(op, buildResolvedLookup(ctx));
+  if (resolved?.urlBuilder ?? false) {
+    return stem;
+  }
+
+  return appendAsyncSuffix(stem);
 }
 
 /** Resolve the SDK class name for a service. */