@workos/oagen-emitters 0.16.0 → 0.17.0

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/rust/resources.test.ts

@@ -214,15 +214,66 @@ describe('rust/resources', () => {
     const f = generateResources(services, ctxWithWrapper, new UnionRegistry()).find(
       (x) => x.path === 'src/resources/user_management.rs',
     )!;
-    // Inferred fields read from the runtime client, not empty literals.
-    expect(f.content).toContain('"client_id": self.client.client_id()');
-    expect(f.content).toContain('"client_secret": self.client.api_key()');
+    // Inferred fields read from the runtime client and inserted only when
+    // non-empty, so secretless clients (PKCE flows) omit them entirely.
+    expect(f.content).toContain('let mut body = serde_json::json!({');
+    expect(f.content).toContain('if !self.client.client_id().is_empty() {');
+    expect(f.content).toContain('body["client_id"] = serde_json::Value::String(self.client.client_id().to_string());');
+    expect(f.content).toContain('if !self.client.api_key().is_empty() {');
+    expect(f.content).toContain(
+      'body["client_secret"] = serde_json::Value::String(self.client.api_key().to_string());',
+    );
     expect(f.content).not.toContain('"client_id": "",');
     expect(f.content).not.toContain('"client_secret": "",');
+    expect(f.content).not.toContain('"client_secret": self.client.api_key()');
     // Defaults are still emitted as literal JSON values.
     expect(f.content).toContain('"grant_type": "authorization_code"');
   });
 
