@workos/oagen-emitters 0.9.1 → 0.11.0

package/test/dotnet/enums.test.ts

@@ -152,6 +152,152 @@ describe('dotnet/enums', () => {
     expect(files).toHaveLength(0);
   });
 
+  it('promotes spec-default member to ordinal 0 and pushes Unknown to 99', () => {
+    const enums: Enum[] = [
+      {
+        name: 'PaginationOrder',
+        values: [
+          { name: 'NORMAL', value: 'normal' },
+          { name: 'DESC', value: 'desc' },
+          { name: 'ASC', value: 'asc' },
+        ],
+        default: 'desc',
+      },
+    ];
+
+    const service: Service = {
+      name: 'Test',
+      operations: [
+        {
+          name: 'test',
+          httpMethod: 'get',
+          path: '/test',
+          pathParams: [],
+          queryParams: [{ name: 'order', type: { kind: 'enum', name: 'PaginationOrder' }, required: false }],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    expect(files).toHaveLength(1);
+    expect(files[0].content).toMatchInlineSnapshot(`
+      "namespace WorkOS
+      {
+          using System.Runtime.Serialization;
+          using Newtonsoft.Json;
+          using STJS = System.Text.Json.Serialization;
+
+          /// <summary>Represents pagination order values.</summary>
+          [JsonConverter(typeof(WorkOSNewtonsoftStringEnumConverter))]
+          [STJS.JsonConverter(typeof(WorkOSStringEnumConverterFactory))]
+          public enum PaginationOrder
+          {
+              [EnumMember(Value = "desc")]
+              Desc = 0,
+              [EnumMember(Value = "normal")]
+              Normal = 1,
+              [EnumMember(Value = "asc")]
+              Asc = 2,
+
+              [EnumMember(Value = "unknown")]
+              Unknown = 99,
+          }
+      }"
+    `);
+  });
+
+  it('falls back to Unknown=0 layout when no default is set', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+        ],
+      },
+    ];
+
+    const service: Service = {
+      name: 'Test',
+      operations: [
+        {
+          name: 'test',
+          httpMethod: 'get',
+          path: '/test',
+          pathParams: [],
+          queryParams: [{ name: 'status', type: { kind: 'enum', name: 'Status' }, required: false }],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    expect(files).toHaveLength(1);
+    const content = files[0].content;
+    // No explicit ordinals when no default
+    expect(content).not.toMatch(/= \d+,/);
+    // Unknown sentinel emitted first (no = N)
+    const unknownIdx = content.indexOf('Unknown,');
+    const activeIdx = content.indexOf('Active,');
+    expect(unknownIdx).toBeGreaterThan(0);
+    expect(unknownIdx).toBeLessThan(activeIdx);
+  });
+
+  it('drops a spec value that collides with the unknown sentinel even when default is set', () => {
+    const enums: Enum[] = [
+      {
+        name: 'WithUnknown',
+        values: [
+          { name: 'NORMAL', value: 'normal' },
+          { name: 'UNKNOWN', value: 'unknown' },
+        ],
+        default: 'normal',
+      },
+    ];
+
+    const service: Service = {
+      name: 'Test',
+      operations: [
+        {
+          name: 'test',
+          httpMethod: 'get',
+          path: '/test',
+          pathParams: [],
+          queryParams: [{ name: 'x', type: { kind: 'enum', name: 'WithUnknown' }, required: false }],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    expect(files).toHaveLength(1);
+    const content = files[0].content;
+    expect(content).toContain('Normal = 0,');
+    expect(content).toContain('Unknown = 99,');
+    // The spec's "unknown" wire value collides with the sentinel and is dropped,
+    // so the body should not contain a non-99 ordinal for Unknown.
+    expect(content).not.toMatch(/Unknown = [0-8],/);
+  });
+
   it('generates deprecated enum values with Obsolete attribute', () => {
     const enums: Enum[] = [
       {

package/test/go/models.test.ts

@@ -256,10 +256,125 @@ describe('go/models', () => {
       	After *string \`url:"after,omitempty" json:"-"\`
       	// Limit is the maximum number of items to return per page.
       	Limit *int \`url:"limit,omitempty" json:"-"\`
-      	// Order is the sort order for results (asc or desc).
+      	// Order is the sort order for results.
       	Order *string \`url:"order,omitempty" json:"-"\`
       }
       "
     `);
   });
+
+  it('types PaginationParams.Order with the spec enum when every list op shares the same enum', () => {
+    const specWithSharedEnum: ApiSpec = {
+      ...emptySpec,
+      enums: [
+        {
+          name: 'PaginationOrder',
+          values: [
+            { name: 'normal', value: 'normal' },
+            { name: 'desc', value: 'desc' },
+            { name: 'asc', value: 'asc' },
+          ],
+        },
+      ],
+      services: [
+        {
+          name: 'Connections',
+          operations: [
+            {
+              name: 'listConnections',
+              httpMethod: 'get',
+              path: '/connections',
+              pathParams: [],
+              queryParams: [
+                { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+                { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+                { name: 'order', type: { kind: 'enum', name: 'PaginationOrder' }, required: false },
+              ],
+              headerParams: [],
+              response: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+              errors: [],
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+    const ctxTyped: EmitterContext = { namespace: 'workos', namespacePascal: 'WorkOS', spec: specWithSharedEnum };
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const content = generateModels(models, ctxTyped)[0].content;
+    expect(content).toContain('Order *PaginationOrder `url:"order,omitempty" json:"-"`');
+    expect(content).not.toContain('Order *string `url:"order,omitempty"');
+  });
+
+  it('falls back to *string when not every list op uses the same Order enum', () => {
+    const specMixed: ApiSpec = {
+      ...emptySpec,
+      services: [
+        {
+          name: 'Connections',
+          operations: [
+            {
+              name: 'listConnections',
+              httpMethod: 'get',
+              path: '/connections',
+              pathParams: [],
+              queryParams: [
+                { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+                { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+                { name: 'order', type: { kind: 'enum', name: 'PaginationOrder' }, required: false },
+              ],
+              headerParams: [],
+              response: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+              errors: [],
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+              injectIdempotencyKey: false,
+            },
+            {
+              name: 'listOrganizations',
+              httpMethod: 'get',
+              path: '/organizations',
+              pathParams: [],
+              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 },
+              ],
+              headerParams: [],
+              response: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+              errors: [],
+              pagination: {
+                strategy: 'cursor',
+                param: 'after',
+                dataPath: 'data',
+                itemType: { kind: 'model', name: 'Organization' },
+              },
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+    const ctxMixed: EmitterContext = { namespace: 'workos', namespacePascal: 'WorkOS', spec: specMixed };
+    const models: Model[] = [
+      { name: 'Organization', fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }] },
+    ];
+    const content = generateModels(models, ctxMixed)[0].content;
+    expect(content).toContain('Order *string `url:"order,omitempty" json:"-"`');
+  });
 });

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[] = [
       {