@workos/oagen-emitters 0.2.1 → 0.3.0

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/go/client.ts

@@ -0,0 +1,141 @@
+import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { toPascalCase, toSnakeCase } from '@workos/oagen';
+// naming utilities used indirectly via resolveResourceClassName
+import { resolveResourceClassName } from './resources.js';
+import { unexportedName } from './naming.js';
+import { getMountTarget } from '../shared/resolved-ops.js';
+
+/**
+ * Generate the Go client file with service accessors.
+ * Produces: workos.go (Client struct + constructor + service accessors).
+ * Static files (client.go, pagination.go, errors.go, go.mod, options.go)
+ * are hand-maintained in the target SDK with @oagen-ignore-file.
+ */
+export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  return [generateWorkOSFile(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 generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
+  const topLevel = deduplicateByMount(spec.services, ctx);
+  const lines: string[] = [];
+
+  lines.push(`package ${ctx.namespace}`);
+  lines.push('');
+  lines.push('import "net/http"');
+  lines.push('');
+
+  // Client struct
+  lines.push('// Client is the WorkOS API client.');
+  lines.push('type Client struct {');
+  lines.push('\tapiKey       string');
+  lines.push('\tclientID     string');
+  lines.push('\tbaseURL      string');
+  lines.push('\thttpClient   *http.Client');
+  lines.push('\tmaxRetries   int');
+  lines.push('');
+  // Service fields
+  for (const service of topLevel) {
+    const resolvedName = resolveResourceClassName(service, ctx);
+    const fieldNameStr = unexportedName(resolvedName);
+    const serviceTypeName = serviceType(resolvedName);
+    lines.push(`\t${fieldNameStr} *${serviceTypeName}`);
+  }
+  lines.push('}');
+  lines.push('');
+
+  // NewClient constructor
+  lines.push('// NewClient creates a new WorkOS API client.');
+  lines.push('func NewClient(apiKey string, opts ...ClientOption) *Client {');
+  lines.push('\tc := &Client{');
+  lines.push('\t\tapiKey:     apiKey,');
+  lines.push('\t\tbaseURL:    defaultBaseURL,');
+  lines.push('\t\thttpClient: &http.Client{Timeout: defaultTimeout},');
+  lines.push('\t\tmaxRetries: defaultMaxRetries,');
+  lines.push('\t}');
+  lines.push('\tfor _, opt := range opts {');
+  lines.push('\t\topt(c)');
+  lines.push('\t}');
+  // Initialize services
+  for (const service of topLevel) {
+    const resolvedName = resolveResourceClassName(service, ctx);
+    const fieldNameStr = unexportedName(resolvedName);
+    const serviceTypeName = serviceType(resolvedName);
+    lines.push(`\tc.${fieldNameStr} = &${serviceTypeName}{client: c}`);
+  }
+  lines.push('\treturn c');
+  lines.push('}');
+  lines.push('');
+
+  // Service accessor methods
+  for (const service of topLevel) {
+    const resolvedName = resolveResourceClassName(service, ctx);
+    const accessorName = resolvedName;
+    const fieldNameStr = unexportedName(resolvedName);
+    const serviceTypeName = serviceType(resolvedName);
+    lines.push(`// ${accessorName} returns the ${resolvedName} service.`);
+    lines.push(`func (c *Client) ${accessorName}() *${serviceTypeName} {`);
+    lines.push(`\treturn c.${fieldNameStr}`);
+    lines.push('}');
+    lines.push('');
+  }
+
+  return {
+    path: `${ctx.namespace}.go`,
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  };
+}
+
+function singularizePascal(name: string): string {
+  if (name.endsWith('ies')) {
+    return `${name.slice(0, -3)}y`;
+  }
+  if (name.endsWith('s') && !name.endsWith('ss')) {
+    return name.slice(0, -1);
+  }
+  return name;
+}
+
+function serviceType(name: string): string {
+  return `${unexportedName(singularizePascal(name))}Service`;
+}

package/src/go/enums.ts

@@ -0,0 +1,196 @@
+import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { walkTypeRef } from '@workos/oagen';
+import { className } from './naming.js';
+
+/**
+ * Generate Go typed string enum constants from IR Enum definitions.
+ *
+ * Each enum becomes a named string type + const block:
+ *   type Status string
+ *   const (
+ *     StatusActive   Status = "active"
+ *     StatusInactive Status = "inactive"
+ *   )
+ */
+export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
+  if (enums.length === 0) return [];
+
+  const aliasOf = collectEnumAliasOf(enums);
+  const files: GeneratedFile[] = [];
+
+  // Group all enums into a single file per SDK
+  const lines: string[] = [];
+  lines.push(`package ${ctx.namespace}`);
+  lines.push('');
+
+  for (const enumDef of enums) {
+    // If this enum is an alias, emit a simple type alias
+    const canonicalName = aliasOf.get(enumDef.name);
+    if (canonicalName) {
+      const aliasType = className(enumDef.name);
+      const canonicalType = className(canonicalName);
+      lines.push(`// ${aliasType} is an alias for ${canonicalType}.`);
+      lines.push(`type ${aliasType} = ${canonicalType}`);
+      lines.push('');
+      continue;
+    }
+
+    const typeName = className(enumDef.name);
+
+    if (enumDef.values.length === 0) {
+      const humanized = humanize(enumDef.name);
+      lines.push(`// ${typeName} represents ${humanized} values.`);
+      lines.push(`type ${typeName} = string`);
+      lines.push('');
+      continue;
+    }
+
+    // Deduplicate values
+    const seenValues = new Set<string>();
+    const uniqueValues: typeof enumDef.values = [];
+    for (const v of enumDef.values) {
+      const vs = String(v.value);
+      if (!seenValues.has(vs)) {
+        seenValues.add(vs);
+        uniqueValues.push(v);
+      }
+    }
+
+    const humanized = humanize(enumDef.name);
+    lines.push(`// ${typeName} represents ${humanized} values.`);
+    lines.push(`type ${typeName} string`);
+    lines.push('');
+    lines.push('const (');
+
+    const usedNames = new Set<string>();
+    for (const v of uniqueValues) {
+      let constSuffix = className(String(v.value));
+      // Avoid collision with the type itself
+      if (usedNames.has(`${typeName}${constSuffix}`)) {
+        let suffix = 2;
+        while (usedNames.has(`${typeName}${constSuffix}${suffix}`)) suffix++;
+        constSuffix = `${constSuffix}${suffix}`;
+      }
+      const constName = `${typeName}${constSuffix}`;
+      usedNames.add(constName);
+      const valueStr = typeof v.value === 'string' ? `"${v.value}"` : String(v.value);
+      if (v.description) {
+        lines.push(`\t// ${constName} is ${v.description}.`);
+      }
+      if (v.deprecated) {
+        if (v.description) lines.push(`\t//`);
+        lines.push(`\t// Deprecated: this value is deprecated.`);
+      }
+      lines.push(`\t${constName} ${typeName} = ${valueStr}`);
+    }
+    lines.push(')');
+    lines.push('');
+  }
+
+  files.push({
+    path: 'enums.go',
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  });
+
+  return files;
+}
+
+/** Known acronyms to preserve as single tokens during humanization. */
+const HUMANIZE_ACRONYMS: [RegExp, string][] = [
+  [/OAuth/g, 'OAUTH_ACRN'],
+  [/URN/g, 'URN_ACRN'],
+  [/IETF/g, 'IETF_ACRN'],
+  [/API/g, 'API_ACRN'],
+  [/SSO/g, 'SSO_ACRN'],
+  [/PKCE/g, 'PKCE_ACRN'],
+  [/JWT/g, 'JWT_ACRN'],
+  [/MFA/g, 'MFA_ACRN'],
+  [/TOTP/g, 'TOTP_ACRN'],
+  [/SAML/g, 'SAML_ACRN'],
+  [/SCIM/g, 'SCIM_ACRN'],
+  [/OIDC/g, 'OIDC_ACRN'],
+  [/CORS/g, 'CORS_ACRN'],
+  [/RBAC/g, 'RBAC_ACRN'],
+];
+
+const HUMANIZE_RESTORE: [RegExp, string][] = [
+  [/oauth_acrn/g, 'OAuth'],
+  [/urn_acrn/g, 'URN'],
+  [/ietf_acrn/g, 'IETF'],
+  [/api_acrn/g, 'API'],
+  [/sso_acrn/g, 'SSO'],
+  [/pkce_acrn/g, 'PKCE'],
+  [/jwt_acrn/g, 'JWT'],
+  [/mfa_acrn/g, 'MFA'],
+  [/totp_acrn/g, 'TOTP'],
+  [/saml_acrn/g, 'SAML'],
+  [/scim_acrn/g, 'SCIM'],
+  [/oidc_acrn/g, 'OIDC'],
+  [/cors_acrn/g, 'CORS'],
+  [/rbac_acrn/g, 'RBAC'],
+];
+
+function humanize(name: string): string {
+  // Replace known acronyms with placeholders before splitting
+  let s = name;
+  for (const [pattern, replacement] of HUMANIZE_ACRONYMS) {
+    s = s.replace(pattern, replacement);
+  }
+  let result = s.replace(/([a-z])([A-Z])/g, '$1 $2');
+  result = result.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+  result = result.toLowerCase();
+  for (const [pattern, replacement] of HUMANIZE_RESTORE) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+
+function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
+  const hashGroups = new Map<string, string[]>();
+  for (const enumDef of enums) {
+    const hash = [...enumDef.values]
+      .map((v) => String(v.value))
+      .sort()
+      .join('|');
+    if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+    hashGroups.get(hash)!.push(enumDef.name);
+  }
+
+  const aliasOf = new Map<string, string>();
+  for (const [, names] of hashGroups) {
+    if (names.length <= 1) continue;
+    const sorted = [...names].sort();
+    const canonical = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+      aliasOf.set(sorted[i], canonical);
+    }
+  }
+  return aliasOf;
+}
+
+export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
+  const enumToService = new Map<string, string>();
+  const enumNames = new Set(enums.map((e) => e.name));
+
+  for (const service of services) {
+    for (const op of service.operations) {
+      const refs = new Set<string>();
+      const collect = (ref: any) => {
+        walkTypeRef(ref, { enum: (r: any) => refs.add(r.name) });
+      };
+      if (op.requestBody) collect(op.requestBody);
+      collect(op.response);
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
+        collect(p.type);
+      }
+      for (const name of refs) {
+        if (enumNames.has(name) && !enumToService.has(name)) {
+          enumToService.set(name, service.name);
+        }
+      }
+    }
+  }
+
+  return enumToService;
+}

