@workos/oagen-emitters 0.0.1

package/test/fixtures/sample-sdk-node/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "sample-sdk-node",
+  "version": "1.0.0",
+  "exports": {
+    ".": "./src/index.ts"
+  }
+}

package/test/fixtures/sample-sdk-node/src/client.ts

@@ -0,0 +1,24 @@
+/* eslint-disable no-unused-vars */
+import type { WorkOSOptions, Organization, ListResponse } from './models.js';
+
+export class WorkOSClient {
+  readonly baseURL: string;
+  private readonly apiKey: string;
+
+  constructor(options: WorkOSOptions) {
+    this.apiKey = options.apiKey;
+    this.baseURL = options.baseUrl ?? 'https://api.workos.com';
+  }
+
+  async getOrganization(id: string): Promise<Organization> {
+    throw new Error('Not implemented');
+  }
+
+  async listOrganizations(limit?: number): Promise<ListResponse<Organization>> {
+    throw new Error('Not implemented');
+  }
+
+  async deleteOrganization(id: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+}

package/test/fixtures/sample-sdk-node/src/index.ts

@@ -0,0 +1,4 @@
+export { WorkOSClient } from './client.js';
+export type { WorkOSOptions, Organization, OrganizationResponse, ListResponse } from './models.js';
+export { Status } from './models.js';
+export type { StatusType } from './models.js';

package/test/fixtures/sample-sdk-node/src/models.ts

@@ -0,0 +1,28 @@
+export interface WorkOSOptions {
+  apiKey: string;
+  baseUrl?: string;
+}
+
+export interface Organization {
+  id: string;
+  name: string;
+  createdAt: string;
+}
+
+export interface OrganizationResponse {
+  id: string;
+  name: string;
+  created_at: string;
+}
+
+export interface ListResponse<T> {
+  data: T[];
+  hasMore: boolean;
+}
+
+export type StatusType = 'active' | 'inactive';
+
+export enum Status {
+  Active = 'active',
+  Inactive = 'inactive',
+}

package/test/fixtures/sample-sdk-node/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}

package/test/node/client.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect } from 'vitest';
+import { generateClient } from '../../src/node/client.js';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+
+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 model: Model = {
+  name: 'Organization',
+  fields: [
+    { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+    { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+  ],
+};
+
+const spec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: 'https://api.example.com',
+  services: [service],
+  models: [model],
+  enums: [],
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+  irVersion: 6,
+};
+
+describe('generateClient', () => {
+  it('generates WorkOS client with resource accessors', () => {
+    const files = generateClient(spec, ctx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts');
+    expect(workosFile).toBeDefined();
+
+    const content = workosFile!.content;
+    expect(content).toContain('export class WorkOS {');
+    expect(content).toContain('readonly organizations = new Organizations(this);');
+    expect(content).toContain('async get<Result');
+    expect(content).toContain('async post<Result');
+    expect(content).toContain('async delete(');
+  });
+
+  it('generates barrel exports', () => {
+    const files = generateClient(spec, ctx);
+    const barrel = files.find((f) => f.path === 'src/index.ts');
+    expect(barrel).toBeDefined();
+
+    const content = barrel!.content;
+    expect(content).toContain("export * from './common/exceptions';");
+    expect(content).toContain("export { AutoPaginatable } from './common/utils/pagination';");
+    expect(content).toContain("export { WorkOS } from './workos';");
+    expect(content).toContain('export type { Organization, OrganizationResponse }');
+    expect(content).toContain("export { Organizations } from './organizations/organizations';");
+  });
+
+  it('generates package.json and tsconfig.json', () => {
+    const files = generateClient(spec, ctx);
+    const pkg = files.find((f) => f.path === 'package.json');
+    const tsconfig = files.find((f) => f.path === 'tsconfig.json');
+
+    expect(pkg).toBeDefined();
+    expect(pkg!.skipIfExists).toBe(true);
+
+    expect(tsconfig).toBeDefined();
+    expect(tsconfig!.skipIfExists).toBe(true);
+  });
+
+  it('uses overlay-resolved names for imports and accessors', () => {
+    const mfaService: Service = {
+      name: 'MultiFactorAuth',
+      operations: [
+        {
+          name: 'enrollFactor',
+          httpMethod: 'post',
+          path: '/auth/factors/enroll',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'AuthenticationFactor' },
+          errors: [],
+          injectIdempotencyKey: true,
+        },
+      ],
+    };
+
+    const mfaModel: Model = {
+      name: 'AuthenticationFactor',
+      fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+
+    const overlaySpec: ApiSpec = {
+      name: 'Test',
+      version: '1.0.0',
+      baseUrl: 'https://api.example.com',
+      services: [mfaService],
+      models: [mfaModel],
+      enums: [],
+    };
+
+    const overlayCtx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: overlaySpec,
+      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 files = generateClient(overlaySpec, overlayCtx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts');
+    expect(workosFile).toBeDefined();
+
+    const content = workosFile!.content;
+    // Import path uses resolved name
+    expect(content).toContain("from './mfa/mfa'");
+    // Property uses resolved name
+    expect(content).toContain('readonly mfa = new Mfa(this);');
+
+    const barrel = files.find((f) => f.path === 'src/index.ts');
+    expect(barrel).toBeDefined();
+    // Barrel export uses resolved name
+    expect(barrel!.content).toContain("from './mfa/mfa'");
+  });
+
+  it('generates error handling in WorkOS client', () => {
+    const files = generateClient(spec, ctx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts')!;
+    const content = workosFile.content;
+
+    expect(content).toContain('case 401: throw new UnauthorizedException');
+    expect(content).toContain('case 404: throw new NotFoundException');
+    expect(content).toContain('case 422: throw new UnprocessableEntityException');
+    expect(content).toContain('case 429:');
+    expect(content).toContain('throw new RateLimitExceededException');
+  });
+});

package/test/node/enums.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from 'vitest';
+import { generateEnums } from '../../src/node/enums.js';
+import type { EmitterContext, ApiSpec, Enum, 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('generateEnums', () => {
+  it('returns empty for no enums', () => {
+    expect(generateEnums([], ctx)).toEqual([]);
+  });
+
+  it('generates string literal union type', () => {
+    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 enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+          { name: 'PENDING', value: 'pending' },
+        ],
+      },
+    ];
+
+    // Enum not referenced by any service → placed in common/
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service] },
+    });
+    expect(files.length).toBe(1);
+    expect(files[0].content).toMatchInlineSnapshot(`
+      "export type Status =
+        | 'active'
+        | 'inactive'
+        | 'pending';"
+    `);
+  });
+
+  it('places enum in service directory when referenced', () => {
+    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: 'enum', name: 'OrgStatus' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const enums: Enum[] = [
+      {
+        name: 'OrgStatus',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service] },
+    });
+    expect(files[0].path).toBe('src/organizations/interfaces/org-status.interface.ts');
+  });
+
+  it('renders @deprecated on enum values', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'LEGACY', value: 'legacy', description: 'No longer supported.', deprecated: true },
+          { name: 'OLD', value: 'old', deprecated: true },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    const content = files[0].content;
+
+    // Value with description + deprecated gets multiline JSDoc
+    expect(content).toContain('  /**\n   * No longer supported.\n   * @deprecated\n   */');
+
+    // Value with only deprecated gets single-line JSDoc
+    expect(content).toContain('  /** @deprecated */');
+  });
+});

