@workos/oagen-emitters 0.9.1 → 0.11.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

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