package/src/go/fixtures.ts

@@ -0,0 +1,212 @@
+import type { Model, TypeRef, Enum } from '@workos/oagen';
+import { fileName, fieldName } from './naming.js';
+import { isListMetadataModel, isListWrapperModel } from './models.js';
+
+/**
+ * Prefix mapping for generating realistic ID fixture values.
+ */
+export const ID_PREFIXES: Record<string, string> = {
+  Connection: 'conn_',
+  Organization: 'org_',
+  OrganizationMembership: 'om_',
+  User: 'user_',
+  Directory: 'directory_',
+  DirectoryGroup: 'dir_grp_',
+  DirectoryUser: 'dir_usr_',
+  Invitation: 'inv_',
+  Session: 'session_',
+  AuthenticationFactor: 'auth_factor_',
+  EmailVerification: 'email_verification_',
+  MagicAuth: 'magic_auth_',
+  PasswordReset: 'password_reset_',
+};
+
+/**
+ * Generate JSON fixture files for test data.
+ */
+export function generateFixtures(spec: {
+  models: Model[];
+  enums: Enum[];
+  services: any[];
+}): { path: string; content: string }[] {
+  if (spec.models.length === 0) return [];
+
+  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+  const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
+  const files: { path: string; content: string }[] = [];
+
+  for (const model of spec.models) {
+    if (isListMetadataModel(model)) continue;
+    if (isListWrapperModel(model)) continue;
+
+    const fixture = model.fields.length === 0 ? {} : generateModelFixture(model, modelMap, enumMap);
+
+    files.push({
+      path: `testdata/${fileName(model.name)}.json`,
+      content: JSON.stringify(fixture, null, 2),
+    });
+  }
+
+  // Generate list fixtures for paginated responses
+  for (const service of spec.services) {
+    for (const op of service.operations) {
+      if (op.pagination) {
+        let itemModel = op.pagination.itemType.kind === 'model' ? modelMap.get(op.pagination.itemType.name) : null;
+        if (itemModel) {
+          const unwrapped = unwrapListModel(itemModel, modelMap);
+          if (unwrapped) itemModel = unwrapped;
+          if (itemModel.fields.length === 0) continue;
+          const fixture = generateModelFixture(itemModel, modelMap, enumMap);
+          const listFixture = {
+            data: [fixture],
+            list_metadata: {
+              before: null,
+              after: null,
+            },
+          };
+          files.push({
+            path: `testdata/list_${fileName(itemModel.name)}.json`,
+            content: JSON.stringify(listFixture, null, 2),
+          });
+        }
+      }
+    }
+  }
+
+  // Deduplicate fixtures with identical content.
+  // When multiple fixtures have the same content, emit one shared file and
+  // rewrite the others as references to the shared path.
+  const contentGroups = new Map<string, string[]>();
+  for (const f of files) {
+    if (!contentGroups.has(f.content)) contentGroups.set(f.content, []);
+    contentGroups.get(f.content)!.push(f.path);
+  }
+
+  const pathRewrites = new Map<string, string>();
+  for (const [_content, paths] of contentGroups) {
+    if (paths.length < 3) continue; // only dedup when 3+ files are identical
+    // Use the shortest path as the canonical shared fixture
+    const sorted = [...paths].sort((a, b) => a.length - b.length);
+    const canonical = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+      pathRewrites.set(sorted[i], canonical);
+    }
+  }
+
+  // Remove duplicate files (they'll reference the canonical)
+  const deduped = files.filter((f) => !pathRewrites.has(f.path));
+
+  return deduped;
+}
+
+function unwrapListModel(model: Model, modelMap: Map<string, Model>): Model | null {
+  const dataField = model.fields.find((f) => f.name === 'data');
+  const hasListMetadata = model.fields.some((f) => f.name === 'list_metadata' || f.name === 'listMetadata');
+  if (dataField && hasListMetadata && dataField.type.kind === 'array') {
+    const itemType = dataField.type.items;
+    if (itemType.kind === 'model') {
+      return modelMap.get(itemType.name) ?? null;
+    }
+  }
+  return null;
+}
+
+export function generateModelFixture(
+  model: Model,
+  modelMap: Map<string, Model>,
+  enumMap: Map<string, Enum>,
+): Record<string, any> {
+  const fixture: Record<string, any> = {};
+
+  const seenFieldNames = new Set<string>();
+  const deduplicatedFields = model.fields.filter((f) => {
+    const goName = fieldName(f.name);
+    if (seenFieldNames.has(goName)) return false;
+    seenFieldNames.add(goName);
+    return true;
+  });
+
+  for (const field of deduplicatedFields) {
+    const wireName = field.name;
+    if (field.example !== undefined) {
+      fixture[wireName] = field.example;
+    } else {
+      fixture[wireName] = generateFieldValue(field.type, field.name, model.name, modelMap, enumMap);
+    }
+  }
+
+  return fixture;
+}
+
+function generateFieldValue(
+  ref: TypeRef,
+  fName: string,
+  modelName: string,
+  modelMap: Map<string, Model>,
+  enumMap: Map<string, Enum>,
+): any {
+  switch (ref.kind) {
+    case 'primitive':
+      return generatePrimitiveValue(ref.type, ref.format, fName, modelName);
+    case 'literal':
+      return ref.value;
+    case 'enum': {
+      const e = enumMap.get(ref.name);
+      return e?.values[0]?.value ?? 'unknown';
+    }
+    case 'model': {
+      const nested = modelMap.get(ref.name);
+      if (nested) return generateModelFixture(nested, modelMap, enumMap);
+      return {};
+    }
+    case 'array': {
+      if (ref.items.kind === 'enum') {
+        const e = enumMap.get(ref.items.name);
+        if (e && e.values.length > 0) {
+          return e.values.map((v) => v.value);
+        }
+      }
+      const item = generateFieldValue(ref.items, fName, modelName, modelMap, enumMap);
+      return [item];
+    }
+    case 'nullable':
+      return generateFieldValue(ref.inner, fName, modelName, modelMap, enumMap);
+    case 'union':
+      if (ref.variants.length > 0) {
+        return generateFieldValue(ref.variants[0], fName, modelName, modelMap, enumMap);
+      }
+      return null;
+    case 'map':
+      return {
+        key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap),
+      };
+  }
+}
+
+function generatePrimitiveValue(type: string, format: string | undefined, name: string, modelName: string): any {
+  switch (type) {
+    case 'string':
+      if (format === 'date-time') return '2023-01-01T00:00:00.000Z';
+      if (format === 'date') return '2023-01-01';
+      if (format === 'uuid') return '00000000-0000-0000-0000-000000000000';
+      if (name === 'id') {
+        const prefix = ID_PREFIXES[modelName] ?? '';
+        return `${prefix}01234`;
+      }
+      if (name.includes('id')) return `${name}_01234`;
+      if (name.includes('email')) return 'test@example.com';
+      if (name.includes('url') || name.includes('uri')) return 'https://example.com';
+      if (name.includes('name')) return 'Test';
+      return `test_${name}`;
+    case 'integer':
+      return 1;
+    case 'number':
+      return 1.0;
+    case 'boolean':
+      return true;
+    case 'unknown':
+      return {};
+    default:
+      return null;
+  }
+}