@workos/oagen-emitters 0.0.1

package/src/compat/extractors/dotnet.ts

@@ -0,0 +1,8 @@
+/**
+ * DotNet (C#) extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { dotnetExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/elixir.ts

@@ -0,0 +1,8 @@
+/**
+ * Elixir extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { elixirExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/go.ts

@@ -0,0 +1,8 @@
+/**
+ * Go extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { goExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/kotlin.ts

@@ -0,0 +1,8 @@
+/**
+ * Kotlin extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { kotlinExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/node.ts

@@ -0,0 +1,8 @@
+/**
+ * Node/TypeScript extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { nodeExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/php.ts

@@ -0,0 +1,8 @@
+/**
+ * PHP extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { phpExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/python.ts

@@ -0,0 +1,8 @@
+/**
+ * Python extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { pythonExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/ruby.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { rubyExtractor } from '@workos/oagen/compat';

package/src/compat/extractors/rust.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust extractor — delegates to the canonical implementation in @workos/oagen.
+ *
+ * Re-exported here so the emitter project can:
+ *  1. Register it in oagen.config.ts alongside the emitter
+ *  2. Customize hints if the generated SDK deviates from core defaults
+ */
+export { rustExtractor } from '@workos/oagen/compat';

package/src/index.ts

@@ -0,0 +1 @@
+export { nodeEmitter } from './node/index.js';

package/src/node/client.ts

