@workos/oagen-emitters 0.0.1

package/src/node/config.ts

@@ -0,0 +1,70 @@
+import type { GeneratedFile } from '@workos/oagen';
+
+export function generateConfig(): GeneratedFile[] {
+  return [
+    {
+      path: 'src/common/interfaces/workos-options.interface.ts',
+      content: `export interface WorkOSOptions {
+  apiKey?: string;
+  apiHostname?: string;
+  https?: boolean;
+  port?: number;
+  config?: RequestInit;
+  fetchFn?: typeof fetch;
+  clientId?: string;
+  timeout?: number;
+}
+
+export interface AppInfo {
+  name: string;
+  version?: string;
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/interfaces/post-options.interface.ts',
+      content: `export interface PostOptions {
+  query?: Record<string, any>;
+  idempotencyKey?: string;
+  warrantToken?: string;
+  skipApiKeyCheck?: boolean;
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/interfaces/get-options.interface.ts',
+      content: `export interface GetOptions {
+  query?: Record<string, any>;
+  accessToken?: string;
+  warrantToken?: string;
+  skipApiKeyCheck?: boolean;
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/interfaces/pagination-options.interface.ts',
+      content: `export interface PaginationOptions {
+  limit?: number;
+  before?: string | null;
+  after?: string | null;
+  order?: 'asc' | 'desc';
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/interfaces/request-exception.interface.ts',
+      content: `export interface RequestException {
+  readonly status: number;
+  readonly name: string;
+  readonly requestID: string;
+  readonly code?: string;
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+  ];
+}

package/src/node/enums.ts

@@ -0,0 +1,87 @@
+import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { walkTypeRef } from '@workos/oagen';
+import { fileName, serviceDirName, buildServiceNameMap } from './naming.js';
+import { docComment } from './utils.js';
+
+export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
+  if (enums.length === 0) return [];
+
+  const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+  const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
+  const resolveDir = (irService: string | undefined) =>
+    irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : 'common';
+  const files: GeneratedFile[] = [];
+
+  for (const enumDef of enums) {
+    const service = enumToService.get(enumDef.name);
+    const dirName = resolveDir(service);
+
+    // Check baseline surface for representation and values
+    const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
+    const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
+    const lines: string[] = [];
+
+    if (baselineEnum?.members) {
+      // Generate TS `enum` using baseline member names and values directly
+      lines.push(`export enum ${enumDef.name} {`);
+      for (const [memberName, memberValue] of Object.entries(baselineEnum.members)) {
+        const valueStr = typeof memberValue === 'string' ? `'${memberValue}'` : String(memberValue);
+        lines.push(`  ${memberName} = ${valueStr},`);
+      }
+      lines.push('}');
+    } else if (baselineAlias?.value) {
+      // Use the exact baseline type alias value for guaranteed compat match
+      lines.push(`export type ${enumDef.name} = ${baselineAlias.value};`);
+    } else {
+      // No baseline — generate string literal union from IR values
+      const values = enumDef.values;
+      lines.push(`export type ${enumDef.name} =`);
+      for (let i = 0; i < values.length; i++) {
+        const v = values[i];
+        const valueStr = typeof v.value === 'string' ? `'${v.value}'` : String(v.value);
+        if (v.description || v.deprecated) {
+          const parts: string[] = [];
+          if (v.description) parts.push(v.description);
+          if (v.deprecated) parts.push('@deprecated');
+          lines.push(...docComment(parts.join('\n'), 2));
+        }
+        const suffix = i === values.length - 1 ? ';' : '';
+        lines.push(`  | ${valueStr}${suffix}`);
+      }
+    }
+
+    files.push({
+      path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
+      content: lines.join('\n'),
+      skipIfExists: true,
+    });
+  }
+
+  return files;
+}
+
+function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
+  const enumToService = new Map<string, string>();
+  const enumNames = new Set(enums.map((e) => e.name));
+
+  for (const service of services) {
+    for (const op of service.operations) {
+      const refs = new Set<string>();
+      const collect = (ref: any) => {
+        walkTypeRef(ref, { enum: (r: any) => refs.add(r.name) });
+      };
+      if (op.requestBody) collect(op.requestBody);
+      collect(op.response);
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
+        collect(p.type);
+      }
+      for (const name of refs) {
+        if (enumNames.has(name) && !enumToService.has(name)) {
+          enumToService.set(name, service.name);
+        }
+      }
+    }
+  }
+
+  return enumToService;
+}

package/src/node/errors.ts

@@ -0,0 +1,205 @@
+import type { GeneratedFile } from '@workos/oagen';
+
+export function generateErrors(): GeneratedFile[] {
+  return [
+    {
+      path: 'src/common/exceptions/bad-request.exception.ts',
+      content: `export class BadRequestException extends Error {
+  readonly status = 400;
+  readonly name = 'BadRequestException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    message,
+    requestID,
+  }: {
+    code?: string;
+    message?: string;
+    requestID: string;
+  }) {
+    super();
+    this.message = message ?? 'Bad request';
+    this.requestID = requestID;
+    if (code) this.code = code;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/unauthorized.exception.ts',
+      content: `export class UnauthorizedException extends Error {
+  readonly status = 401;
+  readonly name = 'UnauthorizedException';
+  readonly requestID: string;
+
+  constructor(requestID: string) {
+    super();
+    this.message = 'Unauthorized';
+    this.requestID = requestID;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/not-found.exception.ts',
+      content: `export class NotFoundException extends Error {
+  readonly status = 404;
+  readonly name = 'NotFoundException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    message,
+    path,
+    requestID,
+  }: {
+    code?: string;
+    message?: string;
+    path: string;
+    requestID: string;
+  }) {
+    super();
+    this.message =
+      message ?? \`The requested path '\${path}' could not be found.\`;
+    this.requestID = requestID;
+    if (code) this.code = code;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/conflict.exception.ts',
+      content: `export class ConflictException extends Error {
+  readonly status = 409;
+  readonly name = 'ConflictException';
+  readonly requestID: string;
+
+  constructor({
+    message,
+    requestID,
+  }: {
+    message?: string;
+    error?: string;
+    requestID: string;
+  }) {
+    super();
+    this.message = message ?? 'Conflict';
+    this.requestID = requestID;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/unprocessable-entity.exception.ts',
+      content: `export interface UnprocessableEntityError {
+  code: string;
+}
+
+export class UnprocessableEntityException extends Error {
+  readonly status = 422;
+  readonly name = 'UnprocessableEntityException';
+  readonly requestID: string;
+  readonly code?: string;
+
+  constructor({
+    code,
+    errors,
+    message,
+    requestID,
+  }: {
+    code?: string;
+    errors?: UnprocessableEntityError[];
+    message?: string;
+    requestID: string;
+  }) {
+    super();
+    this.requestID = requestID;
+    this.message = message ?? 'Unprocessable entity';
+    if (code) this.code = code;
+    if (errors) {
+      const requirement =
+        errors.length === 1 ? 'requirement' : 'requirements';
+      this.message = \`The following \${requirement} must be met:\\n\`;
+      for (const { code: errCode } of errors) {
+        this.message = this.message.concat(\`\\t\${errCode}\\n\`);
+      }
+    }
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/rate-limit-exceeded.exception.ts',
+      content: `export class RateLimitExceededException extends Error {
+  readonly status = 429;
+  readonly name = 'RateLimitExceededException';
+  readonly requestID: string;
+  readonly retryAfter?: number;
+
+  constructor(message: string, requestID: string, retryAfter?: number) {
+    super();
+    this.message = message ?? 'Too many requests';
+    this.requestID = requestID;
+    this.retryAfter = retryAfter;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/generic-server.exception.ts',
+      content: `export class GenericServerException extends Error {
+  readonly status: number;
+  readonly name = 'GenericServerException';
+  readonly requestID: string;
+
+  constructor(status: number, message: string, requestID: string) {
+    super();
+    this.status = status;
+    this.message = message ?? 'Server error';
+    this.requestID = requestID;
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/no-api-key-provided.exception.ts',
+      content: `export class NoApiKeyProvidedException extends Error {
+  readonly name = 'NoApiKeyProvidedException';
+
+  constructor() {
+    super();
+    this.message =
+      'No API key provided. Pass it to the WorkOS constructor or set the WORKOS_API_KEY environment variable.';
+  }
+}`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/exceptions/index.ts',
+      content: `export { BadRequestException } from './bad-request.exception';
+export { UnauthorizedException } from './unauthorized.exception';
+export { NotFoundException } from './not-found.exception';
+export { ConflictException } from './conflict.exception';
+export {
+  UnprocessableEntityException,
+  type UnprocessableEntityError,
+} from './unprocessable-entity.exception';
+export { RateLimitExceededException } from './rate-limit-exceeded.exception';
+export { GenericServerException } from './generic-server.exception';
+export { NoApiKeyProvidedException } from './no-api-key-provided.exception';`,
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+  ];
+}

package/src/node/fixtures.ts

@@ -0,0 +1,139 @@
+import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
+import { wireFieldName, fileName, serviceDirName, buildServiceNameMap, resolveServiceName } from './naming.js';
+import { assignModelsToServices } from './utils.js';
+
+/**
+ * Generate JSON fixture files for test data.
+ * Each model that appears as a response gets a fixture in wire format (snake_case).
+ */
+export function generateFixtures(
+  spec: {
+    models: Model[];
+    enums: Enum[];
+    services: any[];
+  },
+  ctx?: EmitterContext,
+): { path: string; content: string }[] {
+  if (spec.models.length === 0) return [];
+
+  const modelToService = assignModelsToServices(spec.models, spec.services);
+  const serviceNameMap = ctx ? buildServiceNameMap(ctx.spec.services, ctx) : new Map<string, string>();
+  const resolveDir = (irService: string | undefined) =>
+    irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : 'common';
+  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+  const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
+  const files: { path: string; content: string }[] = [];
+
+  for (const model of spec.models) {
+    const service = modelToService.get(model.name);
+    const dirName = resolveDir(service);
+    const fixture = generateModelFixture(model, modelMap, enumMap);
+
+    files.push({
+      path: `src/${dirName}/fixtures/${fileName(model.name)}.fixture.json`,
+      content: JSON.stringify(fixture, null, 2),
+    });
+  }
+
+  // Generate list fixtures for models that appear in paginated responses
+  for (const service of spec.services) {
+    const resolvedName = ctx ? resolveServiceName(service, ctx) : service.name;
+    const serviceDir = serviceDirName(resolvedName);
+    for (const op of service.operations) {
+      if (op.pagination) {
+        const itemModel = op.pagination.itemType.kind === 'model' ? modelMap.get(op.pagination.itemType.name) : null;
+        if (itemModel) {
+          const fixture = generateModelFixture(itemModel, modelMap, enumMap);
+          const listFixture = {
+            data: [fixture],
+            list_metadata: {
+              before: null,
+              after: null,
+            },
+          };
+          files.push({
+            path: `src/${serviceDir}/fixtures/list-${fileName(itemModel.name)}.fixture.json`,
+            content: JSON.stringify(listFixture, null, 2),
+          });
+        }
+      }
+    }
+  }
+
+  return files;
+}
+
+function generateModelFixture(
+  model: Model,
+  modelMap: Map<string, Model>,
+  enumMap: Map<string, Enum>,
+): Record<string, any> {
+  const fixture: Record<string, any> = {};
+
+  for (const field of model.fields) {
+    const wireName = wireFieldName(field.name);
+    fixture[wireName] = generateFieldValue(field.type, field.name, modelMap, enumMap);
+  }
+
+  return fixture;
+}
+
+function generateFieldValue(
+  ref: TypeRef,
+  fieldName: string,
+  modelMap: Map<string, Model>,
+  enumMap: Map<string, Enum>,
+): any {
+  switch (ref.kind) {
+    case 'primitive':
+      return generatePrimitiveValue(ref.type, ref.format, fieldName);
+    case 'literal':
+      return ref.value;
+    case 'enum': {
+      const e = enumMap.get(ref.name);
+      return e?.values[0]?.value ?? 'unknown';
+    }
+    case 'model': {
+      const nested = modelMap.get(ref.name);
+      if (nested) return generateModelFixture(nested, modelMap, enumMap);
+      return {};
+    }
+    case 'array': {
+      const item = generateFieldValue(ref.items, fieldName, modelMap, enumMap);
+      return [item];
+    }
+    case 'nullable':
+      return generateFieldValue(ref.inner, fieldName, modelMap, enumMap);
+    case 'union':
+      if (ref.variants.length > 0) {
+        return generateFieldValue(ref.variants[0], fieldName, modelMap, enumMap);
+      }
+      return null;
+    case 'map':
+      return { key: generateFieldValue(ref.valueType, 'value', modelMap, enumMap) };
+  }
+}
+
+function generatePrimitiveValue(type: string, format: string | undefined, name: string): any {
+  switch (type) {
+    case 'string':
+      if (format === 'date-time') return '2023-01-01T00:00:00.000Z';
+      if (format === 'date') return '2023-01-01';
+      if (format === 'uuid') return '00000000-0000-0000-0000-000000000000';
+      if (name.includes('id')) return `${name}_01234`;
+      if (name.includes('email')) return 'test@example.com';
+      if (name.includes('url') || name.includes('uri')) return 'https://example.com';
+      if (name.includes('name')) return 'Test';
+      return `test_${name}`;
+    case 'integer':
+      return 1;
+    case 'number':
+      return 1.0;
+    case 'boolean':
+      return true;
+    case 'unknown':
+      return {};
+    default:
+      return null;
+  }
+}

package/src/node/index.ts

@@ -0,0 +1,57 @@
+import type { Emitter, EmitterContext, GeneratedFile, ApiSpec, Model, Enum, Service } from '@workos/oagen';
+
+import { generateModels } from './models.js';
+import { generateEnums } from './enums.js';
+import { generateSerializers } from './serializers.js';
+import { generateResources } from './resources.js';
+import { generateClient } from './client.js';
+import { generateErrors } from './errors.js';
+import { generateConfig } from './config.js';
+import { generateCommon } from './common.js';
+import { generateTests } from './tests.js';
+import { generateManifest } from './manifest.js';
+
+export const nodeEmitter: Emitter = {
+  language: 'node',
+
+  generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
+    return [...generateModels(models, ctx), ...generateSerializers(models, ctx)];
+  },
+
+  generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
+    return generateEnums(enums, ctx);
+  },
+
+  generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
+    return generateResources(services, ctx);
+  },
+
+  generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return generateClient(spec, ctx);
+  },
+
+  generateErrors(_ctx: EmitterContext): GeneratedFile[] {
+    return generateErrors();
+  },
+
+  generateConfig(_ctx: EmitterContext): GeneratedFile[] {
+    return [...generateConfig(), ...generateCommon()];
+  },
+
+  generateTypeSignatures(_spec: ApiSpec, _ctx: EmitterContext): GeneratedFile[] {
+    // TypeScript uses inline types — no separate type signature files needed
+    return [];
+  },
+
+  generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return generateTests(spec, ctx);
+  },
+
+  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return generateManifest(spec, ctx);
+  },
+
+  fileHeader(): string {
+    return '// This file is auto-generated by oagen. Do not edit.';
+  },
+};

package/src/node/manifest.ts

@@ -0,0 +1,23 @@
+import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import { resolveMethodName, servicePropertyName, resolveServiceName } from './naming.js';
+
+export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+
+  for (const service of spec.services) {
+    const propName = servicePropertyName(resolveServiceName(service, ctx));
+    for (const op of service.operations) {
+      const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+      const method = resolveMethodName(op, service, ctx);
+      manifest[httpKey] = { sdkMethod: method, service: propName };
+    }
+  }
+
+  return [
+    {
+      path: 'smoke-manifest.json',
+      content: JSON.stringify(manifest, null, 2),
+      integrateTarget: false,
+    },
+  ];
+}