@workos/oagen-emitters 0.12.1 → 0.12.3

package/test/node/tests.test.ts

@@ -0,0 +1,214 @@
+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 });
+    }
+  });
+
+  it('emits tests and fixtures for adopted services when regenerateOwnedTests is true', () => {
+    // Adopted dirs are created by oagen from scratch — no hand-written content
+    // to preserve, so scaffolding tests/fixtures is safe and useful.
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      const result = nodeEmitter.generateTests!(spec, {
+        ...ctx,
+        outputDir: tmpRoot,
+        emitterOptions: { adoptMissingServices: true, 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(fixtureFile).toBeDefined();
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips tests for adopted services when regenerateOwnedTests is false', () => {
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      const result = nodeEmitter.generateTests!(spec, {
+        ...ctx,
+        outputDir: tmpRoot,
+        emitterOptions: { adoptMissingServices: true },
+      } as EmitterContext);
+
+      expect(result.some((f) => f.path.startsWith('src/groups/'))).toBe(false);
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips tests when the resource class diverges from the mount accessor', () => {
+    // Hand-written `Webhooks` has a constructor incompatible with WorkOS,
+    // so the emitter forks endpoint methods onto a `WebhooksEndpoints`
+    // helper class. A generated test would call `workos.webhooks.foo(...)`
+    // — but those methods live on the helper, not the crypto class. Skip
+    // these tests so we don't ship a spec that fails to compile.
+    const webhookOp = {
+      name: 'listWebhookEndpoints',
+      httpMethod: 'get' as const,
+      path: '/webhook_endpoints',
+      pathParams: [],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'primitive' as const, type: 'unknown' as const },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+    const webhookService: Service = { name: 'Webhooks', operations: [webhookOp] };
+    const webhookSpec: ApiSpec = {
+      ...spec,
+      services: [webhookService],
+    };
+
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      const result = nodeEmitter.generateTests!(webhookSpec, {
+        ...ctx,
+        spec: webhookSpec,
+        outputDir: tmpRoot,
+        emitterOptions: { adoptMissingServices: true, regenerateOwnedTests: true },
+        apiSurface: {
+          classes: {
+            Webhooks: {
+              constructorParams: [{ name: 'crypto', type: 'CryptoProvider' }],
+            },
+            WorkOS: {
+              properties: { webhooks: { type: 'Webhooks' } },
+            },
+          },
+        },
+        resolvedOperations: [
+          {
+            operation: webhookOp,
+            service: webhookService,
+            methodName: 'list_webhook_endpoints',
+            mountOn: 'Webhooks',
+            defaults: {},
+            inferFromClient: [],
+            urlBuilder: false,
+          },
+        ],
+      } as unknown as EmitterContext);
+
+      expect(result.some((f) => f.path === 'src/webhooks/webhooks-endpoints.spec.ts')).toBe(false);
+      expect(result.some((f) => f.path === 'src/webhooks/webhooks.spec.ts')).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);
   });
 });