@@ -0,0 +1,356 @@
+import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import {
+  fileName,
+  serviceDirName,
+  servicePropertyName,
+  resolveInterfaceName,
+  resolveServiceName,
+  buildServiceNameMap,
+  wireInterfaceName,
+} from './naming.js';
+import { assignModelsToServices } from './utils.js';
+
+export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  const files: GeneratedFile[] = [];
+
+  files.push(generateWorkOSClient(spec, ctx));
+  files.push(generateBarrel(spec, ctx));
+  files.push(generatePackageJson(ctx));
+  files.push(generateTsConfig());
+
+  return files;
+}
+
+function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
+  const lines: string[] = [];
+
+  // Service imports
+  for (const service of spec.services) {
+    const resolvedName = resolveServiceName(service, ctx);
+    const serviceDir = serviceDirName(resolvedName);
+    lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
+  }
+
+  lines.push("import type { WorkOSOptions } from './common/interfaces/workos-options.interface';");
+  lines.push("import type { PostOptions } from './common/interfaces/post-options.interface';");
+  lines.push("import type { GetOptions } from './common/interfaces/get-options.interface';");
+  lines.push("import { NoApiKeyProvidedException } from './common/exceptions/no-api-key-provided.exception';");
+  lines.push("import { UnauthorizedException } from './common/exceptions/unauthorized.exception';");
+  lines.push("import { NotFoundException } from './common/exceptions/not-found.exception';");
+  lines.push("import { ConflictException } from './common/exceptions/conflict.exception';");
+  lines.push("import { UnprocessableEntityException } from './common/exceptions/unprocessable-entity.exception';");
+  lines.push("import { RateLimitExceededException } from './common/exceptions/rate-limit-exceeded.exception';");
+  lines.push("import { GenericServerException } from './common/exceptions/generic-server.exception';");
+  lines.push("import { BadRequestException } from './common/exceptions/bad-request.exception';");
+
+  lines.push('');
+  lines.push('export class WorkOS {');
+  lines.push('  readonly baseURL: string;');
+  lines.push('  readonly key: string;');
+  lines.push('  private readonly options: WorkOSOptions;');
+  lines.push('');
+
+  // Resource accessors
+  for (const service of spec.services) {
+    const resolvedName = resolveServiceName(service, ctx);
+    const propName = servicePropertyName(resolvedName);
+    lines.push(`  readonly ${propName} = new ${resolvedName}(this);`);
+  }
+
+  lines.push('');
+  lines.push('  constructor(keyOrOptions?: string | WorkOSOptions, maybeOptions?: WorkOSOptions) {');
+  lines.push("    if (typeof keyOrOptions === 'object') {");
+  lines.push("      this.key = keyOrOptions.apiKey ?? '';");
+  lines.push('      this.options = keyOrOptions;');
+  lines.push('    } else {');
+  lines.push("      this.key = keyOrOptions ?? '';");
+  lines.push('      this.options = maybeOptions ?? {};');
+  lines.push('    }');
+  lines.push('');
+  lines.push('    if (!this.key) {');
+  lines.push("      const envKey = typeof process !== 'undefined' ? process.env?.WORKOS_API_KEY : undefined;");
+  lines.push('      if (envKey) this.key = envKey;');
+  lines.push('    }');
+  lines.push('');
+  lines.push("    const protocol = this.options.https === false ? 'http' : 'https';");
+  lines.push("    const hostname = this.options.apiHostname ?? 'api.workos.com';");
+  lines.push("    const port = this.options.port ? `:${this.options.port}` : '';");
+  lines.push('    this.baseURL = `${protocol}://${hostname}${port}`;');
+  lines.push('  }');
+
+  // HTTP methods
+  lines.push('');
+  lines.push('  async get<Result = any>(path: string, options: GetOptions = {}): Promise<{ data: Result }> {');
+  lines.push('    this.ensureApiKey(options);');
+  lines.push('    const url = this.buildUrl(path, options.query);');
+  lines.push('    const response = await fetch(url, {');
+  lines.push("      method: 'GET',");
+  lines.push('      headers: this.buildHeaders(options),');
+  lines.push('    });');
+  lines.push('    await this.handleHttpError(response, path);');
+  lines.push('    const data = await response.json() as Result;');
+  lines.push('    return { data };');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push(
+    '  async post<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {',
+  );
+  lines.push('    this.ensureApiKey(options);');
+  lines.push('    const url = this.buildUrl(path, options.query);');
+  lines.push('    const response = await fetch(url, {');
+  lines.push("      method: 'POST',");
+  lines.push('      headers: this.buildHeaders(options),');
+  lines.push('      body: JSON.stringify(entity),');
+  lines.push('    });');
+  lines.push('    await this.handleHttpError(response, path);');
+  lines.push('    const data = await response.json() as Result;');
+  lines.push('    return { data };');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push(
+    '  async put<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {',
+  );
+  lines.push('    this.ensureApiKey(options);');
+  lines.push('    const url = this.buildUrl(path, options.query);');
+  lines.push('    const response = await fetch(url, {');
+  lines.push("      method: 'PUT',");
+  lines.push('      headers: this.buildHeaders(options),');
+  lines.push('      body: JSON.stringify(entity),');
+  lines.push('    });');
+  lines.push('    await this.handleHttpError(response, path);');
+  lines.push('    const data = await response.json() as Result;');
+  lines.push('    return { data };');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push(
+    '  async patch<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {',
+  );
+  lines.push('    this.ensureApiKey(options);');
+  lines.push('    const url = this.buildUrl(path, options.query);');
+  lines.push('    const response = await fetch(url, {');
+  lines.push("      method: 'PATCH',");
+  lines.push('      headers: this.buildHeaders(options),');
+  lines.push('      body: JSON.stringify(entity),');
+  lines.push('    });');
+  lines.push('    await this.handleHttpError(response, path);');
+  lines.push('    const data = await response.json() as Result;');
+  lines.push('    return { data };');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push('  async delete(path: string, options: GetOptions = {}): Promise<void> {');
+  lines.push('    this.ensureApiKey(options);');
+  lines.push('    const url = this.buildUrl(path);');
+  lines.push('    const response = await fetch(url, {');
+  lines.push("      method: 'DELETE',");
+  lines.push('      headers: this.buildHeaders(options),');
+  lines.push('    });');
+  lines.push('    await this.handleHttpError(response, path);');
+  lines.push('  }');
+
+  // Private helpers
+  lines.push('');
+  lines.push('  private buildUrl(path: string, query?: Record<string, any>): string {');
+  lines.push('    const url = new URL(path, this.baseURL);');
+  lines.push('    if (query) {');
+  lines.push('      for (const [key, value] of Object.entries(query)) {');
+  lines.push("        if (value !== null && value !== undefined && value !== '') {");
+  lines.push('          url.searchParams.set(key, String(value));');
+  lines.push('        }');
+  lines.push('      }');
+  lines.push('    }');
+  lines.push('    return url.toString();');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push('  private buildHeaders(options: any = {}): Record<string, string> {');
+  lines.push('    const headers: Record<string, string> = {');
+  lines.push("      'Content-Type': 'application/json',");
+  lines.push(`      Authorization: \`Bearer \${this.key}\`,`);
+  lines.push('    };');
+  lines.push("    if (options.idempotencyKey) headers['Idempotency-Key'] = options.idempotencyKey;");
+  lines.push("    if (options.warrantToken) headers['Warrant-Token'] = options.warrantToken;");
+  lines.push('    return headers;');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push('  private ensureApiKey(options: any = {}): void {');
+  lines.push('    if (!this.key && !options.skipApiKeyCheck) {');
+  lines.push('      throw new NoApiKeyProvidedException();');
+  lines.push('    }');
+  lines.push('  }');
+
+  lines.push('');
+  lines.push('  private async handleHttpError(response: Response, path: string): Promise<void> {');
+  lines.push('    if (response.ok) return;');
+  lines.push('');
+  lines.push("    const requestID = response.headers.get('x-request-id') ?? '';");
+  lines.push('    let data: any = {};');
+  lines.push('    try { data = await response.json(); } catch {}');
+  lines.push('    const { message, code, errors } = data;');
+  lines.push('');
+  lines.push('    switch (response.status) {');
+  lines.push('      case 400: throw new BadRequestException({ code, message, requestID });');
+  lines.push('      case 401: throw new UnauthorizedException(requestID);');
+  lines.push('      case 404: throw new NotFoundException({ code, message, path, requestID });');
+  lines.push('      case 409: throw new ConflictException({ message, requestID });');
+  lines.push('      case 422: throw new UnprocessableEntityException({ code, errors, message, requestID });');
+  lines.push('      case 429: {');
+  lines.push("        const retryAfter = Number(response.headers.get('retry-after')) || undefined;");
+  lines.push("        throw new RateLimitExceededException(message ?? 'Too many requests', requestID, retryAfter);");
+  lines.push('      }');
+  lines.push("      default: throw new GenericServerException(response.status, message ?? 'Server error', requestID);");
+  lines.push('    }');
+  lines.push('  }');
+
+  lines.push('}');
+
+  return { path: 'src/workos.ts', content: lines.join('\n'), skipIfExists: true, integrateTarget: false };
+}
+
+// Names exported from common utilities that must not be re-exported from model interfaces
+const RESERVED_BARREL_NAMES = new Set(['List', 'ListResponse', 'ListMetadata', 'AutoPaginatable', 'PaginationOptions']);
+
+function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
+  const lines: string[] = [];
+  const modelToService = assignModelsToServices(spec.models, spec.services);
+  const serviceNameMap = buildServiceNameMap(spec.services, ctx);
+  const resolveDir = (irService: string | undefined) =>
+    irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : 'common';
+
+  // Common exports
+  lines.push("export * from './common/exceptions';");
+  lines.push("export { AutoPaginatable } from './common/utils/pagination';");
+  lines.push("export type { List, ListMetadata, ListResponse } from './common/utils/pagination';");
+  lines.push("export type { PaginationOptions } from './common/interfaces/pagination-options.interface';");
+  lines.push("export type { WorkOSOptions } from './common/interfaces/workos-options.interface';");
+  lines.push("export type { PostOptions } from './common/interfaces/post-options.interface';");
+  lines.push("export type { GetOptions } from './common/interfaces/get-options.interface';");
+  lines.push('');
+
+  // Per-service exports: interfaces + resource class
+  for (const service of spec.services) {
+    const resolvedName = resolveServiceName(service, ctx);
+    const serviceDir = serviceDirName(resolvedName);
+
+    // Collect models that belong to this service, skipping reserved names
+    const serviceModels = spec.models.filter((m) => modelToService.get(m.name) === service.name);
+    for (const model of serviceModels) {
+      const name = resolveInterfaceName(model.name, ctx);
+      const wireName = wireInterfaceName(name);
+      if (RESERVED_BARREL_NAMES.has(name) || RESERVED_BARREL_NAMES.has(wireName)) continue;
+      lines.push(
+        `export type { ${name}, ${wireName} } from './${serviceDir}/interfaces/${fileName(model.name)}.interface';`,
+      );
+    }
+
+    // Resource class
+    lines.push(`export { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
+    lines.push('');
+  }
+
+  // Unassigned models (common), skipping reserved names
+  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name));
+  for (const model of unassignedModels) {
+    const name = resolveInterfaceName(model.name, ctx);
+    const wireName = wireInterfaceName(name);
+    if (RESERVED_BARREL_NAMES.has(name) || RESERVED_BARREL_NAMES.has(wireName)) continue;
+    lines.push(`export type { ${name}, ${wireName} } from './common/interfaces/${fileName(model.name)}.interface';`);
+  }
+
+  // Enum exports
+  for (const enumDef of spec.enums) {
+    // Find which service directory the enum landed in
+    const enumService = findEnumService(enumDef.name, spec.services);
+    const dir = resolveDir(enumService);
+    lines.push(`export type { ${enumDef.name} } from './${dir}/interfaces/${fileName(enumDef.name)}.interface';`);
+  }
+
+  lines.push('');
+  lines.push("export { WorkOS } from './workos';");
+
+  return { path: 'src/index.ts', content: lines.join('\n'), skipIfExists: true };
+}
+
+function findEnumService(enumName: string, services: Service[]): string | undefined {
+  for (const service of services) {
+    for (const op of service.operations) {
+      const refs: string[] = [];
+      const collect = (ref: any) => {
+        if (ref?.kind === 'enum' && ref.name === enumName) refs.push(ref.name);
+        if (ref?.items) collect(ref.items);
+        if (ref?.inner) collect(ref.inner);
+        if (ref?.variants) ref.variants.forEach(collect);
+        if (ref?.valueType) collect(ref.valueType);
+      };
+      if (op.requestBody) collect(op.requestBody);
+      collect(op.response);
+      for (const p of [...op.pathParams, ...op.queryParams]) {
+        collect(p.type);
+      }
+      if (refs.length > 0) return service.name;
+    }
+  }
+  return undefined;
+}
+
+function generatePackageJson(ctx: EmitterContext): GeneratedFile {
+  const pkg = {
+    name: `@${ctx.namespace}/sdk`,
+    version: '0.0.0',
+    type: 'module',
+    main: 'src/index.ts',
+    types: 'src/index.ts',
+    exports: {
+      '.': './src/index.ts',
+    },
+    scripts: {
+      test: 'jest',
+      build: 'tsc',
+    },
+    devDependencies: {
+      typescript: '^5.0.0',
+      jest: '^29.0.0',
+      'jest-fetch-mock': '^3.0.0',
+      '@types/jest': '^29.0.0',
+      'ts-jest': '^29.0.0',
+    },
+  };
+
+  return {
+    path: 'package.json',
+    content: JSON.stringify(pkg, null, 2),
+    skipIfExists: true,
+    integrateTarget: false,
+  };
+}
+
+function generateTsConfig(): GeneratedFile {
+  const config = {
+    compilerOptions: {
+      target: 'ES2020',
+      module: 'CommonJS',
+      lib: ['ES2020'],
+      declaration: true,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      resolveJsonModule: true,
+      outDir: './lib',
+      rootDir: './src',
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'lib', '**/*.spec.ts'],
+  };
+
+  return {
+    path: 'tsconfig.json',
+    content: JSON.stringify(config, null, 2),
+    skipIfExists: true,
+    integrateTarget: false,
+  };
+}

package/src/node/common.ts

@@ -0,0 +1,203 @@
+import type { GeneratedFile } from '@workos/oagen';
+
+export function generateCommon(): GeneratedFile[] {
+  return [
+    {
+      path: 'src/common/utils/pagination.ts',
+      content: paginationContent(),
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/utils/fetch-and-deserialize.ts',
+      content: fetchAndDeserializeContent(),
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/serializers/list.serializer.ts',
+      content: listSerializerContent(),
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+    {
+      path: 'src/common/utils/test-utils.ts',
+      content: testUtilsContent(),
+      skipIfExists: true,
+      integrateTarget: false,
+    },
+  ];
+}
+
+function paginationContent(): string {
+  return `import type { PaginationOptions } from '../interfaces/pagination-options.interface';
+
+export interface ListMetadata {
+  before: string | null;
+  after: string | null;
+}
+
+export interface List<T> {
+  object: 'list';
+  data: T[];
+  listMetadata: ListMetadata;
+}
+
+export interface ListResponse<T> {
+  object: 'list';
+  data: T[];
+  list_metadata: {
+    before: string | null;
+    after: string | null;
+  };
+}
+
+export class AutoPaginatable<
+  ResourceType,
+  ParametersType extends PaginationOptions = PaginationOptions,
+> {
+  readonly object = 'list' as const;
+  readonly options: ParametersType;
+
+  constructor(
+    protected list: List<ResourceType>,
+    private apiCall: (params: PaginationOptions) => Promise<List<ResourceType>>,
+    options?: ParametersType,
+  ) {
+    this.options = options ?? ({} as ParametersType);
+  }
+
+  get data(): ResourceType[] {
+    return this.list.data;
+  }
+
+  get listMetadata() {
+    return this.list.listMetadata;
+  }
+
+  private async *generatePages(
+    params: PaginationOptions,
+  ): AsyncGenerator<ResourceType[]> {
+    const result = await this.apiCall({
+      ...this.options,
+      limit: 100,
+      after: params.after,
+    });
+    yield result.data;
+    if (result.listMetadata.after) {
+      await new Promise((resolve) => setTimeout(resolve, 350));
+      yield* this.generatePages({ after: result.listMetadata.after });
+    }
+  }
+
+  async autoPagination(): Promise<ResourceType[]> {
+    if (this.options.limit) {
+      return this.data;
+    }
+    const results: ResourceType[] = [];
+    for await (const page of this.generatePages({
+      after: this.options.after,
+    })) {
+      results.push(...page);
+    }
+    return results;
+  }
+}`;
+}
+
+function fetchAndDeserializeContent(): string {
+  return `import type { WorkOS } from '../../workos';
+import type { PaginationOptions } from '../interfaces/pagination-options.interface';
+import type { List, ListResponse } from './pagination';
+
+function setDefaultOptions(
+  options?: PaginationOptions,
+): Record<string, any> {
+  return {
+    order: 'desc',
+    ...options,
+  };
+}
+
+function deserializeList<T, U>(
+  data: ListResponse<T>,
+  deserializeFn: (item: T) => U,
+): List<U> {
+  return {
+    data: data.data.map(deserializeFn),
+    listMetadata: {
+      before: data.list_metadata.before,
+      after: data.list_metadata.after,
+    },
+  };
+}
+
+export const fetchAndDeserialize = async <T, U>(
+  workos: WorkOS,
+  endpoint: string,
+  deserializeFn: (data: T) => U,
+  options?: PaginationOptions,
+): Promise<List<U>> => {
+  const { data } = await workos.get<ListResponse<T>>(endpoint, {
+    query: setDefaultOptions(options),
+  });
+  return deserializeList(data, deserializeFn);
+};`;
+}
+
+function listSerializerContent(): string {
+  return `import type { ListMetadata, ListResponse } from '../utils/pagination';
+
+export function deserializeListMetadata(
+  metadata: ListResponse<any>['list_metadata'],
+): ListMetadata {
+  return {
+    before: metadata.before,
+    after: metadata.after,
+  };
+}`;
+}
+
+function testUtilsContent(): string {
+  return `import fetch from 'jest-fetch-mock';
+
+interface MockParams {
+  status?: number;
+  headers?: Record<string, string>;
+  [key: string]: any;
+}
+
+export function fetchOnce(
+  response: any = {},
+  { status = 200, headers, ...rest }: MockParams = {},
+) {
+  return fetch.once(JSON.stringify(response), {
+    status,
+    headers: {
+      'content-type': 'application/json;charset=UTF-8',
+      ...headers,
+    },
+    ...rest,
+  });
+}
+
+export function fetchURL(): string {
+  return String(fetch.mock.calls[0][0]);
+}
+
+export function fetchSearchParams(): Record<string, string> {
+  return Object.fromEntries(new URL(fetchURL()).searchParams);
+}
+
+export function fetchHeaders(): Record<string, string> {
+  const headers = fetch.mock.calls[0][1]?.headers ?? {};
+  return headers as Record<string, string>;
+}
+
+export function fetchBody({ raw = false } = {}): any {
+  const body = fetch.mock.calls[0][1]?.body;
+  if (body instanceof URLSearchParams) return body.toString();
+  if (raw) return body;
+  return JSON.parse(String(body));
+}`;
+}