@workos/oagen-emitters 0.12.0 → 0.12.2

package/test/node/tests.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import type { ApiSpec, EmitterContext, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { nodeEmitter } from '../../src/node/index.js';
+
+const groupModel: Model = {
+  name: 'Group',
+  fields: [
+    { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+    { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+  ],
+};
+
+const groupService: Service = {
+  name: 'Groups',
+  operations: [
+    {
+      name: 'getGroup',
+      httpMethod: 'get',
+      path: '/organizations/{organizationId}/groups/{groupId}',
+      pathParams: [
+        { name: 'organizationId', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'groupId', type: { kind: 'primitive', type: 'string' }, required: true },
+      ],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'model', name: 'Group' },
+      errors: [],
+      injectIdempotencyKey: false,
+    },
+  ],
+};
+
+const spec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [groupService],
+  models: [groupModel],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+};
+
+function createTrackedSdkRoot(withHandTests = false): string {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'node-owned-tests-'));
+  fs.mkdirSync(path.join(tmpRoot, 'src', 'groups'), { recursive: true });
+  fs.mkdirSync(path.join(tmpRoot, 'src', 'groups', 'fixtures'), { recursive: true });
+  fs.writeFileSync(path.join(tmpRoot, 'src', 'workos.ts'), '// @oagen-ignore-file\nexport class WorkOS {}\n');
+  if (withHandTests) {
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'groups', 'groups.spec.ts'), "describe('old', () => {});\n");
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'groups', 'fixtures', 'group.json'), '{"id":"old"}\n');
+  }
+  execFileSync('git', ['init'], { cwd: tmpRoot, stdio: 'ignore' });
+  execFileSync('git', ['add', 'src'], { cwd: tmpRoot, stdio: 'ignore' });
+  return tmpRoot;
+}
+
+describe('node test generation ownership', () => {
+  it('regenerates tests and fixtures for owned services', () => {
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      const result = nodeEmitter.generateTests!(spec, {
+        ...ctx,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['Groups'], regenerateOwnedTests: true },
+      } as EmitterContext);
+
+      const testFile = result.find((f) => f.path === 'src/groups/groups.spec.ts');
+      const fixtureFile = result.find((f) => f.path === 'src/groups/fixtures/group.json');
+      expect(testFile).toBeDefined();
+      expect(testFile!.overwriteExisting).toBe(true);
+      expect(fixtureFile).toBeDefined();
+      expect(fixtureFile!.overwriteExisting).toBe(true);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves existing hand-written tests and fixtures for owned services', () => {
+    const tmpRoot = createTrackedSdkRoot(true);
+    try {
+      const result = nodeEmitter.generateTests!(spec, {
+        ...ctx,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['Groups'], regenerateOwnedTests: true },
+      } as EmitterContext);
+
+      expect(result.some((f) => f.path === 'src/groups/groups.spec.ts')).toBe(false);
+      expect(result.some((f) => f.path === 'src/groups/fixtures/group.json')).toBe(false);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips tests and fixtures when the service is not owned', () => {
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      const result = nodeEmitter.generateTests!(spec, {
+        ...ctx,
+        outputDir: tmpRoot,
+        emitterOptions: { regenerateOwnedTests: true },
+      } as EmitterContext);
+
+      expect(result.some((f) => f.path.startsWith('src/groups/'))).toBe(false);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});

package/test/node/type-map.test.ts

@@ -3,49 +3,53 @@ import { mapTypeRef, mapWireTypeRef } from '../../src/node/type-map.js';
 import type { TypeRef } from '@workos/oagen';
 
 describe('mapTypeRef', () => {
-  it('maps primitive string', () => {
+  it('maps string primitive', () => {
     const ref: TypeRef = { kind: 'primitive', type: 'string' };
     expect(mapTypeRef(ref)).toBe('string');
   });
 
-  it('maps primitive integer to number', () => {
+  it('maps integer primitive', () => {
     const ref: TypeRef = { kind: 'primitive', type: 'integer' };
     expect(mapTypeRef(ref)).toBe('number');
   });
 
-  it('maps primitive boolean', () => {
+  it('maps boolean primitive', () => {
     const ref: TypeRef = { kind: 'primitive', type: 'boolean' };
     expect(mapTypeRef(ref)).toBe('boolean');
   });
 
-  it('maps unknown to any', () => {
+  it('maps unknown primitive to any', () => {
     const ref: TypeRef = { kind: 'primitive', type: 'unknown' };
     expect(mapTypeRef(ref)).toBe('any');
   });
 
-  it('maps array of strings', () => {
-    const ref: TypeRef = {
-      kind: 'array',
-      items: { kind: 'primitive', type: 'string' },
-    };
-    expect(mapTypeRef(ref)).toBe('string[]');
+  it('maps date-time to Date', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'string', format: 'date-time' };
+    expect(mapTypeRef(ref)).toBe('Date');
   });
 
-  it('maps model reference', () => {
+  it('maps model ref to model name', () => {
     const ref: TypeRef = { kind: 'model', name: 'Organization' };
     expect(mapTypeRef(ref)).toBe('Organization');
   });
 
-  it('maps enum reference', () => {
-    const ref: TypeRef = { kind: 'enum', name: 'Status' };
+  it('maps enum ref to enum name', () => {
+    const ref: TypeRef = { kind: 'enum', name: 'Status', values: ['active', 'inactive'] };
     expect(mapTypeRef(ref)).toBe('Status');
   });
 
+  it('maps array of primitives', () => {
+    const ref: TypeRef = { kind: 'array', items: { kind: 'primitive', type: 'string' } };
+    expect(mapTypeRef(ref)).toBe('string[]');
+  });
+
+  it('maps array of models', () => {
+    const ref: TypeRef = { kind: 'array', items: { kind: 'model', name: 'Org' } };
+    expect(mapTypeRef(ref)).toBe('Org[]');
+  });
+
   it('maps nullable type', () => {
-    const ref: TypeRef = {
-      kind: 'nullable',
-      inner: { kind: 'primitive', type: 'string' },
-    };
+    const ref: TypeRef = { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } };
     expect(mapTypeRef(ref)).toBe('string | null');
   });
 
@@ -64,32 +68,14 @@ describe('mapTypeRef', () => {
     const ref: TypeRef = {
       kind: 'union',
       variants: [
-        { kind: 'model', name: 'AuthenticationFactorTotp' },
-        { kind: 'model', name: 'AuthenticationFactorTotp' },
+        { kind: 'primitive', type: 'string' },
+        { kind: 'primitive', type: 'string' },
       ],
     };
-    expect(mapTypeRef(ref)).toBe('AuthenticationFactorTotp');
-  });
-
-  it('maps map type', () => {
-    const ref: TypeRef = {
-      kind: 'map',
-      valueType: { kind: 'primitive', type: 'string' },
-    };
-    expect(mapTypeRef(ref)).toBe('Record<string, string>');
-  });
-
-  it('maps literal string', () => {
-    const ref: TypeRef = { kind: 'literal', value: 'organization' };
-    expect(mapTypeRef(ref)).toBe("'organization'");
-  });
-
-  it('maps literal number', () => {
-    const ref: TypeRef = { kind: 'literal', value: 42 };
-    expect(mapTypeRef(ref)).toBe('42');
+    expect(mapTypeRef(ref)).toBe('string');
   });
 
-  it('parenthesizes union in array', () => {
+  it('parenthesizes unions in arrays', () => {
     const ref: TypeRef = {
       kind: 'array',
       items: {
@@ -102,37 +88,46 @@ describe('mapTypeRef', () => {
     };
     expect(mapTypeRef(ref)).toBe('(string | number)[]');
   });
+
+  it('maps map type', () => {
+    const ref: TypeRef = { kind: 'map', valueType: { kind: 'primitive', type: 'string' } };
+    expect(mapTypeRef(ref)).toBe('Record<string, string>');
+  });
+
+  it('maps string literal', () => {
+    const ref: TypeRef = { kind: 'literal', value: 'active' };
+    expect(mapTypeRef(ref)).toBe("'active'");
+  });
+
+  it('maps number literal', () => {
+    const ref: TypeRef = { kind: 'literal', value: 42 };
+    expect(mapTypeRef(ref)).toBe('42');
+  });
 });
 
 describe('mapWireTypeRef', () => {
-  it('maps model reference with Response suffix', () => {
+  it('maps model ref with Response suffix', () => {
     const ref: TypeRef = { kind: 'model', name: 'Organization' };
     expect(mapWireTypeRef(ref)).toBe('OrganizationResponse');
   });
 
   it('maps array of models with Response suffix', () => {
-    const ref: TypeRef = {
-      kind: 'array',
-      items: { kind: 'model', name: 'OrganizationDomain' },
-    };
-    expect(mapWireTypeRef(ref)).toBe('OrganizationDomainResponse[]');
+    const ref: TypeRef = { kind: 'array', items: { kind: 'model', name: 'Org' } };
+    expect(mapWireTypeRef(ref)).toBe('OrgResponse[]');
   });
 
-  it('keeps primitives unchanged', () => {
-    const ref: TypeRef = { kind: 'primitive', type: 'string' };
+  it('maps date-time as string in wire type', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'string', format: 'date-time' };
     expect(mapWireTypeRef(ref)).toBe('string');
   });
 
-  it('keeps enum references unchanged', () => {
-    const ref: TypeRef = { kind: 'enum', name: 'Status' };
+  it('maps enum ref unchanged', () => {
+    const ref: TypeRef = { kind: 'enum', name: 'Status', values: ['active'] };
     expect(mapWireTypeRef(ref)).toBe('Status');
   });
 
   it('maps nullable model with Response suffix', () => {
-    const ref: TypeRef = {
-      kind: 'nullable',
-      inner: { kind: 'model', name: 'Organization' },
-    };
-    expect(mapWireTypeRef(ref)).toBe('OrganizationResponse | null');
+    const ref: TypeRef = { kind: 'nullable', inner: { kind: 'model', name: 'Org' } };
+    expect(mapWireTypeRef(ref)).toBe('OrgResponse | null');
   });
 });

package/test/node/utils.test.ts

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

package/test/rust/fixtures.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect } from 'vitest';
+import type { ApiSpec, Enum, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { exampleFromSpec, generateFixtures, generateModelFixture } from '../../src/rust/fixtures.js';
+
+function spec(models: Model[], enums: Enum[] = []): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: '',
+    services: [],
+    models,
+    enums,
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+describe('rust/fixtures', () => {
+  it('prefers a spec `example` over the generated placeholder for a primitive field', () => {
+    const models: Model[] = [
+      {
+        name: 'Event',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            example: 'event_01XXXX',
+          },
+          {
+            name: 'created_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+            example: '2026-02-02T16:35:39.317Z',
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models));
+    const file = files.find((f) => f.path === 'tests/fixtures/event.json')!;
+    expect(file).toBeDefined();
+    const parsed = JSON.parse(file.content);
+    expect(parsed.id).toBe('event_01XXXX');
+    expect(parsed.created_at).toBe('2026-02-02T16:35:39.317Z');
+  });
+
+  it('falls back to the placeholder when the example shape does not match the type', () => {
+    const models: Model[] = [
+      {
+        name: 'Wrong',
+        fields: [
+          // Type is integer but example is a string — must fall back.
+          {
+            name: 'count',
+            type: { kind: 'primitive', type: 'integer' },
+            required: true,
+            example: 'not-a-number',
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models));
+    const file = files.find((f) => f.path === 'tests/fixtures/wrong.json')!;
+    const parsed = JSON.parse(file.content);
+    expect(parsed.count).toBe(0); // placeholder fallback
+  });
+
+  it('uses an example array of strings for an array<string> field', () => {
+    const models: Model[] = [
+      {
+        name: 'Org',
+        fields: [
+          {
+            name: 'domains',
+            type: {
+              kind: 'array',
+              items: { kind: 'primitive', type: 'string' },
+            },
+            required: true,
+            example: ['example.com', 'foo.com'],
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models));
+    const file = files.find((f) => f.path === 'tests/fixtures/org.json')!;
+    const parsed = JSON.parse(file.content);
+    expect(parsed.domains).toEqual(['example.com', 'foo.com']);
+  });
+
+  it('skips a model-shaped example to avoid mis-shaped nested structs', () => {
+    const models: Model[] = [
+      {
+        name: 'Outer',
+        fields: [
+          {
+            name: 'actor',
+            type: { kind: 'model', name: 'Actor' },
+            required: true,
+            // Provided as a free-form example; we should NOT use it verbatim.
+            example: { not_a_real_field: 'whoops' },
+          },
+        ],
+      },
+      {
+        name: 'Actor',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            example: 'user_TF4C5938',
+          },
+          {
+            name: 'type',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            example: 'user',
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models));
+    const file = files.find((f) => f.path === 'tests/fixtures/outer.json')!;
+    const parsed = JSON.parse(file.content);
+    // The nested model is regenerated from its own fields' examples, not from
+    // the parent's free-form example blob.
+    expect(parsed.actor).toEqual({ id: 'user_TF4C5938', type: 'user' });
+  });
+
+  it('uses an enum example only when it matches a known enum value', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'Active', value: 'active' },
+          { name: 'Pending', value: 'pending' },
+        ],
+      },
+    ];
+    const models: Model[] = [
+      {
+        name: 'GoodEx',
+        fields: [
+          {
+            name: 'status',
+            type: { kind: 'enum', name: 'Status' },
+            required: true,
+            example: 'pending',
+          },
+        ],
+      },
+      {
+        name: 'BadEx',
+        fields: [
+          {
+            name: 'status',
+            type: { kind: 'enum', name: 'Status' },
+            required: true,
+            example: 'something_unknown',
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models, enums));
+    const good = JSON.parse(files.find((f) => f.path === 'tests/fixtures/good_ex.json')!.content);
+    const bad = JSON.parse(files.find((f) => f.path === 'tests/fixtures/bad_ex.json')!.content);
+    expect(good.status).toBe('pending'); // valid example wins
+    expect(bad.status).toBe('active'); // unknown example → first enum value
+  });
+
+  it('treats null examples as unusable so required fields keep a value', () => {
+    const models: Model[] = [
+      {
+        name: 'Nullish',
+        fields: [
+          {
+            name: 'name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            example: null,
+          },
+        ],
+      },
+    ];
+    const files = generateFixtures(spec(models));
+    const parsed = JSON.parse(files.find((f) => f.path === 'tests/fixtures/nullish.json')!.content);
+    expect(parsed.name).toBe('test_name');
+  });
+
+  it('exampleFromSpec exposes the shape-checking helper for reuse', () => {
+    const enums = new Map<string, Enum>();
+    // Primitives are unwrapped through nullable.
+    expect(exampleFromSpec('hello', { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } }, enums)).toBe(
+      'hello',
+    );
+    // Integer floats are rejected (they would corrupt typed deserialisation).
+    expect(exampleFromSpec(1.5, { kind: 'primitive', type: 'integer' }, enums)).toBeUndefined();
+    // Empty arrays fall back so the placeholder can emit a one-element array.
+    expect(exampleFromSpec([], { kind: 'array', items: { kind: 'primitive', type: 'string' } }, enums)).toBeUndefined();
+  });
+
+  it('threads required-only field selection through generateModelFixture', () => {
+    const models: Model[] = [
+      {
+        name: 'Mixed',
+        fields: [
+          {
+            name: 'kept',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            example: 'real',
+          },
+          {
+            name: 'dropped',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+            example: 'ignored',
+          },
+        ],
+      },
+    ];
+    const modelMap = new Map(models.map((m) => [m.name, m]));
+    const fixture = generateModelFixture(models[0]!, modelMap, new Map(), new Set());
+    expect(fixture).toEqual({ kept: 'real' });
+  });
+});