@workos/oagen-emitters 0.2.1 → 0.4.0

package/smoke/sdk-go.ts

@@ -140,6 +140,43 @@ function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
   return manifest;
 }
 
+// ---------------------------------------------------------------------------
+// Accessor map -- discover actual method names from the generated workos.go
+// ---------------------------------------------------------------------------
+
+function buildAccessorMap(sdkPath: string): Map<string, string> {
+  const map = new Map<string, string>();
+  // Find the main workos.go or *.go file that has Client methods
+  const candidates = ['workos.go'];
+  for (const fname of candidates) {
+    const fpath = resolve(sdkPath, fname);
+    if (!existsSync(fpath)) continue;
+    const content = readFileSync(fpath, 'utf-8');
+    // Match: func (c *Client) ServiceName() *serviceNameService {
+    const re = /func \(c \*Client\) (\w+)\(\)/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const accessor = m[1];
+      // Map by lowercase key for case-insensitive matching
+      map.set(accessor.toLowerCase(), accessor);
+    }
+  }
+  return map;
+}
+
+/**
+ * Resolve the Go service accessor name from the manifest service name.
+ * Uses the accessor map (built from the generated SDK) for exact matching.
+ * Falls back to PascalCase for services not found in the map.
+ */
+function resolveAccessorName(manifestService: string, accessorMap: Map<string, string>): string {
+  // Try case-insensitive lookup: "sso" -> "SSO", "api_keys" -> "ApiKeys"
+  const pascalized = toPascalCase(manifestService);
+  const found = accessorMap.get(pascalized.toLowerCase());
+  if (found) return found;
+  return pascalized;
+}
+
 // ---------------------------------------------------------------------------
 // Method resolution
 // ---------------------------------------------------------------------------
@@ -345,15 +382,16 @@ function detectModulePath(sdkPath: string): string {
     const match = goMod.match(/^module\s+(\S+)/m);
     if (match) return match[1];
   }
