@workos/oagen-emitters 0.10.0 → 0.12.0

package/test/python/models.test.ts

@@ -709,6 +709,86 @@ describe('generateModels', () => {
     expect(barrel!.content).toContain('EventSchemaVariant');
   });
 
+  it('emits strict dispatch (no raw-dict fallback, no hasattr) for fields typed as a discriminated union', () => {
+    const service: Service = {
+      name: 'ApiKeys',
+      operations: [
+        {
+          name: 'getApiKey',
+          httpMethod: 'get',
+          path: '/api_keys/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'ApiKeyCreatedData' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'ApiKeyCreatedData',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'owner',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'ApiKeyCreatedDataOwner' },
+                { kind: 'model', name: 'UserApiKeyCreatedDataOwner' },
+              ],
+              discriminator: {
+                property: 'type',
+                mapping: {
+                  organization: 'ApiKeyCreatedDataOwner',
+                  user: 'UserApiKeyCreatedDataOwner',
+                },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'ApiKeyCreatedDataOwner',
+        fields: [
+          { name: 'type', type: { kind: 'literal', value: 'organization' }, required: true },
+          { name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      {
+        name: 'UserApiKeyCreatedDataOwner',
+        fields: [
+          { name: 'type', type: { kind: 'literal', value: 'user' }, required: true },
+          { name: 'user_id', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+    ];
+
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    });
+
+    const parent = files.find((f) => f.path.endsWith('api_key_created_data.py'))!;
+    expect(parent).toBeDefined();
+
+    // from_dict performs strict dispatch and raises on unknown discriminator
+    expect(parent.content).toContain('"Unknown discriminator');
+    expect(parent.content).toContain('ApiKeyCreatedData.owner');
+    expect(parent.content).toContain('Expected one of {sorted(');
+    // Old lax fallback patterns are gone
+    expect(parent.content).not.toContain('else data["owner"]');
+    expect(parent.content).not.toContain('else data[');
+
+    // to_dict no longer needs the hasattr workaround
+    expect(parent.content).not.toContain('hasattr');
+    expect(parent.content).toContain('result["owner"] = self.owner.to_dict()');
+  });
+
   it('deduplicates models with recursively identical sub-model references', () => {
     const service: Service = {
       name: 'Events',
@@ -812,4 +892,149 @@ describe('generateModels', () => {
     expect(contextBFile.content).toContain('TypeAlias');
     expect(contextBFile.content).not.toContain('@dataclass');
   });
+
+  it('places a model in common/ when referenced by 2+ services', () => {
+    const sharedModel: Model = {
+      name: 'PageInfo',
+      fields: [
+        { name: 'page_number', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'page_size', type: { kind: 'primitive', type: 'string' }, required: true },
+      ],
+    };
+    const orgsService: Service = {
+      name: 'Authorization',
+      operations: [
+        {
+          name: 'listAuthz',
+          httpMethod: 'get',
+          path: '/authz',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'PageInfo' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+    const usersService: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'listOrgs',
+          httpMethod: 'get',
+          path: '/orgs',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'PageInfo' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+    const models: Model[] = [sharedModel];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [orgsService, usersService], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+    const sharedFile = files.find((f) => f.path.endsWith('/page_info.py'));
+    expect(sharedFile).toBeDefined();
+    expect(sharedFile!.path).toBe('src/workos/common/models/page_info.py');
+    // No service-local copy of the shared model.
+    expect(files.find((f) => f.path === 'src/workos/authorization/models/page_info.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/workos/organizations/models/page_info.py')).toBeUndefined();
+    // common/__init__.py and common/models/__init__.py both re-export PageInfo.
+    const commonInit = files.find((f) => f.path === 'src/workos/common/__init__.py');
+    expect(commonInit).toBeDefined();
+    expect(commonInit!.content).toContain('from .models import PageInfo as PageInfo');
+    const commonModelsInit = files.find((f) => f.path === 'src/workos/common/models/__init__.py');
+    expect(commonModelsInit).toBeDefined();
+    expect(commonModelsInit!.content).toContain('from .page_info import PageInfo as PageInfo');
+  });
+
+  it('keeps a model in service dir when only one service references it', () => {
+    const onlyModel: Model = {
+      name: 'OnlyOrg',
+      fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrg',
+          httpMethod: 'get',
+          path: '/orgs/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'OnlyOrg' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models: [onlyModel] },
+    };
+
+    const files = generateModels([onlyModel], ctxWithServices);
+    const file = files.find((f) => f.path.endsWith('/only_org.py'));
+    expect(file!.path).toBe('src/workos/organizations/models/only_org.py');
+  });
+
+  it('respects modelHints over the shared rule', () => {
+    const sharedModel: Model = {
+      name: 'PinnedThing',
+      fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const a: Service = {
+      name: 'Authorization',
+      operations: [
+        {
+          name: 'a',
+          httpMethod: 'get',
+          path: '/a',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'PinnedThing' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+    const b: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'b',
+          httpMethod: 'get',
+          path: '/b',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'PinnedThing' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    // PinnedThing is referenced by 2 services but explicitly pinned to Authorization.
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [a, b], models: [sharedModel] },
+      modelHints: { PinnedThing: 'Authorization' },
+    };
+
+    const files = generateModels([sharedModel], ctxWithServices);
+    expect(files.find((f) => f.path === 'src/workos/authorization/models/pinned_thing.py')).toBeDefined();
+    expect(files.find((f) => f.path === 'src/workos/common/models/pinned_thing.py')).toBeUndefined();
+  });
 });

package/test/python/resources.test.ts

@@ -83,8 +83,8 @@ describe('generateResources', () => {
     // GET method with path param
     expect(content).toContain('def get_organization(');
     expect(content).toContain('id: str,');
-    expect(content).toContain(`f"organizations/{quote(str(id), safe='')}"`);
-    expect(content).toContain('from urllib.parse import quote');
+    expect(content).toContain(`("organizations", str(id))`);
+    expect(content).not.toContain('from urllib.parse import quote');
     expect(content).toContain('model=Organization');
     // Public request methods (no underscore prefix)
     expect(content).toContain('self._client.request(');
@@ -167,6 +167,51 @@ describe('generateResources', () => {
       'after: An object ID that defines your place in the list. When the ID is not present, you are at the end of the list.',
     );
     expect(content).toContain('order: Order the results by the creation time.');
+    // The spec has no `default` for `order` here, so the SDK must NOT
+    // hardcode 'desc' on the client. Server's default applies instead.
+    expect(content).toContain('order: Optional[str] = None,');
+    expect(content).not.toContain('order: Optional[str] = "desc"');
+  });
+
+  it('reads pagination order default from the spec rather than hardcoding "desc"', () => {
+    const models: Model[] = [
+      { name: 'Organization', fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }] },
+    ];
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [
+              { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              {
+                name: 'order',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+                default: 'desc',
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'OrganizationList' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          },
+        ],
+      },
+    ];
+    const content = generateResources(services, { ...ctx, spec: { ...emptySpec, services, models } })[0].content;
+    expect(content).toContain('order: Optional[str] = "desc",');
   });
 
   it('indents multiline argument descriptions in docstrings', () => {

package/test/ruby/resources.test.ts

@@ -187,6 +187,64 @@ describe('ruby/resources', () => {
     expect(content).toContain('ListStruct.from_response(');
   });
 
+  it('reads pagination order default from the spec rather than hardcoding "desc"', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'listOrganizations',
+            queryParams: [
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+              {
+                name: 'order',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+                default: 'desc',
+              },
+            ],
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          }),
+        ],
+      },
+    ];
+    const content = generateResources(services, makeCtx(makeSpec(services)))[0].content;
+    expect(content).toContain("order: 'desc'");
+  });
+
+  it("emits order: nil when the spec carries no default (no 'desc' hardcode)", () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'listOrganizations',
+            queryParams: [
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+              { name: 'order', type: { kind: 'primitive', type: 'string' }, required: false },
+            ],
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          }),
+        ],
+      },
+    ];
+    const content = generateResources(services, makeCtx(makeSpec(services)))[0].content;
+    expect(content).toContain('order: nil');
+    expect(content).not.toContain("order: 'desc'");
+  });
+
   // ── P0-3: paginated response shape detection ──────────────────────────
 
   it('generates ListStruct for paginated endpoints with array response type', () => {

package/test/rust/client.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateClient } from '../../src/rust/client.js';
+import { generateModels } from '../../src/rust/models.js';
+import { UnionRegistry } from '../../src/rust/type-map.js';
+
+function makeCtx(spec: ApiSpec): EmitterContext {
+  return { namespace: 'workos', namespacePascal: 'WorkOS', spec };
+}
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+describe('rust/client', () => {
+  it('emits the unions module and an empty resources_api shell when there are no mount targets', () => {
+    const files = generateClient(emptySpec, makeCtx(emptySpec), new UnionRegistry());
+    expect(files.map((f) => f.path).sort()).toEqual(['src/models/_unions.rs', 'src/resources_api.rs']);
+    const unions = files.find((f) => f.path === 'src/models/_unions.rs')!;
+    expect(unions.content).toContain('No oneOf-style unions registered');
+    const api = files.find((f) => f.path === 'src/resources_api.rs')!;
+    expect(api.content).toContain('impl Client {');
+  });
+
+  it('renders unions registered earlier in the emit run', () => {
+    const registry = new UnionRegistry();
+    const models: Model[] = [
+      {
+        name: 'Event',
+        fields: [
+          {
+            name: 'payload',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'UserCreated' },
+                { kind: 'model', name: 'UserDeleted' },
+              ],
+              discriminator: {
+                property: 'event',
+                mapping: { 'user.created': 'UserCreated', 'user.deleted': 'UserDeleted' },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+    ];
+    generateModels(models, makeCtx(emptySpec), registry);
+    const files = generateClient(emptySpec, makeCtx(emptySpec), registry);
+    const unions = files.find((f) => f.path === 'src/models/_unions.rs')!;
+    expect(unions.content).toContain('#[serde(tag = "event")]');
+    expect(unions.content).toContain('pub enum EventPayloadOneOf {');
+  });
+});

package/test/rust/enums.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Enum } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateEnums } from '../../src/rust/enums.js';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+describe('rust/enums', () => {
+  it('emits a non_exhaustive enum with manual Serialize/Deserialize and a fallback variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'active', value: 'active' },
+          { name: 'inactive', value: 'inactive' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/status.rs')!;
+    expect(f.content).toContain('pub enum Status {');
+    expect(f.content).toContain('Active,');
+    expect(f.content).toContain('Inactive,');
+    expect(f.content).toContain('#[non_exhaustive]');
+    expect(f.content).toContain('Unknown(String),');
+    expect(f.content).toContain('impl Serialize for Status');
+    expect(f.content).toContain("impl<'de> Deserialize<'de> for Status");
+    expect(f.content).toContain('Self::Active => "active"');
+    expect(f.content).toContain('Self::Inactive => "inactive"');
+    // No derive(Serialize/Deserialize) — they're hand-written.
+    expect(f.content).not.toContain('Serialize, Deserialize)]');
+  });
+
+  it('round-trips non-snake-case wire values through canonical strings', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Mode',
+        values: [
+          { name: 'kebab-case', value: 'kebab-case' },
+          { name: 'mixedCase', value: 'mixedCase' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/mode.rs')!;
+    // FromStr matches the original wire string; as_str returns it back.
+    expect(f.content).toContain('"kebab-case" => Self::KebabCase');
+    expect(f.content).toContain('"mixedCase" => Self::MixedCase');
+    expect(f.content).toContain('Self::KebabCase => "kebab-case"');
+    expect(f.content).toContain('Self::MixedCase => "mixedCase"');
+  });
+
+  it('collapses alias wire values into a single canonical variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Trigger',
+        values: [
+          { name: 'sign-up', value: 'sign-up' },
+          { name: 'sign_up', value: 'sign_up' },
+          { name: 'sign up', value: 'sign up' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/trigger.rs')!;
+    // One Rust variant for all three aliases.
+    expect(f.content.match(/^\s+SignUp,$/m)).not.toBeNull();
+    // Canonical wire value is the first one seen.
+    expect(f.content).toContain('Self::SignUp => "sign-up"');
+    // Every alias deserializes into the same variant.
+    expect(f.content).toContain('"sign-up" => Self::SignUp');
+    expect(f.content).toContain('"sign_up" => Self::SignUp');
+    expect(f.content).toContain('"sign up" => Self::SignUp');
+  });
+
+  it('falls back to a non-Unknown name when the spec defines an Unknown variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'State',
+        values: [
+          { name: 'unknown', value: 'unknown' },
+          { name: 'ready', value: 'ready' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/state.rs')!;
+    expect(f.content).toContain('Unknown,');
+    expect(f.content).toContain('Unrecognized(String),');
+  });
+
+  it('skips empty enums', () => {
+    const enums: Enum[] = [{ name: 'Empty', values: [] }];
+    const files = generateEnums(enums, ctx);
+    expect(files.find((f) => f.path === 'src/enums/empty.rs')).toBeUndefined();
+  });
+
+  it('always emits a barrel even when no enums', () => {
+    const files = generateEnums([], ctx);
+    expect(files).toHaveLength(1);
+    expect(files[0]!.path).toBe('src/enums/mod.rs');
+  });
+});

package/test/rust/manifest.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { buildOperationsMap } from '../../src/rust/manifest.js';
+
+const spec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [
+    {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'createOrganization',
+          httpMethod: 'post',
+          path: '/organizations',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    },
+  ],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+  resolvedOperations: spec.services.flatMap((service) =>
+    service.operations.map((operation) => ({
+      service,
+      operation,
+      methodName: operation.name,
+      mountOn: service.name,
+      defaults: {},
+      inferFromClient: [],
+      urlBuilder: false,
+    })),
+  ),
+};
+
+describe('rust/manifest', () => {
+  it('maps each HTTP operation to an SDK method + service accessor', () => {
+    const map = buildOperationsMap(spec, ctx);
+    expect(map['POST /organizations']).toEqual({
+      sdkMethod: 'create_organization',
+      service: 'organizations',
+    });
+    expect(map['GET /organizations/{id}']).toEqual({
+      sdkMethod: 'get_organization',
+      service: 'organizations',
+    });
+  });
+});