@workos/oagen-emitters 0.15.2 → 0.16.1

package/src/snippets/rust.ts

@@ -0,0 +1,189 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { fieldName, methodName, moduleName, resourceAccessorName, typeName } from '../rust/naming.js';
+
+const INDENT = '    ';
+
+export const rustSnippetEmitter: SnippetEmitter = {
+  language: 'rust',
+  fileExtension: 'rs',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const method = methodName(
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+    );
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessor = resourceAccessorName(resolved.mountOn);
+  const modulePath = moduleName(resolved.mountOn);
+  const paramsStructName = `${typeName(
+    resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+  )}Params`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let structArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    structArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    structArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const imports: string[] = ['use workos::Client;'];
+  if (structArgs.length > 0) {
+    imports.push(`use workos::${modulePath}::${paramsStructName};`);
+  }
+
+  const lines: string[] = [];
+  lines.push(...imports);
+  lines.push('');
+  lines.push('#[tokio::main]');
+  lines.push('async fn main() -> Result<(), workos::Error> {');
+  lines.push(`${INDENT}let client = Client::builder()`);
+  lines.push(`${INDENT}${INDENT}.api_key("sk_example_123456789")`);
+  lines.push(`${INDENT}${INDENT}.client_id("client_123456789")`);
+  lines.push(`${INDENT}${INDENT}.build();`);
+  lines.push('');
+
+  const callParts: string[] = [];
+  for (const p of pathArgs) {
+    const v = p.value;
+    if (typeof v === 'string') callParts.push(rustString(v));
+    else callParts.push(renderValue(v));
+  }
+  if (structArgs.length > 0) {
+    callParts.push(renderStructLiteral(paramsStructName, structArgs));
+  }
+
+  const callLines: string[] = [`${INDENT}let _result = client`, `${INDENT}${INDENT}.${accessor}()`];
+  if (callParts.length === 0) {
+    callLines.push(`${INDENT}${INDENT}.${method}()`);
+  } else if (callParts.length === 1 && !callParts[0]!.includes('\n')) {
+    callLines.push(`${INDENT}${INDENT}.${method}(${callParts[0]})`);
+  } else {
+    callLines.push(`${INDENT}${INDENT}.${method}(`);
+    for (let i = 0; i < callParts.length; i++) {
+      const trailing = i < callParts.length - 1 ? ',' : '';
+      const indented = indentContinuationLines(callParts[i]!, `${INDENT}${INDENT}${INDENT}`);
+      callLines.push(`${INDENT}${INDENT}${INDENT}${indented}${trailing}`);
+    }
+    callLines.push(`${INDENT}${INDENT})`);
+  }
+  callLines.push(`${INDENT}${INDENT}.await?;`);
+  lines.push(...callLines);
+
+  lines.push('');
+  lines.push(`${INDENT}Ok(())`);
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+function renderStructLiteral(structName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`${structName} {`];
+  for (const a of args) {
+    const field = fieldName(a.wireName);
+    const value = renderStructValue(a.value);
+    lines.push(`${INDENT}${field}: ${indentContinuationLines(value, INDENT)},`);
+  }
+  lines.push(`${INDENT}..Default::default()`);
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Rust literal rendering
+// ---------------------------------------------------------------------------
+
+/** Top-level value rendering (no `.into()` wrap — used for path params etc.). */
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'None';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return rustString(value);
+  if (Array.isArray(value)) return renderVec(value);
+  if (typeof value === 'object') return renderInlineObject(value as Record<string, unknown>);
+  return 'None';
+}
+
+/** Struct-field rendering: wraps strings with `.into()` so `String` fields accept &str. */
+function renderStructValue(value: unknown): string {
+  if (typeof value === 'string') return `${rustString(value)}.into()`;
+  if (Array.isArray(value)) return renderVecStructValues(value);
+  return renderValue(value);
+}
+
+function rustString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderVec(items: unknown[]): string {
+  if (items.length === 0) return 'vec![]';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `vec![${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['vec!['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function renderVecStructValues(items: unknown[]): string {
+  if (items.length === 0) return 'vec![]';
+  const rendered = items.map((v) => renderStructValue(v));
+  const oneline = `vec![${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['vec!['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+/** Render a plain object as a generic `serde_json::json!({...})` literal. The
+ *  snippet doesn't know the exact Rust struct corresponding to each nested
+ *  object, so we fall back to a serde-friendly literal a developer can swap
+ *  for the concrete struct (e.g. `OrganizationDomainData { ... }`). */
+function renderInlineObject(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'serde_json::json!({})';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `serde_json::json!({ ${rendered.map((e) => `"${e.key}": ${e.value}`).join(', ')} })`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['serde_json::json!({'];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}"${e.key}": ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push('})');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/test/node/enums.test.ts

@@ -1,7 +1,13 @@
-import { describe, it, expect } from 'vitest';
-import type { EmitterContext, ApiSpec, Enum } from '@workos/oagen';
+import { describe, it, expect, vi } from 'vitest';
+import type { EmitterContext, ApiSpec, Enum, Model } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
 import { generateEnums } from '../../src/node/enums.js';
+import { nodeEmitter } from '../../src/node/index.js';
+import { emptyLiveSurface, setActiveLiveSurface } from '../../src/node/live-surface.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 
 const emptySpec: ApiSpec = {
   name: 'Test',
@@ -126,3 +132,234 @@ describe('generateEnums', () => {
     expect(result[0].content).toContain('/** @deprecated */');
   });
 });
+
+describe('assignEnumsToServices owned-service dependency reassignment', () => {
+  it('follows a reassigned dependency model into the owned service', () => {
+    // The enum is referenced only through `AuditLogsRetention`, whose
+    // first-reference assignment is Organizations (unemittable this run).
+    // When the owned AuditLogs service pulls the model into `audit-logs/`,
+    // the enum must follow — otherwise the model file imports an enum file
+    // that is emitted nowhere.
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    setActiveLiveSurface(surface);
+    try {
+      const enums: Enum[] = [
+        {
+          name: 'RetentionPeriod',
+          values: [
+            { name: 'THIRTY_DAYS', value: '30d' },
+            { name: 'NINETY_DAYS', value: '90d' },
+          ],
+        },
+      ];
+      const models = [
+        {
+          name: 'AuditLogsRetention',
+          fields: [
+            {
+              name: 'period',
+              type: { kind: 'enum' as const, name: 'RetentionPeriod', values: ['30d', '90d'] },
+              required: true,
+            },
+          ],
+        },
+      ];
+      const retentionOp = (name: string, path: string) => ({
+        name,
+        httpMethod: 'get' as const,
+        path,
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model' as const, name: 'AuditLogsRetention' },
+        errors: [],
+        injectIdempotencyKey: false,
+      });
+      const services = [
+        { name: 'Organizations', operations: [retentionOp('getRetention', '/organizations/{id}/retention')] },
+        { name: 'AuditLogs', operations: [retentionOp('getAuditLogsRetention', '/audit_logs/retention')] },
+      ];
+      const ctxOwned: EmitterContext = {
+        ...ctx,
+        spec: { ...emptySpec, enums, models, services },
+        emitterOptions: { ownedServices: ['AuditLogs'] },
+      } as EmitterContext;
+
+      const result = generateEnums(enums, ctxOwned);
+      expect(result).toHaveLength(1);
+      expect(result[0].path).toBe('src/audit-logs/interfaces/retention-period.interface.ts');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+});
+
+describe('owned-service enum emission under the live-surface skip', () => {
+  function ownedDomainSpec(enums: Enum[], models: Model[]): ApiSpec {
+    return {
+      ...emptySpec,
+      enums,
+      models,
+      services: [
+        {
+          name: 'OrganizationDomains',
+          operations: [
+            {
+              name: 'getOrganizationDomain',
+              httpMethod: 'get',
+              path: '/organization_domains/{id}',
+              pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'OrganizationDomain' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  const stateEnum: Enum = {
+    name: 'OrganizationDomainState',
+    values: [
+      { name: 'VERIFIED', value: 'verified' },
+      { name: 'PENDING', value: 'pending' },
+    ],
+  };
+  const domainModel: Model = {
+    name: 'OrganizationDomain',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      {
+        name: 'state',
+        type: { kind: 'enum', name: 'OrganizationDomainState', values: ['verified', 'pending'] },
+        required: true,
+      },
+    ],
+  };
+
+  it('still emits the union module when the name is declared in a file the owned regeneration overwrites', () => {
+    // Real instance (OrganizationDomains rebuild, service OWNED): the
+    // on-disk organization-domain.interface.ts declared the enum names, so
+    // the live-surface skip suppressed emitting the canonical modules — but
+    // that very file was simultaneously being OVERWRITTEN by the owned
+    // regeneration, leaving the names declared nowhere.
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    surface.files.add('src/organization-domains/interfaces/organization-domain.interface.ts');
+    surface.interfaces.set('OrganizationDomainState', {
+      filePath: 'src/organization-domains/interfaces/organization-domain.interface.ts',
+      fields: new Set(),
+    });
+    setActiveLiveSurface(surface);
+    try {
+      const ctxOwned: EmitterContext = {
+        ...ctx,
+        spec: ownedDomainSpec([stateEnum], [domainModel]),
+        emitterOptions: { ownedServices: ['OrganizationDomains'] },
+      } as EmitterContext;
+
+      const result = generateEnums([stateEnum], ctxOwned);
+      const enumFile = result.find(
+        (f) => f.path === 'src/organization-domains/interfaces/organization-domain-state.interface.ts',
+      );
+      expect(enumFile).toBeDefined();
+      expect(enumFile!.content).toContain('export const OrganizationDomainState = {');
+      expect(enumFile!.content).toContain('export type OrganizationDomainState =');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('keeps the skip for non-owned services whose enum genuinely lives elsewhere', () => {
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts');
+    surface.interfaces.set('OrganizationDomainState', {
+      filePath: 'src/common/interfaces/organization-domain-state.interface.ts',
+      fields: new Set(),
+    });
+    setActiveLiveSurface(surface);
+    try {
+      const ctxNotOwned: EmitterContext = {
+        ...ctx,
+        spec: ownedDomainSpec([stateEnum], [domainModel]),
+      } as EmitterContext;
+
+      const result = generateEnums([stateEnum], ctxNotOwned);
+      expect(result).toHaveLength(0);
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('emits the module, resolves the barrel export, and imports the name in the model file', () => {
+    // End-to-end shape of the OrganizationDomains failure: generated
+    // organization-domain.interface.ts used `OrganizationDomainState` with
+    // NO import, and interfaces/index.ts exported
+    // ./organization-domain-state.interface — a module no hook ever emitted.
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'node-owned-enum-'));
+    try {
+      const ifaceDir = path.join(tmpRoot, 'src', 'organization-domains', 'interfaces');
+      fs.mkdirSync(ifaceDir, { recursive: true });
+      fs.writeFileSync(path.join(tmpRoot, 'src', 'workos.ts'), 'export class WorkOS {}\n');
+      fs.writeFileSync(
+        path.join(ifaceDir, 'organization-domain.interface.ts'),
+        [
+          "export type OrganizationDomainState = 'verified' | 'pending';",
+          '',
+          'export interface OrganizationDomain {',
+          '  id: string;',
+          '  state: OrganizationDomainState;',
+          '}',
+        ].join('\n'),
+      );
+      execFileSync('git', ['init'], { cwd: tmpRoot, stdio: 'ignore' });
+      execFileSync('git', ['add', 'src'], { cwd: tmpRoot, stdio: 'ignore' });
+
+      const spec = ownedDomainSpec([stateEnum], [domainModel]);
+      const runCtx = {
+        ...ctx,
+        spec,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['OrganizationDomains'] },
+      } as EmitterContext;
+
+      const modelFiles = nodeEmitter.generateModels([domainModel], runCtx);
+      const enumFiles = nodeEmitter.generateEnums([stateEnum], runCtx);
+      const clientFiles = nodeEmitter.generateClient(spec, runCtx);
+
+      // The canonical union module IS emitted…
+      const enumPath = 'src/organization-domains/interfaces/organization-domain-state.interface.ts';
+      expect(enumFiles.some((f) => f.path === enumPath)).toBe(true);
+
+      // …the model file imports the name from it…
+      const modelFile = modelFiles.find(
+        (f) => f.path === 'src/organization-domains/interfaces/organization-domain.interface.ts',
+      );
+      expect(modelFile).toBeDefined();
+      expect(modelFile!.content).toContain(
+        "import type { OrganizationDomainState } from './organization-domain-state.interface';",
+      );
+
+      // …and the barrel export resolves to an emitted module instead of a
+      // phantom the import-invariant pass has to drop.
+      const barrel = clientFiles.find((f) => f.path === 'src/organization-domains/interfaces/index.ts');
+      expect(barrel).toBeDefined();
+      expect(barrel!.content).toContain("export * from './organization-domain-state.interface';");
+
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        nodeEmitter.generateTests(spec, runCtx);
+        const dropped = warnSpy.mock.calls.filter((call) => String(call[0]).includes('dropped unresolvable'));
+        expect(dropped).toEqual([]);
+      } finally {
+        warnSpy.mockRestore();
+      }
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});