@workos/oagen-emitters 0.0.1

package/test/node/models.test.ts

@@ -0,0 +1,301 @@
+import { describe, it, expect } from 'vitest';
+import { generateModels } from '../../src/node/models.js';
+import type { EmitterContext, ApiSpec, Model, Service } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+  irVersion: 6,
+};
+
+describe('generateModels', () => {
+  it('returns empty for no models', () => {
+    expect(generateModels([], ctx)).toEqual([]);
+  });
+
+  it('generates domain and response interfaces for a model', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'created_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+          },
+          {
+            name: 'external_id',
+            type: {
+              kind: 'nullable',
+              inner: { kind: 'primitive', type: 'string' },
+            },
+            required: false,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('src/organizations/interfaces/organization.interface.ts');
+
+    // Domain interface has camelCase fields
+    expect(files[0].content).toContain('export interface Organization {');
+    expect(files[0].content).toContain('  id: string;');
+    expect(files[0].content).toContain('  name: string;');
+    expect(files[0].content).toContain('  createdAt: string;');
+    expect(files[0].content).toContain('  externalId?: string | null;');
+
+    // Response interface has snake_case fields
+    expect(files[0].content).toContain('export interface OrganizationResponse {');
+    expect(files[0].content).toContain('  created_at: string;');
+    expect(files[0].content).toContain('  external_id?: string | null;');
+  });
+
+  it('generates imports for referenced models', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'domains',
+            type: {
+              kind: 'array',
+              items: { kind: 'model', name: 'OrganizationDomain' },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'OrganizationDomain',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'domain',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+
+    // Organization file should import OrganizationDomain
+    const orgFile = files.find((f) => f.path.includes('organization.interface.ts'))!;
+    expect(orgFile.content).toContain(
+      "import type { OrganizationDomain, OrganizationDomainResponse } from './organization-domain.interface';",
+    );
+
+    // Domain interface uses OrganizationDomain[]
+    expect(orgFile.content).toContain('  domains: OrganizationDomain[];');
+
+    // Response interface uses OrganizationDomainResponse[]
+    expect(orgFile.content).toContain('  domains: OrganizationDomainResponse[];');
+  });
+
+  it('handles generic type params', () => {
+    const models: Model[] = [
+      {
+        name: 'DirectoryUser',
+        typeParams: [
+          {
+            name: 'TCustom',
+            default: {
+              kind: 'map',
+              valueType: { kind: 'primitive', type: 'unknown' },
+            },
+          },
+        ],
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const files = generateModels(models, ctx);
+    expect(files[0].content).toContain('export interface DirectoryUser<TCustom = Record<string, any>> {');
+    expect(files[0].content).toContain('export interface DirectoryUserResponse<TCustom = Record<string, any>> {');
+  });
+
+  it('uses Wire suffix for models already ending in Response', () => {
+    const service: Service = {
+      name: 'PortalSessions',
+      operations: [
+        {
+          name: 'createPortalSession',
+          httpMethod: 'post',
+          path: '/portal/sessions',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'PortalSessionsCreateResponse' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'PortalSessionsCreateResponse',
+        fields: [
+          {
+            name: 'link',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+    const content = files[0].content;
+
+    // Should use Wire suffix, not ResponseResponse
+    expect(content).toContain('export interface PortalSessionsCreateResponseWire {');
+    expect(content).not.toContain('PortalSessionsCreateResponseResponse');
+  });
+
+  it('renders @deprecated on fields', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'legacy_slug',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+            description: 'Use external_id instead.',
+            deprecated: true,
+          },
+          {
+            name: 'old_field',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+            deprecated: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
+    const content = files[0].content;
+
+    // Field with description + deprecated gets multiline JSDoc
+    expect(content).toContain('  /**\n   * Use external_id instead.\n   * @deprecated\n   */');
+
+    // Field with only deprecated gets single-line JSDoc
+    expect(content).toContain('  /** @deprecated */');
+  });
+});

package/test/node/naming.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest';
+import {
+  className,
+  fileName,
+  methodName,
+  fieldName,
+  wireFieldName,
+  wireInterfaceName,
+  serviceDirName,
+  servicePropertyName,
+  resolveServiceName,
+  buildServiceNameMap,
+} from '../../src/node/naming.js';
+import type { EmitterContext, ApiSpec, Service } from '@workos/oagen';
+
+describe('naming', () => {
+  describe('className', () => {
+    it('converts to PascalCase', () => {
+      expect(className('organizations')).toBe('Organizations');
+      expect(className('user_management')).toBe('UserManagement');
+      expect(className('api_keys')).toBe('ApiKeys');
+    });
+  });
+
+  describe('fileName', () => {
+    it('converts to kebab-case', () => {
+      expect(fileName('Organization')).toBe('organization');
+      expect(fileName('OrganizationDomain')).toBe('organization-domain');
+      expect(fileName('UserManagement')).toBe('user-management');
+    });
+  });
+
+  describe('methodName', () => {
+    it('converts to camelCase', () => {
+      expect(methodName('list_organizations')).toBe('listOrganizations');
+      expect(methodName('create_organization')).toBe('createOrganization');
+      expect(methodName('get_organization')).toBe('getOrganization');
+    });
+  });
+
+  describe('fieldName', () => {
+    it('converts to camelCase', () => {
+      expect(fieldName('allow_profiles_outside_organization')).toBe('allowProfilesOutsideOrganization');
+      expect(fieldName('stripe_customer_id')).toBe('stripeCustomerId');
+      expect(fieldName('id')).toBe('id');
+    });
+  });
+
+  describe('wireFieldName', () => {
+    it('converts to snake_case', () => {
+      expect(wireFieldName('allowProfilesOutsideOrganization')).toBe('allow_profiles_outside_organization');
+      expect(wireFieldName('id')).toBe('id');
+      expect(wireFieldName('created_at')).toBe('created_at');
+    });
+  });
+
+  describe('wireInterfaceName', () => {
+    it('appends Response for normal names', () => {
+      expect(wireInterfaceName('Organization')).toBe('OrganizationResponse');
+    });
+
+    it('appends Wire when name already ends in Response', () => {
+      expect(wireInterfaceName('PortalSessionsCreateResponse')).toBe('PortalSessionsCreateResponseWire');
+    });
+  });
+
+  describe('serviceDirName', () => {
+    it('converts to kebab-case', () => {
+      expect(serviceDirName('Organizations')).toBe('organizations');
+      expect(serviceDirName('UserManagement')).toBe('user-management');
+      expect(serviceDirName('ApiKeys')).toBe('api-keys');
+    });
+  });
+
+  describe('servicePropertyName', () => {
+    it('converts to camelCase', () => {
+      expect(servicePropertyName('Organizations')).toBe('organizations');
+      expect(servicePropertyName('UserManagement')).toBe('userManagement');
+      expect(servicePropertyName('ApiKeys')).toBe('apiKeys');
+    });
+  });
+
+  describe('resolveServiceName', () => {
+    const emptySpec: ApiSpec = {
+      name: 'Test',
+      version: '1.0.0',
+      baseUrl: '',
+      services: [],
+      models: [],
+      enums: [],
+    };
+
+    it('returns overlay class name when available', () => {
+      const service: Service = {
+        name: 'MultiFactorAuth',
+        operations: [
+          {
+            name: 'enrollFactor',
+            httpMethod: 'post',
+            path: '/auth/factors/enroll',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'string' },
+            errors: [],
+            injectIdempotencyKey: true,
+          },
+        ],
+      };
+
+      const ctx: EmitterContext = {
+        namespace: 'workos',
+        namespacePascal: 'WorkOS',
+        spec: emptySpec,
+        irVersion: 6,
+        overlayLookup: {
+          methodByOperation: new Map([
+            [
+              'POST /auth/factors/enroll',
+              { className: 'Mfa', methodName: 'enrollFactor', params: [], returnType: 'void' },
+            ],
+          ]),
+          httpKeyByMethod: new Map(),
+          interfaceByName: new Map(),
+          typeAliasByName: new Map(),
+          requiredExports: new Map(),
+          modelNameByIR: new Map(),
+          fileBySymbol: new Map(),
+        },
+      };
+
+      expect(resolveServiceName(service, ctx)).toBe('Mfa');
+    });
+
+    it('falls back to PascalCase of service.name', () => {
+      const service: Service = {
+        name: 'MultiFactorAuth',
+        operations: [],
+      };
+
+      const ctx: EmitterContext = {
+        namespace: 'workos',
+        namespacePascal: 'WorkOS',
+        spec: emptySpec,
+        irVersion: 6,
+      };
+
+      expect(resolveServiceName(service, ctx)).toBe('MultiFactorAuth');
+    });
+  });
+
+  describe('buildServiceNameMap', () => {
+    const emptySpec: ApiSpec = {
+      name: 'Test',
+      version: '1.0.0',
+      baseUrl: '',
+      services: [],
+      models: [],
+      enums: [],
+    };
+
+    it('maps IR names to resolved names', () => {
+      const services: Service[] = [
+        {
+          name: 'MultiFactorAuth',
+          operations: [
+            {
+              name: 'enrollFactor',
+              httpMethod: 'post',
+              path: '/auth/factors/enroll',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'primitive', type: 'string' },
+              errors: [],
+              injectIdempotencyKey: true,
+            },
+          ],
+        },
+        {
+          name: 'Organizations',
+          operations: [],
+        },
+      ];
+
+      const ctx: EmitterContext = {
+        namespace: 'workos',
+        namespacePascal: 'WorkOS',
+        spec: emptySpec,
+        irVersion: 6,
+        overlayLookup: {
+          methodByOperation: new Map([
+            [
+              'POST /auth/factors/enroll',
+              { className: 'Mfa', methodName: 'enrollFactor', params: [], returnType: 'void' },
+            ],
+          ]),
+          httpKeyByMethod: new Map(),
+          interfaceByName: new Map(),
+          typeAliasByName: new Map(),
+          requiredExports: new Map(),
+          modelNameByIR: new Map(),
+          fileBySymbol: new Map(),
+        },
+      };
+
+      const map = buildServiceNameMap(services, ctx);
+      expect(map.get('MultiFactorAuth')).toBe('Mfa');
+      expect(map.get('Organizations')).toBe('Organizations');
+    });
+  });
+});