@workos/oagen-emitters 0.4.0 → 0.6.0

package/smoke/sdk-php.ts

@@ -166,14 +166,19 @@ class CaptureProxy {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-python.ts

@@ -191,15 +191,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-ruby.ts

@@ -78,15 +78,21 @@ interface MethodResolution {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-rust.ts

@@ -167,15 +167,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/src/dotnet/index.ts

@@ -11,13 +11,13 @@ import type {
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
-import { generateModels } from './models.js';
+import { generateModels, primeModelAliases } from './models.js';
 import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 import { generateEnums, primeEnumAliases } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { generateWrapperOptionsClasses } from './wrappers.js';
 import { groupByMount } from '../shared/resolved-ops.js';
 import { discriminatedUnions } from './type-map.js';
@@ -151,6 +151,7 @@ export const dotnetEmitter: Emitter = {
     const c = fixNamespace(ctx);
     const synEnums = getSyntheticEnums();
     primeEnumAliases(synEnums.length > 0 ? [...c.spec.enums, ...synEnums] : c.spec.enums);
+    primeModelAliases(enrichModelsFromSpec(c.spec.models));
     const files = generateResources(services, c);
 
     // Also generate wrapper options classes
@@ -201,11 +202,12 @@ export const dotnetEmitter: Emitter = {
     const c = fixNamespace(ctx);
     const synEnumsForTests = getSyntheticEnums();
     primeEnumAliases(synEnumsForTests.length > 0 ? [...spec.enums, ...synEnumsForTests] : spec.enums);
+    primeModelAliases(enrichModelsFromSpec(c.spec.models));
     return prefixTestPaths(ensureTrailingNewlines(generateTests(spec, c)));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, fixNamespace(ctx)));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, fixNamespace(ctx));
   },
 
   fileHeader(): string {
@@ -229,7 +231,7 @@ export const dotnetEmitter: Emitter = {
       args: ['format', workspace, '--no-restore', '--include'],
       // Keep batches small enough to stay under argv length limits while
       // still amortizing MSBuild startup across many files.
-      batchSize: 50,
+      batchSize: 500,
     };
   },
 };
@@ -239,8 +241,8 @@ function findDotnetWorkspace(targetDir: string): string | null {
   if (!fs.existsSync(targetDir)) return null;
   const entries = fs.readdirSync(targetDir);
   const sln = entries.find((e) => e.endsWith('.sln') || e.endsWith('.slnx'));
-  if (sln) return path.join(targetDir, sln);
+  if (sln) return path.resolve(targetDir, sln);
   const csproj = entries.find((e) => e.endsWith('.csproj'));
-  if (csproj) return path.join(targetDir, csproj);
+  if (csproj) return path.resolve(targetDir, csproj);
   return null;
 }

package/src/dotnet/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

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. */