@workos/oagen-emitters 0.15.2 → 0.16.1

package/test/node/utils.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest';
-import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import type { EmitterContext, ApiSpec, Model, Service } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
-import { modelHasNewFields } from '../../src/node/utils.js';
+import { modelHasNewFields, createServiceDirResolver } from '../../src/node/utils.js';
+import { emptyLiveSurface, setActiveLiveSurface } from '../../src/node/live-surface.js';
 
 const emptySpec: ApiSpec = {
   name: 'Test',
@@ -87,3 +88,157 @@ describe('modelHasNewFields', () => {
     expect(modelHasNewFields(model, ctxWithSurface)).toBe(true);
   });
 });
+
+describe('createServiceDirResolver owned-service dependency reassignment', () => {
+  const retentionModel: Model = {
+    name: 'AuditLogsRetention',
+    fields: [{ name: 'retention_period_in_days', type: { kind: 'primitive', type: 'integer' }, required: true }],
+  };
+
+  function retentionOp(name: string, path: string) {
+    return {
+      name,
+      httpMethod: 'get' as const,
+      path,
+      pathParams: [],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'model' as const, name: 'AuditLogsRetention' },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+  }
+
+  // Organizations comes first, so first-reference-wins assignment parks the
+  // model in `organizations/` even though only AuditLogs is owned this run.
+  const services: Service[] = [
+    { name: 'Organizations', operations: [retentionOp('getRetention', '/organizations/{id}/retention')] },
+    { name: 'AuditLogs', operations: [retentionOp('getAuditLogsRetention', '/audit_logs/retention')] },
+  ];
+
+  function makeCtx(): EmitterContext {
+    return {
+      ...ctx,
+      spec: { ...emptySpec, models: [retentionModel], services },
+      emitterOptions: { ownedServices: ['AuditLogs'] },
+    } as EmitterContext;
+  }
+
+  it('reassigns dependency models of owned services out of unemittable directories', () => {
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    setActiveLiveSurface(surface);
+    try {
+      const testCtx = makeCtx();
+      const { modelToService, resolveDir } = createServiceDirResolver([retentionModel], services, testCtx);
+      expect(resolveDir(modelToService.get('AuditLogsRetention'))).toBe('audit-logs');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('leaves the assignment alone when the interface already exists on disk', () => {
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts');
+    surface.files.add('src/organizations/interfaces/audit-logs-retention.interface.ts');
+    setActiveLiveSurface(surface);
+    try {
+      const testCtx = makeCtx();
+      const { modelToService, resolveDir } = createServiceDirResolver([retentionModel], services, testCtx);
+      expect(resolveDir(modelToService.get('AuditLogsRetention'))).toBe('organizations');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('does not reassign when no services are owned', () => {
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts');
+    setActiveLiveSurface(surface);
+    try {
+      const testCtx = { ...makeCtx(), emitterOptions: {} } as EmitterContext;
+      const { modelToService, resolveDir } = createServiceDirResolver([retentionModel], services, testCtx);
+      expect(resolveDir(modelToService.get('AuditLogsRetention'))).toBe('organizations');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+
+  it('does not reassign in greenfield mode where every directory is emittable', () => {
+    const testCtx = makeCtx();
+    const { modelToService, resolveDir } = createServiceDirResolver([retentionModel], services, testCtx);
+    expect(resolveDir(modelToService.get('AuditLogsRetention'))).toBe('organizations');
+  });
+
+  it('reassigns the full transitive closure when ops are re-mounted onto an owned service', () => {
+    // Real instance: GET/PUT /organizations/{organizationId}/audit_logs_retention
+    // live on the IR Organizations service but are MOUNTED on AuditLogs via
+    // resolvedOperations. Walking only IR services misses them entirely, so
+    // `AuditLogsRetention` (and everything it references) stays assigned to
+    // the unemittable organizations dir and is never emitted anywhere.
+    const nestedModel: Model = {
+      name: 'RetentionPolicy',
+      fields: [{ name: 'kind', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const retentionWithNested: Model = {
+      ...retentionModel,
+      fields: [
+        ...retentionModel.fields,
+        { name: 'policy', type: { kind: 'model', name: 'RetentionPolicy' }, required: true },
+      ],
+    };
+    const listOrgsOp = {
+      name: 'listOrganizations',
+      httpMethod: 'get' as const,
+      path: '/organizations',
+      pathParams: [],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'primitive' as const, type: 'unknown' as const },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+    const mountedRetentionOp = retentionOp(
+      'getAuditLogsRetention',
+      '/organizations/{organizationId}/audit_logs_retention',
+    );
+    const orgService: Service = { name: 'Organizations', operations: [listOrgsOp, mountedRetentionOp] };
+    const mountedServices: Service[] = [orgService];
+
+    const surface = emptyLiveSurface();
+    surface.files.add('src/workos.ts'); // existing SDK
+    setActiveLiveSurface(surface);
+    try {
+      const testCtx = {
+        ...ctx,
+        spec: { ...emptySpec, models: [retentionWithNested, nestedModel], services: mountedServices },
+        emitterOptions: { ownedServices: ['AuditLogs'] },
+        resolvedOperations: [
+          {
+            operation: listOrgsOp,
+            service: orgService,
+            methodName: 'list_organizations',
+            mountOn: 'Organizations',
+          },
+          {
+            operation: mountedRetentionOp,
+            service: orgService,
+            methodName: 'get_audit_logs_retention',
+            mountOn: 'AuditLogs',
+          },
+        ],
+      } as unknown as EmitterContext;
+      const { modelToService, resolveDir } = createServiceDirResolver(
+        [retentionWithNested, nestedModel],
+        mountedServices,
+        testCtx,
+      );
+      expect(resolveDir(modelToService.get('AuditLogsRetention'))).toBe('audit-logs');
+      // Nested dependency N follows M into the owned dir — the closure must
+      // not stop at the directly-referenced model.
+      expect(resolveDir(modelToService.get('RetentionPolicy'))).toBe('audit-logs');
+    } finally {
+      setActiveLiveSurface(emptyLiveSurface());
+    }
+  });
+});

package/test/snippets/_helpers.ts

@@ -0,0 +1,67 @@
+import type { ApiSpec, EmitterContext, Field, Model, Operation, ResolvedOperation, Service } from '@workos/oagen';
+import { defaultSdkBehavior, toPascalCase, toSnakeCase } from '@workos/oagen';
+
+export function makeSpec(services: Service[], models: Model[] = []): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: '',
+    services,
+    models,
+    enums: [],
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+export function buildResolvedOps(services: Service[]): ResolvedOperation[] {
+  const ops: ResolvedOperation[] = [];
+  for (const service of services) {
+    const mountOn = toPascalCase(service.name);
+    for (const op of service.operations) {
+      ops.push({
+        operation: op,
+        service,
+        methodName: toSnakeCase(op.name),
+        mountOn,
+        defaults: {},
+        inferFromClient: [],
+        urlBuilder: false,
+      });
+    }
+  }
+  return ops;
+}
+
+export function makeCtx(spec: ApiSpec): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec,
+    resolvedOperations: buildResolvedOps(spec.services),
+  };
+}
+
+export function makeOp(overrides: Partial<Operation>): Operation {
+  return {
+    name: 'listOrganizations',
+    httpMethod: 'get',
+    path: '/organizations',
+    pathParams: [],
+    queryParams: [],
+    headerParams: [],
+    requestBody: undefined,
+    response: { kind: 'model', name: 'Organization' },
+    errors: [],
+    injectIdempotencyKey: false,
+    ...overrides,
+  };
+}
+
+export function makeStringField(name: string, example?: string, required = true): Field {
+  return {
+    name,
+    type: { kind: 'primitive', type: 'string' },
+    required,
+    ...(example !== undefined ? { example } : {}),
+  };
+}

package/test/snippets/dotnet.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, Service } from '@workos/oagen';
+import { runSnippetEmitters } from '@workos/oagen';
+import { dotnetSnippetEmitter } from '../../src/snippets/dotnet.js';
+import { makeCtx, makeOp, makeSpec, makeStringField } from './_helpers.js';
+
+function runDotnet(services: Service[], models: Model[] = []): string {
+  const results = runSnippetEmitters([dotnetSnippetEmitter], makeCtx(makeSpec(services, models)));
+  return results[0]!.content;
+}
+
+describe('snippets/dotnet', () => {
+  it('renders WorkOSClient with WorkOSOptions and an Async-suffixed call', () => {
+    const content = runDotnet([{ name: 'Organizations', operations: [makeOp({ name: 'list_organizations' })] }]);
+    expect(content).toContain('using WorkOS;');
+    expect(content).toContain('var client = new WorkOSClient(new WorkOSOptions');
+    expect(content).toContain('ApiKey = "sk_example_123456789"');
+    expect(content).toContain('ClientId = "client_123456789"');
+    // Mount target `Organizations`; method `list_organizations` → ListAsync.
+    expect(content).toContain('await client.Organizations.ListAsync();');
+  });
+
+  it('builds the typed Options class for body args', () => {
+    const content = runDotnet(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [
+        {
+          name: 'CreateOrgReq',
+          fields: [makeStringField('name', 'Foo Corp')],
+        },
+      ],
+    );
+    expect(content).toContain('await client.Organizations.CreateAsync(');
+    expect(content).toContain('new OrganizationsCreateOptions');
+    expect(content).toContain('Name = "Foo Corp",');
+  });
+});

package/test/snippets/go.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, Service } from '@workos/oagen';
+import { runSnippetEmitters } from '@workos/oagen';
+import { goSnippetEmitter } from '../../src/snippets/go.js';
+import { makeCtx, makeOp, makeSpec, makeStringField } from './_helpers.js';
+
+function runGo(services: Service[], models: Model[] = []): string {
+  const results = runSnippetEmitters([goSnippetEmitter], makeCtx(makeSpec(services, models)));
+  return results[0]!.content;
+}
+
+describe('snippets/go', () => {
+  it('renders a package main with context import and client init', () => {
+    const content = runGo([{ name: 'Organizations', operations: [makeOp({ name: 'list_organizations' })] }]);
+    expect(content).toContain('package main');
+    expect(content).toContain('"context"');
+    expect(content).toContain('"github.com/workos/workos-go/v9"');
+    expect(content).toContain('client := workos.NewClient("sk_example_123456789")');
+  });
+
+  it('trims the mount-target resource from the method name', () => {
+    // Mount target is `Organizations`; the resolved method `create_organization`
+    // becomes `CreateOrganization` then trims to `Create`.
+    const content = runGo(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [{ name: 'CreateOrgReq', fields: [makeStringField('name', 'Foo Corp')] }],
+    );
+    expect(content).toContain('client.Organizations().Create(');
+    expect(content).not.toContain('CreateOrganization(');
+  });
+
+  it('renders required body fields inside a typed opts struct', () => {
+    const content = runGo(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [
+        {
+          name: 'CreateOrgReq',
+          fields: [makeStringField('name', 'Foo Corp'), makeStringField('description', undefined, false)],
+        },
+      ],
+    );
+    expect(content).toContain('&workos.OrganizationsCreateParams{');
+    expect(content).toContain('Name: "Foo Corp",');
+    expect(content).not.toContain('Description:');
+  });
+
+  it('passes required path params positionally before the opts struct', () => {
+    const content = runGo([
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'get_organization',
+            httpMethod: 'get',
+            path: '/organizations/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+                example: 'org_123',
+              },
+            ],
+          }),
+        ],
+      },
+    ]);
+    expect(content).toContain('client.Organizations().Get(context.Background(), "org_123")');
+  });
+});

package/test/snippets/kotlin.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, Service } from '@workos/oagen';
+import { runSnippetEmitters } from '@workos/oagen';
+import { kotlinSnippetEmitter } from '../../src/snippets/kotlin.js';
+import { makeCtx, makeOp, makeSpec, makeStringField } from './_helpers.js';
+
+function runKotlin(services: Service[], models: Model[] = []): string {
+  const results = runSnippetEmitters([kotlinSnippetEmitter], makeCtx(makeSpec(services, models)));
+  return results[0]!.content;
+}
+
+describe('snippets/kotlin (Java-syntax output)', () => {
+  it('emits the .java file extension and Java client init', () => {
+    const results = runSnippetEmitters(
+      [kotlinSnippetEmitter],
+      makeCtx(makeSpec([{ name: 'Organizations', operations: [makeOp({ name: 'list_organizations' })] }])),
+    );
+    expect(results[0]!.fileExtension).toBe('java');
+    expect(results[0]!.language).toBe('java');
+    expect(results[0]!.content).toContain('import com.workos.WorkOS;');
+    expect(results[0]!.content).toContain('WorkOS workos = new WorkOS("sk_example_123456789");');
+    expect(results[0]!.content).toContain('workos.organizations.listOrganizations();');
+  });
+
+  it('builds the typed Options class via builder() for body args', () => {
+    const content = runKotlin(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [
+        {
+          name: 'CreateOrgReq',
+          fields: [makeStringField('name', 'Foo Corp')],
+        },
+      ],
+    );
+    expect(content).toContain('import com.workos.organizations.OrganizationsApi.CreateOrganizationOptions;');
+    expect(content).toContain('CreateOrganizationOptions options = CreateOrganizationOptions.builder()');
+    expect(content).toContain('.name("Foo Corp")');
+    expect(content).toContain('.build();');
+    expect(content).toContain('workos.organizations.createOrganization(options);');
+  });
+});

package/test/snippets/php.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, Service } from '@workos/oagen';
+import { runSnippetEmitters } from '@workos/oagen';
+import { phpSnippetEmitter } from '../../src/snippets/php.js';
+import { makeCtx, makeOp, makeSpec, makeStringField } from './_helpers.js';
+
+function runPhp(services: Service[], models: Model[] = []): string {
+  const results = runSnippetEmitters([phpSnippetEmitter], makeCtx(makeSpec(services, models)));
+  return results[0]!.content;
+}
+
+describe('snippets/php', () => {
+  it('renders the modern WorkOS client constructor with named args', () => {
+    const content = runPhp([{ name: 'Organizations', operations: [makeOp({ name: 'list_organizations' })] }]);
+    expect(content).toContain('<?php');
+    expect(content).toContain('use WorkOS\\WorkOS;');
+    expect(content).toContain("apiKey: 'sk_example_123456789'");
+    expect(content).toContain("clientId: 'client_123456789'");
+    expect(content).toContain('$workos->organizations()->listOrganizations();');
+  });
+
+  it('camelCases body field kwargs and uses PHP named args', () => {
+    const content = runPhp(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [
+        {
+          name: 'CreateOrgReq',
+          fields: [makeStringField('name', 'Foo Corp'), makeStringField('external_id', 'ext_123')],
+        },
+      ],
+    );
+    expect(content).toContain('$workos->organizations()->createOrganization(');
+    expect(content).toContain("name: 'Foo Corp'");
+    expect(content).toContain("externalId: 'ext_123'");
+  });
+});

