@workos/oagen-emitters 0.3.0 → 0.5.0

package/test/php/resources.test.ts

@@ -379,6 +379,71 @@ describe('generateResources', () => {
     expect(result[0].content).toContain('(deprecated) The organization ID');
   });
 
+  it('uses body model field types for parameter group variant classes', () => {
+    const membershipModels: 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 membershipServices: 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: true }],
+                  },
+                  {
+                    name: 'multiple',
+                    parameters: [{ name: 'role_slugs', type: { kind: 'primitive', type: 'string' }, required: true }],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const spec = { ...emptySpec, services: membershipServices, models: membershipModels };
+    const result = generateResources(membershipServices, { ...ctx, spec });
+    const roleMultiple = result.find((file) => file.path === 'lib/Service/RoleMultiple.php');
+
+    expect(roleMultiple).toBeDefined();
+    expect(roleMultiple!.content).toContain('public readonly array $slugs');
+  });
+
   it('requires inferred client credentials in wrapper methods', () => {
     const lines = generateWrapperMethods(
       {
@@ -470,6 +535,44 @@ describe('generateResources', () => {
     // Should inject default and inferred values into query
     expect(content).toContain("'response_type' => 'code'");
     expect(content).toContain("$query['client_id'] = $this->client->requireClientId()");
+
+    // Redirect endpoint: should return string and build URL, not make HTTP request
+    expect(content).toContain('): string {');
+    expect(content).toContain('$this->client->buildUrl(');
+    expect(content).not.toContain('$this->client->request(');
+    expect(content).toContain('@return string');
+    // Should pass $options to buildUrl for base URL overrides
+    expect(content).toContain('$options);');
+  });
+
+  it('generates redirect endpoint that builds URL for GET with primitive unknown response', () => {
+    const logoutServices: Service[] = [
+      {
+        name: 'SSO',
+        operations: [
+          {
+            name: 'getLogoutUrl',
+            httpMethod: 'get',
+            path: '/sso/logout',
+            pathParams: [],
+            queryParams: [{ name: 'token', type: { kind: 'primitive', type: 'string' }, required: true }],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const spec = { ...emptySpec, services: logoutServices };
+    const result = generateResources(logoutServices, { ...ctx, spec });
+    const content = result[0].content;
+
+    expect(content).toContain('): string {');
+    expect(content).toContain("return $this->client->buildUrl(path: 'sso/logout', query: $query, options: $options);");
+    expect(content).not.toContain('$this->client->request(');
+    expect(content).toContain('@return string');
   });
 
   it('skips base method when wrappers exist', () => {

package/test/php/tests.test.ts

@@ -106,6 +106,73 @@ describe('generateTests', () => {
     expect(resourceTest!.content).toContain('foreach ($result as $item)');
   });
 
+  it('generates redirect endpoint test with query param assertions', () => {
+    const ssoServices: Service[] = [
+      {
+        name: 'SSO',
+        operations: [
+          {
+            name: 'getAuthorizationUrl',
+            httpMethod: 'get',
+            path: '/sso/authorize',
+            pathParams: [],
+            queryParams: [
+              { name: 'client_id', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'response_type', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'redirect_uri', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'state', type: { kind: 'primitive', type: 'string' }, required: false },
+            ],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const ssoSpec = { ...spec, services: ssoServices };
+    const ssoCtx: EmitterContext = {
+      ...ctx,
+      spec: ssoSpec,
+      resolvedOperations: [
+        {
+          operation: ssoServices[0].operations[0],
+          service: ssoServices[0],
+          methodName: 'get_authorization_url',
+          mountOn: 'SSO',
+          defaults: { response_type: 'code' },
+          inferFromClient: ['client_id'],
+        } as any,
+      ],
+    };
+
+    const result = generateTests(ssoSpec, ssoCtx);
+    const testFile = result.find((f) => f.path === 'tests/Service/SSOTest.php');
+    expect(testFile).toBeDefined();
+    const content = testFile!.content;
+
+    // Should be a redirect endpoint test (no mock responses, returns string)
+    expect(content).toContain('$this->assertIsString($result)');
+    expect(content).toContain("assertStringContainsString('sso/authorize'");
+
+    // Should parse query params from URL
+    expect(content).toContain('parse_str(parse_url($result, PHP_URL_QUERY)');
+
+    // Should assert visible query params (required and optional)
+    expect(content).toContain("assertSame('test_value', $query['redirect_uri'])");
+    expect(content).toContain("assertSame('test_value', $query['state'])");
+
+    // Should pass optional params in the method call
+    expect(content).toContain("state: 'test_value'");
+
+    // Should assert hidden defaults
+    expect(content).toContain("assertSame('code', $query['response_type'])");
+
+    // Should assert inferred client fields
+    expect(content).toContain("assertArrayHasKey('client_id', $query)");
+  });
+
   it('generates fixture JSON files', () => {
     const result = generateTests(spec, ctx);
 

package/test/plugin.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { workosEmittersPlugin } from '../src/plugin.js';
+
+describe('workosEmittersPlugin', () => {
+  it('exports emitters for all supported languages', () => {
+    const languages = workosEmittersPlugin.emitters!.map((e) => e.language);
+    expect(languages).toContain('node');
+    expect(languages).toContain('python');
+    expect(languages).toContain('php');
+    expect(languages).toContain('go');
+    expect(languages).toContain('dotnet');
+    expect(languages).toContain('kotlin');
+    expect(languages).toContain('ruby');
+    expect(languages).toHaveLength(7);
+  });
+
+  it('exports extractors for all supported languages', () => {
+    const languages = workosEmittersPlugin.extractors!.map((e) => e.language);
+    expect(languages).toContain('node');
+    expect(languages).toContain('python');
+    expect(languages).toContain('php');
+    expect(languages).toContain('go');
+    expect(languages).toContain('ruby');
+    expect(languages).toContain('rust');
+    expect(languages).toContain('kotlin');
+    expect(languages).toContain('dotnet');
+    expect(languages).toContain('elixir');
+    expect(languages).toHaveLength(9);
+  });
+
+  it('exports smoke runners for all supported languages', () => {
+    const runners = Object.keys(workosEmittersPlugin.smokeRunners!);
+    expect(runners).toContain('node');
+    expect(runners).toContain('python');
+    expect(runners).toContain('php');
+    expect(runners).toContain('go');
+    expect(runners).toContain('ruby');
+    expect(runners).toContain('rust');
+    expect(runners).toContain('kotlin');
+    expect(runners).toContain('dotnet');
+    expect(runners).toContain('elixir');
+    expect(runners).toHaveLength(9);
+  });
+
+  it('smoke runner paths are absolute', () => {
+    for (const [, runnerPath] of Object.entries(workosEmittersPlugin.smokeRunners!)) {
+      expect(runnerPath).toMatch(/^\//);
+    }
+  });
+});

package/test/python/client.test.ts

@@ -141,6 +141,62 @@ describe('generateClient', () => {
     expect(clientFile!.content).toContain('OrganizationsApiKeys');
   });
 
+  it('re-exports parameter group classes from service __init__.py', () => {
+    const groupSpec: ApiSpec = {
+      ...spec,
+      services: [
+        {
+          name: 'UserManagement',
+          operations: [
+            {
+              name: 'createOrganizationMembership',
+              httpMethod: 'post',
+              path: '/user_management/organization_memberships',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              requestBody: { kind: 'model', name: 'CreateOrganizationMembershipRequest' },
+              parameterGroups: [
+                {
+                  name: 'role',
+                  optional: false,
+                  variants: [
+                    {
+                      name: 'single',
+                      parameters: [{ name: 'role_slug', type: { kind: 'primitive', type: 'string' }, required: true }],
+                    },
+                    {
+                      name: 'multiple',
+                      parameters: [
+                        {
+                          name: 'role_slugs',
+                          type: { kind: 'array', items: { kind: 'primitive', type: 'string' } },
+                          required: true,
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+
+    const files = generateClient(groupSpec, { ...ctx, spec: groupSpec });
+    const serviceInit = files.find((f) => f.path === 'src/workos/user_management/__init__.py');
+    expect(serviceInit).toBeDefined();
+    expect(serviceInit!.content).toContain('RoleSingle');
+    expect(serviceInit!.content).toContain('RoleMultiple');
+    expect(serviceInit!.content).toContain(
+      'from ._resource import UserManagement, AsyncUserManagement, RoleSingle, RoleMultiple',
+    );
+  });
+
   it('does not generate compat shim modules', () => {
     const files = generateClient(spec, ctx);
 

package/test/python/models.test.ts

@@ -610,6 +610,105 @@ describe('generateModels', () => {
     expect(modelFile.content).toContain('""".. deprecated:: This field is deprecated."""');
   });
 
+  it('generates discriminator dispatcher with unknown fallback variant', () => {
+    const service: 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 discriminatorModel: any = {
+      name: 'EventSchema',
+      fields: [],
+      discriminator: {
+        property: 'event',
+        mapping: {
+          'user.created': 'UserCreated',
+          'dsync.user.created': 'DsyncUserCreated',
+        },
+      },
+    };
+
+    const models: 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 ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+    const dispatcherFile = files.find((f) => f.path.includes('event_schema.py'))!;
+    expect(dispatcherFile).toBeDefined();
+
+    // Has Unknown variant dataclass
+    expect(dispatcherFile.content).toContain('@dataclass(slots=True)');
+    expect(dispatcherFile.content).toContain('class EventSchemaUnknown:');
+    expect(dispatcherFile.content).toContain('raw_data: Dict[str, Any]');
+    expect(dispatcherFile.content).toContain('def from_dict(cls, data: Dict[str, Any]) -> "EventSchemaUnknown"');
+    expect(dispatcherFile.content).toContain('def to_dict(self) -> Dict[str, Any]:');
+
+    // Union includes Unknown variant
+    expect(dispatcherFile.content).toContain('EventSchemaVariant = Union[');
+    expect(dispatcherFile.content).toContain('    EventSchemaUnknown,');
+
+    // Dispatcher class
+    expect(dispatcherFile.content).toContain('class EventSchema:');
+    expect(dispatcherFile.content).toContain('_DISPATCH: ClassVar[Dict[str, type]]');
+
+    // from_dict falls back to Unknown instead of raising
+    expect(dispatcherFile.content).toContain('return EventSchemaUnknown.from_dict(data)');
+    expect(dispatcherFile.content).not.toContain('Unknown event');
+
+    // No str() coercion on discriminator value
+    expect(dispatcherFile.content).toContain('cls._DISPATCH.get(disc_value)');
+    expect(dispatcherFile.content).not.toContain('str(');
+
+    // Still raises on missing key and None value
+    expect(dispatcherFile.content).toContain("Missing required field 'event'");
+    expect(dispatcherFile.content).toContain('event must not be None');
+
+    // Barrel exports include Unknown variant
+    const barrel = files.find((f) => f.path.endsWith('__init__.py') && f.path.includes('models/'));
+    expect(barrel).toBeDefined();
+    expect(barrel!.content).toContain('EventSchemaUnknown');
+    expect(barrel!.content).toContain('EventSchemaVariant');
+  });
+
   it('deduplicates models with recursively identical sub-model references', () => {
     const service: Service = {
       name: 'Events',