@workos/oagen-emitters 0.3.0 → 0.5.0

package/test/python/resources.test.ts

@@ -614,4 +614,298 @@ describe('generateResources', () => {
     // Deprecated query param without description
     expect(content).toContain('legacy_param: (deprecated)');
   });
+
+  it('generates parameter group dataclasses, union kwargs, and isinstance dispatch', () => {
+    const models: Model[] = [
+      {
+        name: 'Widget',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'Widgets',
+        operations: [
+          {
+            name: 'listWidgets',
+            httpMethod: 'get',
+            path: '/widgets',
+            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,
+              },
+              {
+                name: 'parent_resource_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+              {
+                name: 'parent_resource_type_slug',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+              {
+                name: 'parent_resource_external_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'WidgetList' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Widget' },
+            },
+            parameterGroups: [
+              {
+                name: 'parent_resource',
+                optional: false,
+                variants: [
+                  {
+                    name: 'by_id',
+                    parameters: [
+                      {
+                        name: 'parent_resource_id',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                    ],
+                  },
+                  {
+                    name: 'by_external_id',
+                    parameters: [
+                      {
+                        name: 'parent_resource_type_slug',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                      {
+                        name: 'parent_resource_external_id',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    expect(files.length).toBe(1);
+    const content = files[0].content;
+
+    // dataclass import should be present
+    expect(content).toContain('from dataclasses import dataclass');
+
+    // Variant dataclass definitions
+    expect(content).toContain('@dataclass');
+    expect(content).toContain('class ParentResourceById:');
+    expect(content).toContain('    parent_resource_id: str');
+    expect(content).toContain('class ParentResourceByExternalId:');
+    expect(content).toContain('    parent_resource_type_slug: str');
+    expect(content).toContain('    parent_resource_external_id: str');
+
+    // Method signature should have the union kwarg, not individual grouped params
+    expect(content).toContain('parent_resource: Union[ParentResourceById, ParentResourceByExternalId],');
+    // Grouped params should NOT appear as individual kwargs
+    expect(content).not.toMatch(/^\s+parent_resource_id: str,$/m);
+    expect(content).not.toMatch(/^\s+parent_resource_type_slug: str,$/m);
+    expect(content).not.toMatch(/^\s+parent_resource_external_id: str,$/m);
+
+    // isinstance dispatch in method body
+    expect(content).toContain('if isinstance(parent_resource, ParentResourceById):');
+    expect(content).toContain('params["parent_resource_id"] = parent_resource.parent_resource_id');
+    expect(content).toContain('elif isinstance(parent_resource, ParentResourceByExternalId):');
+    expect(content).toContain('params["parent_resource_type_slug"] = parent_resource.parent_resource_type_slug');
+    expect(content).toContain('params["parent_resource_external_id"] = parent_resource.parent_resource_external_id');
+
+    // Docstring should document the group parameter
+    expect(content).toContain(
+      'parent_resource: Identifies the parent resource. One of: ParentResourceById, ParentResourceByExternalId.',
+    );
+  });
+
+  it('generates optional parameter group with Optional[Union[...]] = None', () => {
+    const models: Model[] = [
+      {
+        name: 'Thing',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'Things',
+        operations: [
+          {
+            name: 'getThing',
+            httpMethod: 'get',
+            path: '/things/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+            queryParams: [
+              {
+                name: 'scope_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+              {
+                name: 'scope_name',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'Thing' },
+            errors: [],
+            injectIdempotencyKey: false,
+            parameterGroups: [
+              {
+                name: 'scope',
+                optional: true,
+                variants: [
+                  {
+                    name: 'by_id',
+                    parameters: [
+                      {
+                        name: 'scope_id',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                    ],
+                  },
+                  {
+                    name: 'by_name',
+                    parameters: [
+                      {
+                        name: 'scope_name',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    const content = files[0].content;
+
+    // Optional group should use Optional[Union[...]] = None
+    expect(content).toContain('scope: Optional[Union[ScopeById, ScopeByName]] = None,');
+
+    // Dataclass definitions
+    expect(content).toContain('class ScopeById:');
+    expect(content).toContain('    scope_id: str');
+    expect(content).toContain('class ScopeByName:');
+    expect(content).toContain('    scope_name: str');
+
+    // isinstance dispatch in the non-paginated GET body
+    expect(content).toContain('if isinstance(scope, ScopeById):');
+    expect(content).toContain('params["scope_id"] = scope.scope_id');
+    expect(content).toContain('elif isinstance(scope, ScopeByName):');
+    expect(content).toContain('params["scope_name"] = scope.scope_name');
+  });
+
+  it('uses body model field types for parameter group dataclasses', () => {
+    const models: Model[] = [
+      {
+        name: 'OrganizationMembership',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'CreateOrganizationMembershipRequest',
+        fields: [
+          { name: 'user_id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'role_slug', type: { kind: 'primitive', type: 'string' }, required: false },
+          {
+            name: 'role_slugs',
+            type: { kind: 'array', items: { kind: 'primitive', type: 'string' } },
+            required: false,
+          },
+        ],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'UserManagement',
+        operations: [
+          {
+            name: 'createOrganizationMembership',
+            httpMethod: 'post',
+            path: '/user_management/organization_memberships',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateOrganizationMembershipRequest' },
+            response: { kind: 'model', name: 'OrganizationMembership' },
+            errors: [],
+            injectIdempotencyKey: false,
+            parameterGroups: [
+              {
+                name: 'role',
+                optional: true,
+                variants: [
+                  {
+                    name: 'single',
+                    parameters: [{ name: 'role_slug', type: { kind: 'primitive', type: 'string' }, required: false }],
+                  },
+                  {
+                    name: 'multiple',
+                    parameters: [{ name: 'role_slugs', type: { kind: 'primitive', type: 'string' }, required: false }],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    expect(files[0].content).toContain('class RoleMultiple:');
+    expect(files[0].content).toContain('    role_slugs: List[str]');
+  });
 });

package/test/python/tests.test.ts

@@ -36,6 +36,7 @@ const services: Service[] = [
         queryParams: [],
         headerParams: [],
         response: { kind: 'primitive', type: 'unknown' },
+        successResponses: [{ statusCode: 202, type: { kind: 'primitive', type: 'unknown' } }],
         errors: [],
         injectIdempotencyKey: false,
       },
@@ -77,6 +78,7 @@ describe('generateTests', () => {
     expect(content).toContain('class TestOrganizations:');
     expect(content).toContain('def test_get_organization(');
     expect(content).toContain('def test_delete_organization(');
+    expect(content).toContain('httpx_mock.add_response(status_code=202, content=b"\\n")');
     expect(content).toContain('assert result is None');
     expect(content).toContain('isinstance(result, Organization)');
   });
@@ -107,6 +109,93 @@ describe('generateTests', () => {
     expect(data).toHaveProperty('name');
   });
 
+  it('generates discriminator dispatch tests for dispatcher models', () => {
+    const discriminatorModel: any = {
+      name: 'EventSchema',
+      fields: [],
+      discriminator: {
+        property: 'event',
+        mapping: {
+          'user.created': 'UserCreated',
+          'dsync.user.created': 'DsyncUserCreated',
+        },
+      },
+    };
+
+    const discModels: Model[] = [
+      discriminatorModel,
+      {
+        name: 'UserCreated',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'event', type: { kind: 'literal', value: 'user.created' }, required: true },
+          { name: 'data', type: { kind: 'primitive', type: 'unknown' }, required: true },
+        ],
+      },
+      {
+        name: 'DsyncUserCreated',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'event', type: { kind: 'literal', value: 'dsync.user.created' }, required: true },
+          { name: 'data', type: { kind: 'primitive', type: 'unknown' }, required: true },
+        ],
+      },
+    ];
+
+    const discServices: Service[] = [
+      {
+        name: 'Events',
+        operations: [
+          {
+            name: 'listEvents',
+            httpMethod: 'get',
+            path: '/events',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'EventSchema' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'EventSchema' },
+            },
+          },
+        ],
+      },
+    ];
+
+    const discSpec: ApiSpec = {
+      ...spec,
+      models: discModels,
+      services: discServices,
+      enums: [],
+    };
+
+    const files = generateTests(discSpec, { ...ctx, spec: discSpec });
+    const roundTripTest = files.find((f) => f.path === 'tests/test_models_round_trip.py');
+    expect(roundTripTest).toBeDefined();
+
+    const content = roundTripTest!.content;
+    expect(content).toContain('class TestDiscriminatorDispatch:');
+    expect(content).toContain('def test_event_schema_dispatches_known_variant(self)');
+    expect(content).toContain('def test_event_schema_returns_unknown_for_unrecognized_type(self)');
+    expect(content).toContain('isinstance(result, EventSchemaUnknown)');
+    expect(content).toContain('def test_event_schema_raises_on_missing_discriminator(self)');
+    expect(content).toContain('def test_event_schema_raises_on_none_discriminator(self)');
+    expect(content).toContain('pytest.raises(Exception)');
+
+    // Service test should exercise discriminated union dispatch through pagination
+    const serviceTest = files.find((f) => f.path === 'tests/test_events.py');
+    expect(serviceTest).toBeDefined();
+    const svcContent = serviceTest!.content;
+    expect(svcContent).toContain('load_fixture("dsync_user_created.json")');
+    expect(svcContent).toContain('isinstance(page.data[0], DsyncUserCreated)');
+    expect(svcContent).toContain('assert len(page.data) == 1');
+  });
+
   it('generates model edge-case and query/pagination regression tests', () => {
     const edgeModels: Model[] = [
       {
@@ -188,6 +277,8 @@ describe('generateTests', () => {
     const roundTripTest = files.find((f) => f.path === 'tests/test_models_round_trip.py');
 
     expect(serviceTest).toBeDefined();
+    expect(serviceTest!.content).toContain('assert len(page.data) == 1');
+    expect(serviceTest!.content).toContain('assert isinstance(page.data[0], Organization)');
     expect(serviceTest!.content).toContain('def test_list_organizations_empty_page(');
     expect(serviceTest!.content).toContain('def test_list_organizations_encodes_query_params(');
     expect(serviceTest!.content).toContain('assert request.url.params["email"] == "value email/test"');

package/test/ruby/client.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateClient } from '../../src/ruby/client.js';
+
+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: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+];
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: 'https://api.example.com',
+  services,
+  models,
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+describe('generateClient (ruby)', () => {
+  it('generates inflections, main entry, and client files', () => {
+    const result = generateClient(emptySpec, ctx);
+
+    expect(result).toHaveLength(3);
+    expect(result[0].path).toBe('lib/workos/inflections.rb');
+    expect(result[1].path).toBe('lib/workos.rb');
+    expect(result[2].path).toBe('lib/workos/client.rb');
+  });
+
+  it('ignores inflections.rb in Zeitwerk loader', () => {
+    const result = generateClient(emptySpec, ctx);
+    const mainEntry = result[1].content;
+
+    expect(mainEntry).toContain('loader.ignore("#{__dir__}/workos/inflections.rb")');
+  });
+
+  it('ignores errors.rb in Zeitwerk loader', () => {
+    const result = generateClient(emptySpec, ctx);
+    const mainEntry = result[1].content;
+
+    expect(mainEntry).toContain('loader.ignore("#{__dir__}/workos/errors.rb")');
+  });
+
+  it('requires inflections before loader.setup', () => {
+    const result = generateClient(emptySpec, ctx);
+    const mainEntry = result[1].content;
+
+    const requireIdx = mainEntry.indexOf("require_relative 'workos/inflections'");
+    const setupIdx = mainEntry.indexOf('loader.setup');
+    expect(requireIdx).toBeGreaterThan(-1);
+    expect(setupIdx).toBeGreaterThan(requireIdx);
+  });
+});