@workos/oagen-emitters 0.10.0 → 0.11.0

package/test/go/resources.test.ts

@@ -168,6 +168,76 @@ describe('go/resources', () => {
     expect(content).toContain('newIterator[User](ctx, s.client, "GET", "/users", nil, "after", "data", opts,');
   });
 
+  it('propagates spec defaults into the newIterator defaults map', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'listUsers',
+            httpMethod: 'get',
+            path: '/users',
+            queryParams: [
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              {
+                name: 'limit',
+                type: { kind: 'primitive', type: 'integer' },
+                required: false,
+                default: 10,
+              },
+              {
+                name: 'order',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+                default: 'desc',
+              },
+            ],
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'User' },
+            },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const content = generateResources(services, makeCtx(spec))[0].content;
+    expect(content).toMatch(/newIterator\[User\][^\n]*map\[string\]string\{"limit": "10", "order": "desc"\}/);
+  });
+
+  it('omits defaults from newIterator when the spec carries no defaults (no client-side hardcode)', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'listUsers',
+            httpMethod: 'get',
+            path: '/users',
+            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: 'User' },
+            },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const content = generateResources(services, makeCtx(spec))[0].content;
+    // Last argument to newIterator must be `nil`, not a map literal.
+    expect(content).toMatch(/newIterator\[User\][^\n]*opts, nil\)/);
+    expect(content).not.toContain('"order": "desc"');
+  });
+
   it('generates delete methods returning error', () => {
     const services: Service[] = [
       {

package/test/php/models.test.ts

@@ -495,4 +495,81 @@ describe('generateModels', () => {
     expect(file!.content).toContain('@var array<string>|null');
     expect(file!.content).not.toContain('|null|null');
   });
+
+  it('emits ->toArray() for polymorphic union of model variants', () => {
+    const models: Model[] = [
+      {
+        name: 'ApiKey',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'owner',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'ApiKeyOwner' },
+                { kind: 'model', name: 'UserApiKeyOwner' },
+              ],
+              discriminator: {
+                property: 'type',
+                mapping: { apiKey: 'ApiKeyOwner', user: 'UserApiKeyOwner' },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'ApiKeyOwner',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'UserApiKeyOwner',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const specWithModels = { ...emptySpec, models };
+    const result = generateModels(models, { ...ctx, spec: specWithModels });
+
+    const file = findModel(result, 'ApiKey');
+    expect(file).toBeDefined();
+    // toArray must dispatch to the concrete instance, not emit the bare object.
+    expect(file!.content).toContain("'owner' => $this->owner->toArray()");
+    expect(file!.content).not.toMatch(/'owner' => \$this->owner,/);
+    // fromArray match on discriminator must throw on unknown values, not pass through raw.
+    expect(file!.content).toContain("match ($data['owner']['type'] ?? null)");
+    expect(file!.content).toContain('throw new \\UnexpectedValueException');
+    expect(file!.content).not.toMatch(/default => \$data\['owner'\]/);
+  });
+
+  it('throws at codegen time for heterogeneous union mixing model and scalar', () => {
+    const models: Model[] = [
+      {
+        name: 'Thing',
+        fields: [
+          {
+            name: 'value',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'SomeModel' },
+                { kind: 'primitive', type: 'string' },
+              ],
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'SomeModel',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const specWithModels = { ...emptySpec, models };
+    expect(() => generateModels(models, { ...ctx, spec: specWithModels })).toThrow(
+      /heterogeneous union.*model:SomeModel \| primitive/,
+    );
+  });
 });

package/test/php/resources.test.ts

@@ -122,6 +122,101 @@ describe('generateResources', () => {
     expect(result[0].content).toContain('Organization::fromArray($response)');
   });
 
+  it('reads the order param default from the spec rather than hardcoding desc', () => {
+    const orderEnum = {
+      name: 'PaginationOrder',
+      values: [
+        { name: 'desc', value: 'desc' },
+        { name: 'asc', value: 'asc' },
+      ],
+    };
+    const specWithOrder: ApiSpec = {
+      ...emptySpec,
+      enums: [orderEnum],
+      services: [
+        {
+          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: 'enum', name: 'PaginationOrder' },
+                  required: false,
+                  default: 'desc',
+                },
+              ],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+    const content = generateResources(specWithOrder.services, { ...ctx, spec: specWithOrder })[0].content;
+    // With a spec default, the param is non-nullable and defaults to the enum case.
+    expect(content).toMatch(/PaginationOrder \$order = .*PaginationOrder::Desc/);
+  });
+
+  it('emits ?order = null when the spec carries no default for `order`', () => {
+    const orderEnum = {
+      name: 'PaginationOrder',
+      values: [
+        { name: 'desc', value: 'desc' },
+        { name: 'asc', value: 'asc' },
+      ],
+    };
+    const specNoDefault: ApiSpec = {
+      ...emptySpec,
+      enums: [orderEnum],
+      services: [
+        {
+          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: 'enum', name: 'PaginationOrder' }, required: false },
+              ],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+    const content = generateResources(specNoDefault.services, { ...ctx, spec: specNoDefault })[0].content;
+    expect(content).toMatch(/\?\\WorkOS\\Resource\\PaginationOrder \$order = null/);
+    expect(content).not.toMatch(/PaginationOrder::Desc/);
+  });
+
   it('generates paginated list method', () => {
     const result = generateResources(services, ctx);
 

package/test/python/enums.test.ts

@@ -110,6 +110,97 @@ describe('generateEnums', () => {
     expect(files[0].path).toBe('src/workos/organizations/models/org_status.py');
   });
 
+  it('places enum in common/ when referenced by 2+ services', () => {
+    const makeService = (name: string, opName: string): Service => ({
+      name,
+      operations: [
+        {
+          name: opName,
+          httpMethod: 'get',
+          path: `/${name.toLowerCase()}`,
+          pathParams: [],
+          queryParams: [
+            {
+              name: 'order',
+              type: { kind: 'enum', name: 'PaginationOrder' },
+              required: false,
+            },
+          ],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    });
+
+    const enums: Enum[] = [
+      {
+        name: 'PaginationOrder',
+        values: [
+          { name: 'NORMAL', value: 'normal' },
+          { name: 'DESC', value: 'desc' },
+          { name: 'ASC', value: 'asc' },
+        ],
+      },
+    ];
+
+    // Authorization comes alphabetically first; without the shared rule the
+    // enum would land under authorization/. Two services referencing it must
+    // route it to common/ instead.
+    const services = [makeService('Authorization', 'listAuthz'), makeService('Organizations', 'listOrgs')];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services },
+    });
+
+    const enumFile = files.find((f) => f.path.endsWith('pagination_order.py'));
+    expect(enumFile).toBeDefined();
+    expect(enumFile!.path).toBe('src/workos/common/models/pagination_order.py');
+    // No service-local copy should exist.
+    expect(files.find((f) => f.path === 'src/workos/authorization/models/pagination_order.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/workos/organizations/models/pagination_order.py')).toBeUndefined();
+  });
+
+  it('keeps enum in service dir when only one service references it', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'listOrgs',
+          httpMethod: 'get',
+          path: '/orgs',
+          pathParams: [],
+          queryParams: [
+            {
+              name: 'order',
+              type: { kind: 'enum', name: 'OnlyOrgsOrder' },
+              required: false,
+            },
+          ],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const enums: Enum[] = [
+      {
+        name: 'OnlyOrgsOrder',
+        values: [{ name: 'ASC', value: 'asc' }],
+      },
+    ];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service] },
+    });
+    expect(files[0].path).toBe('src/workos/organizations/models/only_orgs_order.py');
+  });
+
   it('deduplicates values that produce the same string', () => {
     const enums: Enum[] = [
       {

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

@@ -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', () => {