@workos/oagen-emitters 0.18.3 → 0.19.0

package/test/rust/models.test.ts

@@ -119,6 +119,55 @@ describe('rust/models', () => {
     expect(unions.content).toContain('pub enum EventPayloadOneOf {');
   });
 
+  it('relaxes the discriminator field on internally-tagged union variants', () => {
+    // Mirrors the ApiKey `owner` union: serde's `#[serde(tag = "type")]`
+    // consumes `type` as the enum tag and strips it from the variant body, so
+    // a *required* `type` field on the variant struct can never be satisfied
+    // ("missing field `type`"). The emitter must mark it default+skip_serializing.
+    const owner = (name: string, extra: Model['fields'] = []): Model => ({
+      name,
+      fields: [
+        { name: 'type', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        ...extra,
+      ],
+    });
+    const models: Model[] = [
+      {
+        name: 'ApiKey',
+        fields: [
+          {
+            name: 'owner',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'ApiKeyOwner' },
+                { kind: 'model', name: 'UserApiKeyOwner' },
+              ],
+              discriminator: {
+                property: 'type',
+                mapping: { organization: 'ApiKeyOwner', user: 'UserApiKeyOwner' },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      owner('ApiKeyOwner'),
+      owner('UserApiKeyOwner', [
+        { name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true },
+      ]),
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    for (const mod of ['api_key_owner', 'user_api_key_owner']) {
+      const f = files.find((x) => x.path === `src/models/${mod}.rs`)!;
+      expect(f.content).toContain('#[serde(rename = "type", default, skip_serializing)]');
+      expect(f.content).toContain('pub type_: String,');
+      // The non-discriminator field is untouched.
+      expect(f.content).toContain('pub id: String,');
+    }
+  });
+
   it('documents Field.default as a "Defaults to" doc comment', () => {
     const models: Model[] = [
       {

package/test/shared/synthetic-enum-seed.test.ts

@@ -0,0 +1,79 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Enum, Model } from '@workos/oagen';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../../src/shared/model-utils.js';
+
+// Regression: an inline oneOf enum whose synthetic name (`Parent_field`)
+// snake-collapses onto an existing IR enum must NOT spawn a duplicate
+// synthetic. `DataIntegrationAccessTokenResponse.error` (-> synthetic
+// `DataIntegrationAccessTokenResponse_error`) and the parser-emitted IR enum
+// `DataIntegrationAccessTokenResponseError` both snake to
+// `data_integration_access_token_response_error`. When both exist, every
+// PascalCase-normalizing emitter (PHP, Ruby, Go, ...) collapses them onto the
+// SAME file path, and which one wins is decided by array order — which differs
+// between a full and a scoped (`--services`) generation, yielding a
+// non-deterministic enum-case order. Seeding `enrichModelsFromSpec` with the
+// IR enum names suppresses the duplicate so the real enum always wins.
+const SPEC = {
+  openapi: '3.0.0',
+  info: { title: 'fixture', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      DataIntegrationAccessTokenResponse: {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              error: {
+                type: 'string',
+                enum: ['not_installed', 'needs_reauthorization'],
+              },
+            },
+          },
+        ],
+      },
+    },
+  },
+};
+
+const SYNTHETIC_NAME = 'DataIntegrationAccessTokenResponse_error';
+const models: Model[] = [{ name: 'DataIntegrationAccessTokenResponse', fields: [] }];
+const collidingEnum: Enum = {
+  name: 'DataIntegrationAccessTokenResponseError',
+  values: [
+    { name: 'NOT_INSTALLED', value: 'not_installed' },
+    { name: 'NEEDS_REAUTHORIZATION', value: 'needs_reauthorization' },
+  ],
+};
+
+let dir: string;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), 'synthetic-enum-seed-'));
+  const specPath = join(dir, 'spec.yaml');
+  // `loadRawSpec` accepts JSON too (js-yaml parses JSON), so write JSON.
+  writeFileSync(specPath, JSON.stringify(SPEC));
+  process.env.OPENAPI_SPEC_PATH = specPath;
+});
+
+afterAll(() => {
+  delete process.env.OPENAPI_SPEC_PATH;
+  if (dir) rmSync(dir, { recursive: true, force: true });
+});
+
+describe('enrichModelsFromSpec — synthetic enum seed', () => {
+  it('emits the inline synthetic enum when no IR enum names are seeded', () => {
+    enrichModelsFromSpec(models);
+    const names = getSyntheticEnums().map((e) => e.name);
+    expect(names).toContain(SYNTHETIC_NAME);
+  });
+
+  it('suppresses the duplicate synthetic when the colliding IR enum is seeded', () => {
+    enrichModelsFromSpec(models, [collidingEnum]);
+    const names = getSyntheticEnums().map((e) => e.name);
+    expect(names).not.toContain(SYNTHETIC_NAME);
+  });
+});