@workos/oagen-emitters 0.0.1 → 0.2.0

package/src/node/common.ts

@@ -12,7 +12,7 @@ export function generateCommon(): GeneratedFile[] {
       path: 'src/common/utils/fetch-and-deserialize.ts',
       content: fetchAndDeserializeContent(),
       skipIfExists: true,
-      integrateTarget: false,
+      integrateTarget: true,
     },
     {
       path: 'src/common/serializers/list.serializer.ts',
@@ -24,7 +24,7 @@ export function generateCommon(): GeneratedFile[] {
       path: 'src/common/utils/test-utils.ts',
       content: testUtilsContent(),
       skipIfExists: true,
-      integrateTarget: false,
+      integrateTarget: true,
     },
   ];
 }
@@ -108,7 +108,7 @@ export class AutoPaginatable<
 function fetchAndDeserializeContent(): string {
   return `import type { WorkOS } from '../../workos';
 import type { PaginationOptions } from '../interfaces/pagination-options.interface';
-import type { List, ListResponse } from './pagination';
+import { AutoPaginatable, type List, type ListResponse } from './pagination';
 
 function setDefaultOptions(
   options?: PaginationOptions,
@@ -142,7 +142,20 @@ export const fetchAndDeserialize = async <T, U>(
     query: setDefaultOptions(options),
   });
   return deserializeList(data, deserializeFn);
-};`;
+};
+
+export async function createPaginatedList<TResponse, TModel, TOptions extends PaginationOptions>(
+  workos: WorkOS,
+  endpoint: string,
+  deserializeFn: (r: TResponse) => TModel,
+  options?: TOptions,
+): Promise<AutoPaginatable<TModel, TOptions>> {
+  return new AutoPaginatable(
+    await fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, options),
+    (params) => fetchAndDeserialize<TResponse, TModel>(workos, endpoint, deserializeFn, params),
+    options,
+  );
+}`;
 }
 
 function listSerializerContent(): string {
@@ -185,6 +198,10 @@ export function fetchURL(): string {
   return String(fetch.mock.calls[0][0]);
 }
 
+export function fetchMethod(): string {
+  return String(fetch.mock.calls[0][1]?.method ?? 'GET');
+}
+
 export function fetchSearchParams(): Record<string, string> {
   return Object.fromEntries(new URL(fetchURL()).searchParams);
 }
@@ -199,5 +216,58 @@ export function fetchBody({ raw = false } = {}): any {
   if (body instanceof URLSearchParams) return body.toString();
   if (raw) return body;
   return JSON.parse(String(body));
+}
+
+/**
+ * Shared test helper: asserts that the given async function throws when the
+ * server responds with 401 Unauthorized.
+ */
+export function testUnauthorized(fn: () => Promise<any>) {
+  it('throws on unauthorized', async () => {
+    fetchOnce({ message: 'Unauthorized' }, { status: 401 });
+    await expect(fn()).rejects.toThrow('Unauthorized');
+  });
+}
+
+/**
+ * Shared test helper: asserts that a paginated list call returns the expected
+ * shape (data array + listMetadata) and hits the correct endpoint.
+ */
+export function testPaginatedList(
+  fn: () => Promise<any>,
+  pathContains: string,
+) {
+  it('returns paginated results', async () => {
+    // Caller must have called fetchOnce with the list fixture before invoking fn
+    const { data, listMetadata } = await fn();
+    expect(fetchURL()).toContain(pathContains);
+    expect(fetchSearchParams()).toHaveProperty('order');
+    expect(Array.isArray(data)).toBe(true);
+    expect(listMetadata).toBeDefined();
+  });
+}
+
+/**
+ * Shared test helper: asserts that a paginated list call returns empty data
+ * when the server responds with an empty list.
+ */
+export function testEmptyResults(fn: () => Promise<any>) {
+  it('handles empty results', async () => {
+    fetchOnce({ data: [], list_metadata: { before: null, after: null } });
+    const { data } = await fn();
+    expect(data).toEqual([]);
+  });
+}
+
+/**
+ * Shared test helper: asserts that pagination params are forwarded correctly.
+ */
+export function testPaginationParams(fn: (opts: any) => Promise<any>, fixture: any) {
+  it('forwards pagination params', async () => {
+    fetchOnce(fixture);
+    await fn({ limit: 10, after: 'cursor_abc' });
+    expect(fetchSearchParams()['limit']).toBe('10');
+    expect(fetchSearchParams()['after']).toBe('cursor_abc');
+  });
 }`;
 }

package/src/node/config.ts