package/test/snippets/python.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, Service } from '@workos/oagen';
+import { runSnippetEmitters } from '@workos/oagen';
+import { pythonSnippetEmitter } from '../../src/snippets/python.js';
+import { makeCtx, makeOp, makeSpec, makeStringField } from './_helpers.js';
+
+function runPython(services: Service[], models: Model[] = []): string {
+  const results = runSnippetEmitters([pythonSnippetEmitter], makeCtx(makeSpec(services, models)));
+  return results[0]!.content;
+}
+
+describe('snippets/python', () => {
+  it('renders a no-arg call with the WorkOSClient constructor', () => {
+    const content = runPython([{ name: 'Organizations', operations: [makeOp({ name: 'list_organizations' })] }]);
+    expect(content).toContain('from workos import WorkOSClient');
+    expect(content).toContain('client = WorkOSClient(api_key="sk_example_123456789", client_id="client_123456789")');
+    expect(content).toContain('client.organizations.list_organizations()');
+  });
+
+  it('renames Python builtin path params with a trailing underscore', () => {
+    const content = runPython([
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'get_organization',
+            path: '/organizations/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+                example: 'org_123',
+              },
+            ],
+          }),
+        ],
+      },
+    ]);
+    // Python builtins ('id', 'type') get an underscore via safeParamName,
+    // so the snippet exposes `id_=` instead of shadowing the builtin.
+    expect(content).toContain('client.organizations.get_organization(id_="org_123")');
+  });
+
+  it('expands required body fields as kwargs', () => {
+    const content = runPython(
+      [
+        {
+          name: 'Organizations',
+          operations: [
+            makeOp({
+              name: 'create_organization',
+              httpMethod: 'post',
+              path: '/organizations',
+              requestBody: { kind: 'model', name: 'CreateOrgReq' },
+            }),
+          ],
+        },
+      ],
+      [
+        {
+          name: 'CreateOrgReq',
+          fields: [
+            makeStringField('name', 'Foo Corp'),
+            makeStringField('description', undefined, false), // optional
+          ],
+        },
+      ],
+    );
+    expect(content).toContain('name="Foo Corp"');
+    expect(content).not.toContain('description');
+  });
+});