-  return 'github.com/workos/workos-go/v4';
+  return 'github.com/workos/workos-go/v2';
 }
 
 function generateGoImports(
   modulePath: string,
-  servicePackages: Set<string>,
+  _servicePackages: Set<string>,
   needsJson: boolean,
-  needsServicePkg: boolean,
+  _needsServicePkg: boolean,
 ): string {
+  // New emitter: flat package -- everything lives in the root module, no sub-packages.
   const lines: string[] = [];
   lines.push('import (');
   lines.push('\t"context"');
@@ -363,20 +401,21 @@ function generateGoImports(
   lines.push('\t"fmt"');
   lines.push('\t"os"');
   lines.push('');
-  lines.push(`\tworkos "${modulePath}/pkg"`);
-  if (needsServicePkg) {
-    for (const pkg of [...servicePackages].sort()) {
-      lines.push(`\t"${modulePath}/pkg/${pkg}"`);
-    }
-  }
+  lines.push(`\t"${modulePath}"`);
   lines.push(')');
   return lines.join('\n');
 }
 
-function generateGoPayloadStruct(payload: Record<string, unknown>, optsType: string, servicePackage: string): string {
+function generateGoPayloadStruct(payload: Record<string, unknown>, paramsType: string): string {
+  // New emitter: all types in root workos package, params are pointers.
+  // Skip nested objects, arrays, and nil values since Go requires typed structs
+  // and primitive fields can't be nil.
   const lines: string[] = [];
-  lines.push(`${servicePackage}.${optsType}{`);
+  lines.push(`&workos.${paramsType}{`);
   for (const [key, value] of Object.entries(payload)) {
+    // Skip nil, nested objects, and arrays
+    if (value === null || value === undefined) continue;
+    if (typeof value === 'object') continue;
     const goField = goFieldName(key);
     lines.push(`\t\t${goField}: ${goLiteral(value)},`);
   }
@@ -414,9 +453,9 @@ function generateGoCallBlock(
   pathParams: Record<string, string>,
   spec: any,
   callIndex: number,
+  accessorMap: Map<string, string>,
 ): string {
   const lines: string[] = [];
-  const servicePackage = goServicePackageName(resolution.service);
   const method = resolution.method;
 
   // Build arguments
@@ -427,52 +466,63 @@ function generateGoCallBlock(
     args.push(`"${pathParams[p.name] || ''}"`);
   }
 
-  // Request body opts struct
+  // Build service-prefixed params struct name (matches emitter's paramsStructName)
+  const servicePrefix = goExportedName(resolution.service);
+  const paramsTypeName = method.startsWith(servicePrefix) ? `${method}Params` : `${servicePrefix}${method}Params`;
+
+  // Request body params struct (emitter uses &workos.{ServicePrefix}{Method}Params{...})
+  const hasQueryParams = op.queryParams && op.queryParams.length > 0;
   if (op.requestBody) {
     const payload = generatePayload(op, spec);
     if (payload && Object.keys(payload).length > 0) {
-      const optsType = `${method}Opts`;
-      args.push(generateGoPayloadStruct(payload, optsType, servicePackage));
-    }
-  }
-
-  // Paginated operations: pass opts with Limit=1
-  if (op.pagination && !op.requestBody) {
-    const extraParams = op.queryParams.filter((p: any) => !['limit', 'before', 'after', 'order'].includes(p.name));
-    if (extraParams.length > 0) {
-      // Match the emitter convention: List → ListFilterOpts, others → ${method}Opts
-      const optsType = method === 'List' ? 'ListFilterOpts' : `${method}Opts`;
-      args.push(`${servicePackage}.${optsType}{Limit: 1}`);
+      args.push(generateGoPayloadStruct(payload, paramsTypeName));
     } else {
-      args.push(`${servicePackage}.ListOpts{Limit: 1}`);
+      // Even with empty payload, the method signature requires the params arg
+      args.push(`&workos.${paramsTypeName}{}`);
     }
+  } else if (op.pagination || hasQueryParams) {
+    // Paginated or query-param operations need a params struct
+    args.push(`&workos.${paramsTypeName}{}`);
   }
 
-  // Determine the service accessor on the client
-  const serviceProp = goExportedName(resolution.service);
+  // Service accessor: resolve from the generated SDK's actual accessor names
+  const serviceProp = resolveAccessorName(resolution.service, accessorMap);
 
   lines.push(`\t// Call ${callIndex}: ${op.httpMethod.toUpperCase()} ${op.path}`);
   lines.push(`\tfmt.Fprintf(os.Stderr, "CALL_START:${callIndex}\\n")`);
 
-  // Determine return type: paginated and GET-with-response return (result, error),
-  // DELETE returns just error
+  // Determine return type: paginated returns Iterator, DELETE and void/redirect return just error
   const isDelete = op.httpMethod === 'delete';
-  const hasResponse = !isDelete;
-
-  if (hasResponse) {
-    lines.push(`\tresult${callIndex}, err${callIndex} := client.${serviceProp}.${method}(${args.join(', ')})`);
+  const isPaginated = !!op.pagination;
+  const isVoidResponse =
+    !isPaginated &&
+    !isDelete &&
+    ((op.response.kind === 'primitive' && (op.response as any).type === 'unknown') ||
+      (op.successResponses && op.successResponses.some((r: any) => r.statusCode >= 300 && r.statusCode < 400)));
+
+  if (isPaginated) {
+    // Iterator-based: call Next() once to trigger the first HTTP request
+    lines.push(`\titer${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
+    lines.push(`\titer${callIndex}.Next()`);
+    lines.push(`\tif err${callIndex} := iter${callIndex}.Err(); err${callIndex} != nil {`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
+    lines.push('\t} else {');
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
+    lines.push('\t}');
+  } else if (isDelete || isVoidResponse) {
+    lines.push(`\terr${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
     lines.push(`\tif err${callIndex} != nil {`);
     lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
     lines.push('\t} else {');
-    lines.push(`\t\tjsonResult${callIndex}, _ := json.Marshal(result${callIndex})`);
-    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:%s\\n", string(jsonResult${callIndex}))`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
     lines.push('\t}');
   } else {
-    lines.push(`\terr${callIndex} := client.${serviceProp}.${method}(${args.join(', ')})`);
+    lines.push(`\tresult${callIndex}, err${callIndex} := client.${serviceProp}().${method}(${args.join(', ')})`);
     lines.push(`\tif err${callIndex} != nil {`);
     lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_ERROR:${callIndex}:%s\\n", err${callIndex}.Error())`);
     lines.push('\t} else {');
-    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:\\n")`);
+    lines.push(`\t\tjsonResult${callIndex}, _ := json.Marshal(result${callIndex})`);
+    lines.push(`\t\tfmt.Fprintf(os.Stderr, "CALL_OK:${callIndex}:%s\\n", string(jsonResult${callIndex}))`);
     lines.push('\t}');
   }
 
@@ -523,6 +573,11 @@ async function main(): Promise<void> {
   // Load manifest
   const manifest = loadManifest(sdkPath);
 
+  // Build accessor name map by scanning the generated workos.go for
+  // `func (c *Client) XxxYyy()` patterns, then matching them to manifest
+  // service names via case-insensitive comparison.
+  const accessorMap = buildAccessorMap(sdkPath);
+
   const baseUrl = process.env.WORKOS_BASE_URL || spec.baseUrl;
 
   // Start capture proxy
@@ -633,7 +688,7 @@ async function main(): Promise<void> {
       // Generate all call blocks for this wave
       const callBlocks: string[] = [];
       for (const call of plannedCalls) {
-        callBlocks.push(generateGoCallBlock(call.op, call.resolution, call.pathParams, spec, call.index));
+        callBlocks.push(generateGoCallBlock(call.op, call.resolution, call.pathParams, spec, call.index, accessorMap));
       }
 
       const imports = generateGoImports(modulePath, servicePackages, needsJson, needsServicePkg);
@@ -644,7 +699,7 @@ async function main(): Promise<void> {
         imports,
         '',
         'func main() {',
-        `\tclient := workos.NewClient("${apiKey}", workos.WithEndpoint("http://127.0.0.1:${proxyPort}"))`,
+        `\tclient := workos.NewClient("${apiKey}", workos.WithBaseURL("http://127.0.0.1:${proxyPort}"))`,
         '\tctx := context.Background()',
         '',
         ...callBlocks,
@@ -660,8 +715,10 @@ async function main(): Promise<void> {
 
       // Step 1: Build (sync — no proxy needed during compilation)
       let buildError: string | null = null;
+
+      // Run go mod tidy first to resolve dependencies
       try {
-        execSync('go build -o smoke-driver main.go', {
+        execSync('go mod tidy', {
           cwd: tmpDir,
           timeout: 120_000,
           env: {
@@ -673,9 +730,26 @@ async function main(): Promise<void> {
         });
       } catch (err: any) {
         const stderr = typeof err.stderr === 'string' ? err.stderr : '';
-        buildError = stderr.trim().split('\n').slice(0, 5).join(' ') || 'go build failed';
+        buildError = `go mod tidy failed: ${stderr.trim().split('\n').slice(0, 3).join(' ')}`;
       }
 
+      if (!buildError)
+        try {
+          execSync('go build -o smoke-driver main.go', {
+            cwd: tmpDir,
+            timeout: 120_000,
+            env: {
+              ...process.env,
+              GOPATH: process.env.GOPATH || resolve(process.env.HOME || '~', 'go'),
+            },
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+        } catch (err: any) {
+          const stderr = typeof err.stderr === 'string' ? err.stderr : '';
+          buildError = stderr.trim().split('\n').slice(0, 5).join(' ') || 'go build failed';
+        }
+
       if (buildError) {
         // Build failure affects entire wave
         const elapsed = Date.now() - waveStart;

package/smoke/sdk-php.ts

@@ -184,8 +184,8 @@ function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
 // ---------------------------------------------------------------------------
 
 interface MethodResolution {
-  className: string;
-  method: string;
+  service: string; // camelCase accessor on client (e.g., "organizations")
+  method: string; // camelCase method name (e.g., "get")
   tier: ExchangeProvenance['resolutionTier'];
   confidence: number;
 }
@@ -200,14 +200,12 @@ function resolveMethod(
   if (manifest) {
     const entry = manifest.get(httpKey);
     if (entry) {
-      const className = entry.service.charAt(0).toUpperCase() + entry.service.slice(1);
-      return { className, method: entry.sdkMethod, tier: 'manifest', confidence: 1.0 };
+      return { service: entry.service, method: entry.sdkMethod, tier: 'manifest', confidence: 1.0 };
     }
   }
 
   const sdkProp = SERVICE_PROPERTY_MAP[irService] || toCamelCase(irService);
-  const className = sdkProp.charAt(0).toUpperCase() + sdkProp.slice(1);
-  return { className, method: toCamelCase(op.name), tier: 'exact', confidence: 0.8 };
+  return { service: sdkProp, method: toCamelCase(op.name), tier: 'exact', confidence: 0.8 };
 }
 
 // ---------------------------------------------------------------------------
@@ -278,9 +276,14 @@ function buildBatchedPhpScript(
   }
   lines.push('');
 
-  // Configure SDK
-  lines.push(`${namespace}\\Client::setApiKey('${apiKey}');`);
-  lines.push(`${namespace}\\Client::setBaseUrl('http://127.0.0.1:${proxyPort}');`);
+  // Configure SDK — generated SDK uses instance-based client with Guzzle handler
+  lines.push(`use GuzzleHttp\\HandlerStack;`);
+  lines.push(`use GuzzleHttp\\Handler\\CurlHandler;`);
+  lines.push('');
+  lines.push(`$client = new ${namespace}\\${namespace}(`);
+  lines.push(`    apiKey: '${escapePhpString(apiKey)}',`);
+  lines.push(`    baseUrl: 'http://127.0.0.1:${proxyPort}',`);
+  lines.push(');');
   lines.push('');
 
   for (const call of calls) {
@@ -289,7 +292,8 @@ function buildBatchedPhpScript(
     // Marker: start
     lines.push(`fwrite(STDERR, "OAGEN_CALL_START:${index}\\n");`);
 
-    // Build arguments
+    // Build arguments — generated PHP SDK takes positional path params,
+    // then named keyword args for body fields and query params
     const phpArgs: string[] = [];
 
     for (const p of op.pathParams) {
@@ -299,33 +303,31 @@ function buildBatchedPhpScript(
 
     if (op.requestBody) {
       const payload = generatePayload(op, spec);
-      if (payload && Object.keys(payload).length > 0) {
-        phpArgs.push(phpArrayLiteral(payload));
-      } else {
-        phpArgs.push('[]');
+      if (payload && typeof payload === 'object') {
+        // Pass as named arguments (the generated SDK uses promoted properties)
+        for (const [key, value] of Object.entries(payload)) {
+          phpArgs.push(`${toCamelCase(key)}: ${phpArrayLiteral(value)}`);
+        }
       }
     }
 
     if (!op.requestBody && op.queryParams.some((p) => p.required)) {
       const queryOpts = generateQueryParams(op, spec);
-      if (Object.keys(queryOpts).length > 0) {
-        phpArgs.push(phpArrayLiteral(queryOpts));
+      for (const [key, value] of Object.entries(queryOpts)) {
+        phpArgs.push(`${toCamelCase(key)}: ${phpArrayLiteral(value)}`);
       }
     }
 
-    if (op.pagination && phpArgs.length === 0) {
-      phpArgs.push("['limit' => 1]");
-    } else if (op.pagination && !op.requestBody) {
-      const last = phpArgs[phpArgs.length - 1];
-      if (last && last.startsWith('[')) {
-        phpArgs[phpArgs.length - 1] = last.replace(/\]$/, ", 'limit' => 1]");
-      } else {
-        phpArgs.push("['limit' => 1]");
+    if (op.pagination) {
+      if (!phpArgs.some((a) => a.startsWith('limit:'))) {
+        phpArgs.push('limit: 1');
       }
     }
 
+    // The generated SDK uses $client->resource()->method(...) pattern
+    const serviceAccessor = resolution.service;
     lines.push('try {');
-    lines.push(`    $result = ${namespace}\\${resolution.className}::${resolution.method}(${phpArgs.join(', ')});`);
+    lines.push(`    $result = $client->${serviceAccessor}()->${resolution.method}(${phpArgs.join(', ')});`);
     lines.push(`    fwrite(STDERR, "OAGEN_CALL_OK:${index}\\n");`);
     lines.push('} catch (\\Throwable $e) {');
     lines.push(`    fwrite(STDERR, "OAGEN_CALL_ERROR:${index}:" . $e->getMessage() . "\\n");`);
@@ -669,7 +671,7 @@ function buildExchange(
     provenance: {
       resolutionTier: resolution.tier,
       resolutionConfidence: resolution.confidence,
-      sdkMethodName: `${resolution.className}::${resolution.method}`,
+      sdkMethodName: `${resolution.service}->${resolution.method}`,
       captureIndex: 0,
       totalCaptures: 1,
     },

package/smoke/sdk-python.ts

@@ -284,7 +284,10 @@ function buildBatchedPythonScript(
   calls: PlannedCall[],
   spec: any,
 ): string {
-  const srcPath = resolve(sdkPath, 'src');
+  // Use src/ subdirectory if it exists, otherwise use the SDK root directly.
+  // Generated SDKs use a flat layout (workos/ at root), while some hand-written
+  // SDKs nest under src/.
+  const srcPath = existsSync(resolve(sdkPath, 'src')) ? resolve(sdkPath, 'src') : resolve(sdkPath);
   const lines: string[] = [];
 
   // Preamble -- loaded once
@@ -504,7 +507,7 @@ async function main(): Promise<void> {
         const child = spawn(python3Path, [scriptPath], {
           env: {
             ...process.env,
-            PYTHONPATH: resolve(sdkPath, 'src'),
+            PYTHONPATH: existsSync(resolve(sdkPath, 'src')) ? resolve(sdkPath, 'src') : resolve(sdkPath),
             PYTHONDONTWRITEBYTECODE: '1',
           },
           stdio: ['pipe', 'pipe', 'pipe'],

package/src/dotnet/client.ts

@@ -0,0 +1,89 @@
+import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { toPascalCase, toSnakeCase } from '@workos/oagen';
+import { resolveResourceClassName } from './resources.js';
+import { className, serviceTypeName, humanize } from './naming.js';
+import { getMountTarget } from '../shared/resolved-ops.js';
+
+/**
+ * Generate the C# client file with service accessors.
+ * Produces: WorkOSClient.Generated.cs (partial class with service properties).
+ */
+export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  return [generateClientFile(spec, ctx)];
+}
+
+/**
+ * Deduplicate services by mount target.
+ */
+function deduplicateByMount(services: Service[], ctx: EmitterContext): Service[] {
+  const byTarget = new Map<string, Service>();
+  for (const s of services) {
+    const target = getMountTarget(s, ctx);
+    const existing = byTarget.get(target);
+    if (!existing || toPascalCase(s.name) === target) {
+      byTarget.set(target, s);
+    }
+  }
+  return [...byTarget.values()];
+}
+
+/**
+ * Build map of service name -> accessor property name.
+ */
+export function buildServiceAccessPaths(services: Service[], ctx: EmitterContext): Map<string, string> {
+  const topLevel = deduplicateByMount(services, ctx);
+  const paths = new Map<string, string>();
+
+  for (const service of topLevel) {
+    const resolvedName = resolveResourceClassName(service, ctx);
+    const prop = toSnakeCase(resolvedName);
+    paths.set(service.name, prop);
+  }
+
+  // Also map mount targets
+  for (const service of services) {
+    const target = getMountTarget(service, ctx);
+    if (!paths.has(target)) {
+      const existing = paths.get(service.name);
+      if (existing) paths.set(target, existing);
+    }
+  }
+
+  return paths;
+}
+
+function generateClientFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
+  const topLevel = deduplicateByMount(spec.services, ctx);
+  const lines: string[] = [];
+
+  lines.push(`namespace ${ctx.namespacePascal}`);
+  lines.push('{');
+  lines.push('    /// <summary>');
+  lines.push('    /// Generated service accessors for WorkOSClient.');
+  lines.push('    /// </summary>');
+  lines.push('    public partial class WorkOSClient');
+  lines.push('    {');
+
+  // Service properties with lazy initialization
+  for (const service of topLevel) {
+    const resolvedName = resolveResourceClassName(service, ctx);
+    const propName = className(resolvedName);
+    const svcType = serviceTypeName(resolvedName);
+    const backingField = propName.charAt(0).toLowerCase() + propName.slice(1);
+    const human = humanize(resolvedName);
+    lines.push(`        private ${svcType} ${backingField};`);
+    lines.push('');
+    lines.push(`        /// <summary>Gets the <see cref="${svcType}"/> for ${human} API operations.</summary>`);
+    lines.push(`        public virtual ${svcType} ${propName} => this.${backingField} ??= new ${svcType}(this);`);
+    lines.push('');
+  }
+
+  lines.push('    }');
+  lines.push('}');
+
+  return {
+    path: 'Client/WorkOSClient.Generated.cs',
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  };
+}