@@ -29,6 +29,7 @@ export interface AppInfo {
   idempotencyKey?: string;
   warrantToken?: string;
   skipApiKeyCheck?: boolean;
+  encoding?: 'json' | 'form-data' | 'form-urlencoded' | 'binary' | 'text';
 }`,
       skipIfExists: true,
       integrateTarget: false,

package/src/node/enums.ts

@@ -21,17 +21,44 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
     const lines: string[] = [];
 
+    // Track whether the generated content has new values not in the baseline.
+    // When it does, skipIfExists must be false so the file gets updated.
+    let hasNewValues = false;
+
     if (baselineEnum?.members) {
-      // Generate TS `enum` using baseline member names and values directly
+      // Generate TS `enum` using baseline member names and values, merging
+      // any new IR values that the baseline is missing.
+      const existingValues = new Set(Object.values(baselineEnum.members).map(String));
+      const irValues = enumDef.values.map((v) => String(v.value));
+      const missingValues = irValues.filter((v) => !existingValues.has(v));
+      hasNewValues = missingValues.length > 0;
+
       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},`);
       }
+      // Append new values from the spec that the baseline is missing
+      for (const val of missingValues) {
+        // Derive a PascalCase member name from the value
+        const memberName = val.replace(/[^a-zA-Z0-9]+/g, '');
+        lines.push(`  ${memberName} = '${val}',`);
+      }
       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};`);
+      // Use the baseline type alias value, but merge in any new IR values the baseline is missing.
+      const baselineValues = extractLiteralUnionValues(baselineAlias.value);
+      const irValues = enumDef.values.map((v) => String(v.value));
+      const missing = irValues.filter((v) => !baselineValues.has(v));
+      hasNewValues = missing.length > 0;
+      if (missing.length > 0) {
+        // Baseline is missing values from the spec — regenerate with all values merged
+        const allValues = [...baselineValues, ...missing];
+        const parts = allValues.map((v) => `'${v}'`);
+        lines.push(`export type ${enumDef.name} = ${parts.join(' | ')};`);
+      } else {
+        lines.push(`export type ${enumDef.name} = ${baselineAlias.value};`);
+      }
     } else {
       // No baseline — generate string literal union from IR values
       const values = enumDef.values;
@@ -53,14 +80,31 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     files.push({
       path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
       content: lines.join('\n'),
-      skipIfExists: true,
+      // When the spec has new values the baseline is missing, allow the file
+      // to be updated so the SDK picks up the full set of enum values.
+      skipIfExists: !hasNewValues,
     });
   }
 
   return files;
 }
 
-function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
+/**
+ * Parse a TypeScript string literal union type alias value (e.g., "'a' | 'b' | 'c'")
+ * into a set of its string values.
+ */
+function extractLiteralUnionValues(aliasValue: string): Set<string> {
+  const values = new Set<string>();
+  // Match all single-quoted string literals in the union
+  const regex = /'([^']+)'/g;
+  let match;
+  while ((match = regex.exec(aliasValue)) !== null) {
+    values.add(match[1]);
+  }
+  return values;
+}
+
+export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
   const enumToService = new Map<string, string>();
   const enumNames = new Set(enums.map((e) => e.name));
 
@@ -72,7 +116,7 @@ function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string,
       };
       if (op.requestBody) collect(op.requestBody);
       collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
         collect(p.type);
       }
       for (const name of refs) {

package/src/node/errors.ts

@@ -1,7 +1,8 @@
-import type { GeneratedFile } from '@workos/oagen';
+import type { EmitterContext, GeneratedFile } from '@workos/oagen';
+import { fileName } from './naming.js';
 
-export function generateErrors(): GeneratedFile[] {
-  return [
+export function generateErrors(ctx?: EmitterContext): GeneratedFile[] {
+  const files: GeneratedFile[] = [
     {
       path: 'src/common/exceptions/bad-request.exception.ts',
       content: `export class BadRequestException extends Error {
@@ -202,4 +203,78 @@ export { NoApiKeyProvidedException } from './no-api-key-provided.exception';`,
       integrateTarget: false,
     },
   ];
+
+  // Fix 6: Generate typed exception classes from ErrorResponse.type
+  if (ctx?.spec) {
+    const typedErrors = collectTypedErrors(ctx);
+    for (const { modelName, statusCode, baseException } of typedErrors) {
+      const exceptionClassName = `${modelName}Exception`;
+      const filePath = `src/common/exceptions/${fileName(modelName)}.exception.ts`;
+      const baseImport = baseException
+        ? `import { ${baseException} } from './${fileName(baseException.replace(/Exception$/, '')).replace(/^/, '')}.exception';\n\n`
+        : '';
+      const baseClass = baseException ?? 'Error';
+
+      files.push({
+        path: filePath,
+        content: `${baseImport}export class ${exceptionClassName} extends ${baseClass} {
+  readonly status = ${statusCode};
+  readonly name = '${exceptionClassName}';
+  readonly requestID: string;
+  readonly data?: any;
+
+  constructor({ message, requestID, data }: { message?: string; requestID: string; data?: any }) {
+    ${baseException ? `super(${baseException === 'UnauthorizedException' ? 'requestID' : `{ message: message ?? '${modelName} error', requestID }`});` : 'super();'}
+    this.message = message ?? '${modelName} error';
+    this.requestID = requestID;
+    if (data) this.data = data;
+  }
+}`,
+        skipIfExists: true,
+        integrateTarget: false,
+      });
+
+      // Update the barrel index to export the new exception
+      const existingIndex = files.find((f) => f.path === 'src/common/exceptions/index.ts');
+      if (existingIndex) {
+        existingIndex.content += `\nexport { ${exceptionClassName} } from './${fileName(modelName)}.exception';`;
+      }
+    }
+  }
+
+  return files;
+}
+
+const STATUS_TO_BASE_EXCEPTION: Record<number, string> = {
+  400: 'BadRequestException',
+  401: 'UnauthorizedException',
+  404: 'NotFoundException',
+  409: 'ConflictException',
+  422: 'UnprocessableEntityException',
+  429: 'RateLimitExceededException',
+};
+
+function collectTypedErrors(
+  ctx: EmitterContext,
+): { modelName: string; statusCode: number; baseException: string | null }[] {
+  const seen = new Set<string>();
+  const results: { modelName: string; statusCode: number; baseException: string | null }[] = [];
+
+  for (const service of ctx.spec.services) {
+    for (const op of service.operations) {
+      for (const err of op.errors) {
+        if (err.type?.kind === 'model' && !seen.has(err.type.name)) {
+          seen.add(err.type.name);
+          results.push({
+            modelName: err.type.name,
+            statusCode: err.statusCode,
+            baseException:
+              STATUS_TO_BASE_EXCEPTION[err.statusCode] ?? (err.statusCode >= 500 ? 'GenericServerException' : null),
+          });
+        }
+      }
+    }
+  }
+
+  return results;
 }

package/src/node/fixtures.ts

@@ -1,6 +1,28 @@
 import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
-import { wireFieldName, fileName, serviceDirName, buildServiceNameMap, resolveServiceName } from './naming.js';
-import { assignModelsToServices } from './utils.js';
+import { wireFieldName, fileName, serviceDirName } from './naming.js';
+import { resolveResourceClassName } from './resources.js';
+import { createServiceDirResolver, assignModelsToServices, isListMetadataModel, isListWrapperModel } from './utils.js';
+
+/**
+ * Prefix mapping for generating realistic ID fixture values.
+ * When a field named "id" belongs to a model whose name matches a key here,
+ * the generated ID will be prefixed accordingly (e.g. "conn_01234").
+ */
+export const ID_PREFIXES: Record<string, string> = {
+  Connection: 'conn_',
+  Organization: 'org_',
+  OrganizationMembership: 'om_',
+  User: 'user_',
+  Directory: 'directory_',
+  DirectoryGroup: 'dir_grp_',
+  DirectoryUser: 'dir_usr_',
+  Invitation: 'inv_',
+  Session: 'session_',
+  AuthenticationFactor: 'auth_factor_',
+  EmailVerification: 'email_verification_',
+  MagicAuth: 'magic_auth_',
+  PasswordReset: 'password_reset_',
+};
 
 /**
  * Generate JSON fixture files for test data.
@@ -16,15 +38,21 @@ export function generateFixtures(
 ): { 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 { modelToService, resolveDir } = ctx
+    ? createServiceDirResolver(spec.models, ctx.spec.services, ctx)
+    : {
+        modelToService: assignModelsToServices(spec.models, spec.services),
+        resolveDir: (irService: string | undefined) => (irService ? serviceDirName(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) {
+    // Skip redundant list-metadata and list-wrapper models (handled by shared types)
+    if (isListMetadataModel(model)) continue;
+    if (isListWrapperModel(model)) continue;
+
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
     const fixture = generateModelFixture(model, modelMap, enumMap);
@@ -37,12 +65,18 @@ export function generateFixtures(
 
   // 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 resolvedName = ctx ? resolveResourceClassName(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;
+        let itemModel = op.pagination.itemType.kind === 'model' ? modelMap.get(op.pagination.itemType.name) : null;
         if (itemModel) {
+          // Detect if the "item" model is actually a list wrapper (has `data` array + `list_metadata`).
+          // If so, unwrap to the actual item type to avoid double-nesting in fixtures.
+          const unwrapped = unwrapListModel(itemModel, modelMap);
+          if (unwrapped) {
+            itemModel = unwrapped;
+          }
           const fixture = generateModelFixture(itemModel, modelMap, enumMap);
           const listFixture = {
             data: [fixture],
@@ -63,6 +97,24 @@ export function generateFixtures(
   return files;
 }
 
+/**
+ * Detect if a model is a list wrapper (has a `data` array field and a `list_metadata` field).
+ * If so, return the inner item model from the `data` array. Otherwise return null.
+ * This prevents double-nesting when the pagination itemType points to a list wrapper
+ * instead of the actual item model.
+ */
+export function unwrapListModel(model: Model, modelMap: Map<string, Model>): Model | null {
+  const dataField = model.fields.find((f) => f.name === 'data');
+  const hasListMetadata = model.fields.some((f) => f.name === 'list_metadata' || f.name === 'listMetadata');
+  if (dataField && hasListMetadata && dataField.type.kind === 'array') {
+    const itemType = dataField.type.items;
+    if (itemType.kind === 'model') {
+      return modelMap.get(itemType.name) ?? null;
+    }
+  }
+  return null;
+}
+
 function generateModelFixture(
   model: Model,
   modelMap: Map<string, Model>,
@@ -72,7 +124,12 @@ function generateModelFixture(
 
   for (const field of model.fields) {
     const wireName = wireFieldName(field.name);
-    fixture[wireName] = generateFieldValue(field.type, field.name, modelMap, enumMap);
+    // Prefer the OpenAPI example value when available on the field
+    if (field.example !== undefined) {
+      fixture[wireName] = field.example;
+    } else {
+      fixture[wireName] = generateFieldValue(field.type, field.name, model.name, modelMap, enumMap);
+    }
   }
 
   return fixture;
@@ -81,12 +138,13 @@ function generateModelFixture(
 function generateFieldValue(
   ref: TypeRef,
   fieldName: string,
+  modelName: string,
   modelMap: Map<string, Model>,
   enumMap: Map<string, Enum>,
 ): any {
   switch (ref.kind) {
     case 'primitive':
-      return generatePrimitiveValue(ref.type, ref.format, fieldName);
+      return generatePrimitiveValue(ref.type, ref.format, fieldName, modelName);
     case 'literal':
       return ref.value;
     case 'enum': {
@@ -99,27 +157,38 @@ function generateFieldValue(
       return {};
     }
     case 'array': {
-      const item = generateFieldValue(ref.items, fieldName, modelMap, enumMap);
+      // For array<enum>, use actual enum values instead of a single generated item
+      if (ref.items.kind === 'enum') {
+        const e = enumMap.get(ref.items.name);
+        if (e && e.values.length > 0) {
+          return e.values.map((v) => v.value);
+        }
+      }
+      const item = generateFieldValue(ref.items, fieldName, modelName, modelMap, enumMap);
       return [item];
     }
     case 'nullable':
-      return generateFieldValue(ref.inner, fieldName, modelMap, enumMap);
+      return generateFieldValue(ref.inner, fieldName, modelName, modelMap, enumMap);
     case 'union':
       if (ref.variants.length > 0) {
-        return generateFieldValue(ref.variants[0], fieldName, modelMap, enumMap);
+        return generateFieldValue(ref.variants[0], fieldName, modelName, modelMap, enumMap);
       }
       return null;
     case 'map':
-      return { key: generateFieldValue(ref.valueType, 'value', modelMap, enumMap) };
+      return { key: generateFieldValue(ref.valueType, 'value', modelName, modelMap, enumMap) };
   }
 }
 
-function generatePrimitiveValue(type: string, format: string | undefined, name: string): any {
+function generatePrimitiveValue(type: string, format: string | undefined, name: string, modelName: 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 === 'id') {
+        const prefix = ID_PREFIXES[modelName] ?? '';
+        return `${prefix}01234`;
+      }
       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';

package/src/node/index.ts

@@ -30,8 +30,8 @@ export const nodeEmitter: Emitter = {
     return generateClient(spec, ctx);
   },
 
-  generateErrors(_ctx: EmitterContext): GeneratedFile[] {
-    return generateErrors();
+  generateErrors(ctx: EmitterContext): GeneratedFile[] {
+    return generateErrors(ctx);
   },
 
   generateConfig(_ctx: EmitterContext): GeneratedFile[] {

package/src/node/manifest.ts

@@ -1,11 +1,12 @@
 import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
-import { resolveMethodName, servicePropertyName, resolveServiceName } from './naming.js';
+import { resolveMethodName, servicePropertyName } from './naming.js';
+import { resolveResourceClassName } from './resources.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));
+    const propName = servicePropertyName(resolveResourceClassName(service, ctx));
     for (const op of service.operations) {
       const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
       const method = resolveMethodName(op, service, ctx);
@@ -18,6 +19,7 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
       path: 'smoke-manifest.json',
       content: JSON.stringify(manifest, null, 2),
       integrateTarget: false,
+      overwriteExisting: true,
     },
   ];
 }