package/test/node/errors.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { generateErrors } from '../../src/node/errors.js';
+import type { EmitterContext, ApiSpec } 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('generateErrors', () => {
+  it('generates all exception classes', () => {
+    const files = generateErrors(ctx);
+
+    const names = files.map((f) => f.path);
+    expect(names).toContain('src/common/exceptions/bad-request.exception.ts');
+    expect(names).toContain('src/common/exceptions/unauthorized.exception.ts');
+    expect(names).toContain('src/common/exceptions/not-found.exception.ts');
+    expect(names).toContain('src/common/exceptions/conflict.exception.ts');
+    expect(names).toContain('src/common/exceptions/unprocessable-entity.exception.ts');
+    expect(names).toContain('src/common/exceptions/rate-limit-exceeded.exception.ts');
+    expect(names).toContain('src/common/exceptions/generic-server.exception.ts');
+    expect(names).toContain('src/common/exceptions/no-api-key-provided.exception.ts');
+    expect(names).toContain('src/common/exceptions/index.ts');
+  });
+
+  it('generates NotFoundException with correct status', () => {
+    const files = generateErrors(ctx);
+    const notFoundFile = files.find((f) => f.path.includes('not-found.exception.ts'))!;
+
+    expect(notFoundFile.content).toContain('export class NotFoundException extends Error');
+    expect(notFoundFile.content).toContain('readonly status = 404;');
+    expect(notFoundFile.content).toContain('requestID: string');
+  });
+
+  it('generates RateLimitExceededException with retryAfter', () => {
+    const files = generateErrors(ctx);
+    const rateLimitFile = files.find((f) => f.path.includes('rate-limit-exceeded.exception.ts'))!;
+
+    expect(rateLimitFile.content).toContain('export class RateLimitExceededException extends Error');
+    expect(rateLimitFile.content).toContain('readonly status = 429;');
+    expect(rateLimitFile.content).toContain('retryAfter?: number');
+  });
+
+  it('generates exception barrel with all exports', () => {
+    const files = generateErrors(ctx);
+    const barrel = files.find((f) => f.path === 'src/common/exceptions/index.ts')!;
+
+    expect(barrel.content).toContain('export { BadRequestException }');
+    expect(barrel.content).toContain('export { UnauthorizedException }');
+    expect(barrel.content).toContain('export { NotFoundException }');
+    expect(barrel.content).toContain('export { RateLimitExceededException }');
+    expect(barrel.content).toContain('export { NoApiKeyProvidedException }');
+  });
+});