+  it('throws on an unrecognized inferFromClient field instead of dropping it', () => {
+    // With the `if !expr.is_empty()` guard, an unknown field falling back to an
+    // empty literal would silently vanish from every request body (and emit
+    // dead `if !"".is_empty()` Rust). Generation must fail loud instead so a
+    // missing accessor is caught at build time, not shipped in a broken SDK.
+    const services: Service[] = [
+      {
+        name: 'UserManagement',
+        operations: [
+          {
+            name: 'authenticate',
+            httpMethod: 'post',
+            path: '/user_management/authenticate',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'AuthenticateResponse' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const baseCtx = ctxWithResolved(services);
+    const ctxWithWrapper: EmitterContext = {
+      ...baseCtx,
+      resolvedOperations: baseCtx.resolvedOperations!.map((r) => ({
+        ...r,
+        wrappers: [
+          {
+            name: 'authenticate_with_code',
+            targetVariant: 'AuthorizationCodeSessionAuthenticateRequest',
+            defaults: { grant_type: 'authorization_code' },
+            inferFromClient: ['client_id', 'tenant_id'],
+            exposedParams: ['code'],
+            optionalParams: [],
+            responseModelName: null,
+          },
+        ],
+      })),
+    };
+    expect(() => generateResources(services, ctxWithWrapper, new UnionRegistry())).toThrow(/tenant_id/);
+  });
+
   it('renders spec-level parameter defaults as doc comments', () => {
     const services: Service[] = [
       {
@@ -663,6 +714,95 @@ describe('rust/resources', () => {
     expect(f.content).not.toContain('list_events_auto_paging');
   });
 
+  it('decodes inline-envelope list responses into Page<T> instead of Vec<T>', () => {
+    // Spec responses shaped `{ object, data: [...], list_metadata }` without a
+    // named component reach the IR as a bare array plus `pagination.dataPath`.
+    // The wire format is still the envelope, so the method must decode
+    // `crate::pagination::Page<T>` — `Vec<T>` fails with a serde type error.
+    const services: Service[] = [
+      {
+        name: 'Memberships',
+        operations: [
+          {
+            name: 'listMemberships',
+            httpMethod: 'get',
+            path: '/memberships',
+            pathParams: [],
+            queryParams: [
+              {
+                name: 'after',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'array', items: { kind: 'model', name: 'Membership' } },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Membership' },
+            },
+          },
+        ],
+      },
+    ];
+    const baseCtx = ctxWithResolved(services);
+    const ctx: EmitterContext = {
+      ...baseCtx,
+      spec: { ...baseCtx.spec, models: [{ name: 'Membership', fields: [] }] },
+    };
+    const f = generateResources(services, ctx, new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/memberships.rs',
+    )!;
+    expect(f.content).toContain('Result<crate::pagination::Page<Membership>, Error>');
+    expect(f.content).not.toContain('Result<Vec<Membership>, Error>');
+    // Page<T> carries `data` + `list_metadata.after`, so auto-paging works too.
+    expect(f.content).toContain('list_memberships_auto_paging');
+    expect(f.content).toContain('Ok((page.data, page.list_metadata.after))');
+  });
+
+  it('keeps Vec<T> for true bare-array responses without an envelope', () => {
+    // A response that really is a JSON array (e.g. /users/{id}/identities)
+    // has no pagination dataPath — it must keep decoding into Vec<T>.
+    const services: Service[] = [
+      {
+        name: 'Identities',
+        operations: [
+          {
+            name: 'getUserIdentities',
+            httpMethod: 'get',
+            path: '/users/{id}/identities',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'array', items: { kind: 'model', name: 'Identity' } },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const baseCtx = ctxWithResolved(services);
+    const ctx: EmitterContext = {
+      ...baseCtx,
+      spec: { ...baseCtx.spec, models: [{ name: 'Identity', fields: [] }] },
+    };
+    const f = generateResources(services, ctx, new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/identities.rs',
+    )!;
+    expect(f.content).toContain('Result<Vec<Identity>, Error>');
+    expect(f.content).not.toContain('crate::pagination::Page');
+  });
+
   it('adds serialize_with attribute on Vec query params with explode=false', () => {
     const services: Service[] = [
       {

package/test/shared/union-flatten.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest';
+import type { Model, TypeRef, UnionType } from '@workos/oagen';
+import { flattenDiscriminatedUnionFields } from '../../src/shared/union-flatten.js';
+
+/** The `ApiKey.owner` discriminated-union shape from the WorkOS spec. */
+function ownerUnion(): UnionType {
+  return {
+    kind: 'union',
+    compositionKind: 'oneOf',
+    discriminator: { property: 'type', mapping: { organization: 'ApiKeyOwner', user: 'UserApiKeyOwner' } },
+    variants: [
+      { kind: 'model', name: 'ApiKeyOwner' },
+      { kind: 'model', name: 'UserApiKeyOwner' },
+    ],
+  };
+}
+
+function baseModels(ownerType: TypeRef): Model[] {
+  return [
+    {
+      name: 'ApiKey',
+      fields: [{ name: 'owner', type: ownerType, required: true }],
+    },
+    {
+      name: 'ApiKeyOwner',
+      fields: [
+        { name: 'type', type: { kind: 'literal', value: 'organization' }, required: true },
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      ],
+    },
+    {
+      name: 'UserApiKeyOwner',
+      fields: [
+        { name: 'type', type: { kind: 'literal', value: 'user' }, required: true },
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true },
+      ],
+    },
+  ];
+}
+
+describe('flattenDiscriminatedUnionFields', () => {
+  it('rewrites a discriminated-union field to a ref to the first variant', () => {
+    const out = flattenDiscriminatedUnionFields(baseModels(ownerUnion()));
+    const apiKey = out.find((m) => m.name === 'ApiKey')!;
+    expect(apiKey.fields[0].type).toEqual({ kind: 'model', name: 'ApiKeyOwner' });
+  });
+
+  it('merges later-variant fields into the canonical model as optional', () => {
+    const out = flattenDiscriminatedUnionFields(baseModels(ownerUnion()));
+    const canonical = out.find((m) => m.name === 'ApiKeyOwner')!;
+    const orgId = canonical.fields.find((f) => f.name === 'organization_id');
+    expect(orgId).toBeDefined();
+    expect(orgId!.required).toBe(false);
+    // Fields shared (and required) by every variant stay required.
+    expect(canonical.fields.find((f) => f.name === 'id')!.required).toBe(true);
+  });
+
+  it('widens the discriminator property to a union of its literal values', () => {
+    const out = flattenDiscriminatedUnionFields(baseModels(ownerUnion()));
+    const canonical = out.find((m) => m.name === 'ApiKeyOwner')!;
+    const typeField = canonical.fields.find((f) => f.name === 'type')!;
+    expect(typeField.type).toEqual({
+      kind: 'union',
+      variants: [
+        { kind: 'literal', value: 'organization' },
+        { kind: 'literal', value: 'user' },
+      ],
+    });
+  });
+
+  it('flattens the union when wrapped in nullable', () => {
+    const out = flattenDiscriminatedUnionFields(baseModels({ kind: 'nullable', inner: ownerUnion() }));
+    const apiKey = out.find((m) => m.name === 'ApiKey')!;
+    expect(apiKey.fields[0].type).toEqual({ kind: 'nullable', inner: { kind: 'model', name: 'ApiKeyOwner' } });
+  });
+
+  it('leaves a non-discriminated (untagged) primitive union untouched', () => {
+    // AuditLogEvent actor metadata: string | number | boolean — no discriminator.
+    const union: TypeRef = {
+      kind: 'union',
+      compositionKind: 'anyOf',
+      variants: [
+        { kind: 'primitive', type: 'string' },
+        { kind: 'primitive', type: 'number' },
+        { kind: 'primitive', type: 'boolean' },
+      ],
+    };
+    const models: Model[] = [{ name: 'Meta', fields: [{ name: 'value', type: union, required: false }] }];
+    expect(flattenDiscriminatedUnionFields(models)).toBe(models);
+  });
+
+  it('skips a union whose variants are dispatcher (discriminated) models', () => {
+    // Event-style union: each variant is itself a discriminated base. Must not flatten.
+    const union: UnionType = {
+      kind: 'union',
+      discriminator: { property: 'event', mapping: { a: 'EventA', b: 'EventB' } },
+      variants: [
+        { kind: 'model', name: 'EventA' },
+        { kind: 'model', name: 'EventB' },
+      ],
+    };
+    const models: Model[] = [
+      { name: 'Envelope', fields: [{ name: 'data', type: union, required: true }] },
+      { name: 'EventA', fields: [], discriminator: { property: 'x', mapping: {} } },
+      { name: 'EventB', fields: [], discriminator: { property: 'x', mapping: {} } },
+    ];
+    const out = flattenDiscriminatedUnionFields(models);
+    expect(out.find((m) => m.name === 'Envelope')!.fields[0].type).toBe(union);
+  });
+
+  it('does not throw when the same union is referenced by multiple container fields', () => {
+    // Re-planning the same union (canonical re-seen with an identical merge) is
+    // harmless and must not trip the collision guard.
+    const models = baseModels(ownerUnion());
+    models.push({ name: 'ApiKeyList', fields: [{ name: 'owner', type: ownerUnion(), required: false }] });
+    const out = flattenDiscriminatedUnionFields(models);
+    expect(out.find((m) => m.name === 'ApiKey')!.fields[0].type).toEqual({ kind: 'model', name: 'ApiKeyOwner' });
+    expect(out.find((m) => m.name === 'ApiKeyList')!.fields[0].type).toEqual({ kind: 'model', name: 'ApiKeyOwner' });
+  });
+
+  it('throws when two distinct unions share a first variant with differing merges', () => {
+    const unionA: UnionType = {
+      kind: 'union',
+      discriminator: { property: 'type', mapping: { shared: 'Shared', a: 'VariantA' } },
+      variants: [
+        { kind: 'model', name: 'Shared' },
+        { kind: 'model', name: 'VariantA' },
+      ],
+    };
+    const unionB: UnionType = {
+      kind: 'union',
+      discriminator: { property: 'type', mapping: { shared: 'Shared', b: 'VariantB' } },
+      variants: [
+        { kind: 'model', name: 'Shared' },
+        { kind: 'model', name: 'VariantB' },
+      ],
+    };
+    const models: Model[] = [
+      { name: 'C1', fields: [{ name: 'value', type: unionA, required: true }] },
+      { name: 'C2', fields: [{ name: 'value', type: unionB, required: true }] },
+      {
+        name: 'Shared',
+        fields: [{ name: 'type', type: { kind: 'literal', value: 'shared' }, required: true }],
+      },
+      {
+        name: 'VariantA',
+        fields: [{ name: 'foo', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'VariantB',
+        fields: [{ name: 'bar', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    expect(() => flattenDiscriminatedUnionFields(models)).toThrow(/first variant of two distinct/);
+  });
+
+  it('throws when a field shared across variants has conflicting types', () => {
+    const models = baseModels(ownerUnion());
+    // Make `id` diverge: string on the org variant, number on the user variant.
+    const user = models.find((m) => m.name === 'UserApiKeyOwner')!;
+    user.fields = user.fields.map((f) => (f.name === 'id' ? { ...f, type: { kind: 'primitive', type: 'number' } } : f));
+    expect(() => flattenDiscriminatedUnionFields(models)).toThrow(/conflicting types/);
+  });
+
+  it('does not mutate the input models', () => {
+    const models = baseModels(ownerUnion());
+    const canonicalBefore = models.find((m) => m.name === 'ApiKeyOwner')!;
+    const fieldCountBefore = canonicalBefore.fields.length;
+    flattenDiscriminatedUnionFields(models);
+    expect(canonicalBefore.fields.length).toBe(fieldCountBefore);
+    expect(models.find((m) => m.name === 'ApiKey')!.fields[0].type).toEqual(ownerUnion());
+  });
+});