@workos/oagen-emitters 0.4.0 → 0.6.0

package/test/node/utils.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { modelHasNewFields } from '../../src/node/utils.js';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+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('modelHasNewFields', () => {
+  const model: Model = {
+    name: 'Organization',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  };
+
+  it('returns true when no apiSurface exists (Scenario B)', () => {
+    expect(modelHasNewFields(model, ctx)).toBe(true);
+  });
+
+  it('returns true when model has no baseline entry (new model)', () => {
+    const ctxWithSurface: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        interfaces: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+      },
+    };
+    expect(modelHasNewFields(model, ctxWithSurface)).toBe(true);
+  });
+
+  it('returns false when all fields exist in baseline', () => {
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              name: { name: 'name', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(model, ctxWithBaseline)).toBe(false);
+  });
+
+  it('returns true when model has one new field not in baseline', () => {
+    const modelWithNewField: Model = {
+      name: 'Organization',
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'slug', type: { kind: 'primitive', type: 'string' }, required: false },
+      ],
+    };
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              name: { name: 'name', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(modelWithNewField, ctxWithBaseline)).toBe(true);
+  });
+
+  it('converts snake_case IR field names to camelCase for baseline comparison', () => {
+    const snakeModel: Model = {
+      name: 'Organization',
+      fields: [{ name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              organizationId: { name: 'organizationId', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(snakeModel, ctxWithBaseline)).toBe(false);
+  });
+});

package/test/php/models.test.ts

@@ -436,7 +436,7 @@ describe('generateModels', () => {
     expect(file!.content).not.toContain('instanceof \\BackedEnum');
   });
 
-  it('deduplicates structurally identical models', () => {
+  it('emits all structurally identical models as full classes', () => {
     const models: Model[] = [
       {
         name: 'FlagCreatedContextActor',
@@ -464,11 +464,12 @@ describe('generateModels', () => {
     const specWithModels = { ...emptySpec, models };
     const result = generateModels(models, { ...ctx, spec: specWithModels });
 
-    // Only the trait + one canonical model file should be emitted (not 3)
+    // PHP readonly classes cannot be aliased, so all models are emitted as full classes
     const modelFiles = result.filter((f) => !f.path.includes('Trait'));
-    expect(modelFiles).toHaveLength(1);
-    // Shortest class name wins as canonical
+    expect(modelFiles).toHaveLength(3);
     expect(modelFiles[0].path).toContain('FlagCreatedContextActor');
+    expect(modelFiles[1].path).toContain('FlagUpdatedContextActor');
+    expect(modelFiles[2].path).toContain('FlagDeletedContextActor');
   });
 
   it('does not produce double |null in @var for nullable optional arrays', () => {

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(
       {
@@ -505,7 +570,7 @@ describe('generateResources', () => {
     const content = result[0].content;
 
     expect(content).toContain('): string {');
-    expect(content).toContain("return $this->client->buildUrl('sso/logout', $query, $options);");
+    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');
   });

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { generateManifest } from '../../src/python/manifest.js';
+import { buildOperationsMap } from '../../src/python/manifest.js';
 import type { ApiSpec, EmitterContext, Service, Model } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
 
@@ -61,14 +61,14 @@ const ctx: EmitterContext = {
   spec,
 };
 
-describe('generateManifest', () => {
+describe('buildOperationsMap', () => {
   it('uses flat client access paths (no dotted namespaces)', () => {
-    const files = generateManifest(spec, ctx);
-    expect(files).toHaveLength(1);
+    const ops = buildOperationsMap(spec, ctx);
 
-    const manifest = JSON.parse(files[0].content) as Record<string, { sdkMethod: string; service: string }>;
-    expect(manifest['GET /organizations'].service).toBe('organizations');
+    const orgEntry = ops['GET /organizations'] as { sdkMethod: string; service: string };
+    expect(orgEntry.service).toBe('organizations');
     // Flat: no dotted access, each service has its own accessor
-    expect(manifest['GET /organizations/api_keys'].service).toBe('organizations_api_keys');
+    const apiKeysEntry = ops['GET /organizations/api_keys'] as { sdkMethod: string; service: string };
+    expect(apiKeysEntry.service).toBe('organizations_api_keys');
   });
 });

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',