@workos/oagen-emitters 0.0.1

package/src/node/tests.ts

@@ -0,0 +1,336 @@
+import type { ApiSpec, Service, Operation, Model, TypeRef, EmitterContext, GeneratedFile } from '@workos/oagen';
+import { planOperation, toCamelCase } from '@workos/oagen';
+import {
+  fieldName,
+  wireFieldName,
+  fileName,
+  serviceDirName,
+  servicePropertyName,
+  resolveMethodName,
+  resolveServiceName,
+} from './naming.js';
+import { generateFixtures } from './fixtures.js';
+
+export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  const files: GeneratedFile[] = [];
+
+  // Generate fixture JSON files
+  const fixtures = generateFixtures(spec, ctx);
+  for (const f of fixtures) {
+    files.push({ path: f.path, content: f.content, headerPlacement: 'skip' });
+  }
+
+  // Build model lookup for response field assertions
+  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
+
+  // Generate test files per service
+  for (const service of spec.services) {
+    files.push(generateServiceTest(service, spec, ctx, modelMap));
+  }
+
+  return files;
+}
+
+function generateServiceTest(
+  service: Service,
+  spec: ApiSpec,
+  ctx: EmitterContext,
+  modelMap: Map<string, Model>,
+): GeneratedFile {
+  const resolvedName = resolveServiceName(service, ctx);
+  const serviceDir = serviceDirName(resolvedName);
+  const serviceClass = resolvedName;
+  const serviceProp = servicePropertyName(resolvedName);
+  const testPath = `src/${serviceDir}/${fileName(resolvedName)}.spec.ts`;
+
+  const lines: string[] = [];
+
+  lines.push("import fetch from 'jest-fetch-mock';");
+  lines.push('import {');
+  lines.push('  fetchOnce,');
+  lines.push('  fetchURL,');
+  lines.push('  fetchSearchParams,');
+  lines.push('  fetchBody,');
+  lines.push("} from '../common/utils/test-utils';");
+  lines.push("import { WorkOS } from '../workos';");
+  lines.push('');
+
+  // Import fixtures
+  const fixtureImports = new Set<string>();
+  for (const op of service.operations) {
+    const plan = planOperation(op);
+    if (plan.isPaginated && op.pagination) {
+      const itemModelName = op.pagination.itemType.kind === 'model' ? op.pagination.itemType.name : null;
+      if (itemModelName) {
+        fixtureImports.add(
+          `import list${itemModelName}Fixture from './fixtures/list-${fileName(itemModelName)}.fixture.json';`,
+        );
+      }
+    } else if (plan.responseModelName) {
+      fixtureImports.add(
+        `import ${toCamelCase(plan.responseModelName)}Fixture from './fixtures/${fileName(plan.responseModelName)}.fixture.json';`,
+      );
+    }
+  }
+  for (const imp of fixtureImports) {
+    lines.push(imp);
+  }
+
+  lines.push('');
+  lines.push("const workos = new WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');");
+  lines.push('');
+  lines.push(`describe('${serviceClass}', () => {`);
+  lines.push('  beforeEach(() => fetch.resetMocks());');
+
+  for (const op of service.operations) {
+    const plan = planOperation(op);
+    const method = resolveMethodName(op, service, ctx);
+
+    lines.push('');
+    lines.push(`  describe('${method}', () => {`);
+
+    if (plan.isPaginated) {
+      renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap);
+    } else if (plan.isDelete) {
+      renderDeleteTest(lines, op, method, serviceProp);
+    } else if (plan.hasBody && plan.responseModelName) {
+      renderBodyTest(lines, op, plan, method, serviceProp, modelMap);
+    } else if (plan.responseModelName) {
+      renderGetTest(lines, op, plan, method, serviceProp, modelMap);
+    } else {
+      renderVoidTest(lines, op, method, serviceProp);
+    }
+
+    // Error case test for all non-void operations
+    if (plan.responseModelName || plan.isPaginated) {
+      renderErrorTest(lines, op, plan, method, serviceProp);
+    }
+
+    lines.push('  });');
+  }
+
+  lines.push('});');
+
+  return { path: testPath, content: lines.join('\n'), skipIfExists: true, integrateTarget: false };
+}
+
+function renderPaginatedTest(
+  lines: string[],
+  op: Operation,
+  plan: any,
+  method: string,
+  serviceProp: string,
+  modelMap: Map<string, Model>,
+): void {
+  const itemModelName = op.pagination?.itemType.kind === 'model' ? op.pagination.itemType.name : 'Item';
+
+  lines.push("    it('returns paginated results', async () => {");
+  lines.push(`      fetchOnce(list${itemModelName}Fixture);`);
+  lines.push('');
+  lines.push(`      const { data, listMetadata } = await workos.${serviceProp}.${method}();`);
+  lines.push('');
+  lines.push(`      expect(fetchURL()).toContain('${op.path.split('{')[0]}');`);
+  lines.push("      expect(fetchSearchParams()).toHaveProperty('order');");
+  lines.push('      expect(Array.isArray(data)).toBe(true);');
+  lines.push('      expect(listMetadata).toBeDefined();');
+
+  // Assert on first item fields when item model is available
+  const itemModel = modelMap.get(itemModelName);
+  if (itemModel) {
+    const assertions = buildFieldAssertions(itemModel, 'data[0]');
+    if (assertions.length > 0) {
+      lines.push('      expect(data.length).toBeGreaterThan(0);');
+      for (const assertion of assertions) {
+        lines.push(`      ${assertion}`);
+      }
+    }
+  }
+
+  lines.push('    });');
+}
+
+function renderDeleteTest(lines: string[], op: Operation, method: string, serviceProp: string): void {
+  const hasPathParam = op.pathParams.length > 0;
+  const args = hasPathParam ? "'test_id'" : '';
+
+  lines.push("    it('sends a DELETE request', async () => {");
+  lines.push('      fetchOnce({}, { status: 204 });');
+  lines.push('');
+  lines.push(`      await workos.${serviceProp}.${method}(${args});`);
+  lines.push('');
+  lines.push(`      expect(fetchURL()).toContain('${op.path.split('{')[0]}');`);
+  if (hasPathParam) {
+    lines.push("      expect(fetchURL()).toContain('test_id');");
+  }
+  lines.push('    });');
+}
+
+function renderBodyTest(
+  lines: string[],
+  op: Operation,
+  plan: any,
+  method: string,
+  serviceProp: string,
+  modelMap: Map<string, Model>,
+): void {
+  const responseModelName = plan.responseModelName!;
+  const fixture = `${toCamelCase(responseModelName)}Fixture`;
+  const hasPathParam = op.pathParams.length > 0;
+  const pathArg = hasPathParam ? "'test_id', " : '';
+
+  lines.push("    it('sends the correct request and returns result', async () => {");
+  lines.push(`      fetchOnce(${fixture});`);
+  lines.push('');
+  lines.push(`      const result = await workos.${serviceProp}.${method}(${pathArg}{});`);
+  lines.push('');
+  lines.push(`      expect(fetchURL()).toContain('${op.path.split('{')[0]}');`);
+  if (hasPathParam) {
+    lines.push("      expect(fetchURL()).toContain('test_id');");
+  }
+  lines.push('      expect(fetchBody()).toBeDefined();');
+  lines.push('      expect(result).toBeDefined();');
+
+  // Response field assertions
+  const responseModel = modelMap.get(responseModelName);
+  if (responseModel) {
+    const assertions = buildFieldAssertions(responseModel, 'result');
+    for (const assertion of assertions) {
+      lines.push(`      ${assertion}`);
+    }
+  }
+
+  lines.push('    });');
+}
+
+function renderGetTest(
+  lines: string[],
+  op: Operation,
+  plan: any,
+  method: string,
+  serviceProp: string,
+  modelMap: Map<string, Model>,
+): void {
+  const responseModelName = plan.responseModelName!;
+  const fixture = `${toCamelCase(responseModelName)}Fixture`;
+  const hasPathParam = op.pathParams.length > 0;
+  const args = hasPathParam ? "'test_id'" : '';
+
+  lines.push("    it('returns the expected result', async () => {");
+  lines.push(`      fetchOnce(${fixture});`);
+  lines.push('');
+  lines.push(`      const result = await workos.${serviceProp}.${method}(${args});`);
+  lines.push('');
+  lines.push(`      expect(fetchURL()).toContain('${op.path.split('{')[0]}');`);
+  if (hasPathParam) {
+    lines.push("      expect(fetchURL()).toContain('test_id');");
+  }
+  lines.push('      expect(result).toBeDefined();');
+
+  // Response field assertions
+  const responseModel = modelMap.get(responseModelName);
+  if (responseModel) {
+    const assertions = buildFieldAssertions(responseModel, 'result');
+    for (const assertion of assertions) {
+      lines.push(`      ${assertion}`);
+    }
+  }
+
+  lines.push('    });');
+}
+
+function renderVoidTest(lines: string[], op: Operation, method: string, serviceProp: string): void {
+  const hasPathParam = op.pathParams.length > 0;
+  const args = hasPathParam ? "'test_id'" : '';
+
+  lines.push("    it('sends the request', async () => {");
+  lines.push('      fetchOnce({});');
+  lines.push('');
+  lines.push(`      await workos.${serviceProp}.${method}(${args});`);
+  lines.push('');
+  lines.push(`      expect(fetchURL()).toContain('${op.path.split('{')[0]}');`);
+  if (hasPathParam) {
+    lines.push("      expect(fetchURL()).toContain('test_id');");
+  }
+  lines.push('    });');
+}
+
+function renderErrorTest(lines: string[], op: Operation, plan: any, method: string, serviceProp: string): void {
+  const hasPathParam = op.pathParams.length > 0;
+  const isPaginated = plan.isPaginated;
+  const hasBody = plan.hasBody;
+
+  let args: string;
+  if (isPaginated) {
+    args = '';
+  } else if (hasBody && hasPathParam) {
+    args = "'test_id', {}";
+  } else if (hasBody) {
+    args = '{}';
+  } else if (hasPathParam) {
+    args = "'test_id'";
+  } else {
+    args = '';
+  }
+
+  lines.push('');
+  lines.push("    it('throws on unauthorized', async () => {");
+  lines.push("      fetchOnce({ message: 'Unauthorized' }, { status: 401 });");
+  lines.push('');
+  lines.push(`      await expect(workos.${serviceProp}.${method}(${args})).rejects.toThrow();`);
+  lines.push('    });');
+}
+
+/**
+ * Build field-level assertions for top-level primitive fields of a response model.
+ * Returns lines like: expect(result.fieldName).toBe(fixtureValue);
+ */
+function buildFieldAssertions(model: Model, accessor: string): string[] {
+  const assertions: string[] = [];
+
+  for (const field of model.fields) {
+    if (!field.required) continue;
+    const value = fixtureValueForType(field.type, field.name);
+    if (value === null) continue;
+    const domainField = fieldName(field.name);
+    assertions.push(`expect(${accessor}.${domainField}).toBe(${value});`);
+  }
+
+  return assertions;
+}
+
+/**
+ * Return a JS literal string for the expected fixture value of a primitive field.
+ * Returns null for non-primitive or complex types (arrays, models, etc.).
+ */
+function fixtureValueForType(ref: TypeRef, name: string): string | null {
+  switch (ref.kind) {
+    case 'primitive':
+      return fixtureValueForPrimitive(ref.type, ref.format, name);
+    case 'literal':
+      return typeof ref.value === 'string' ? `'${ref.value}'` : String(ref.value);
+    default:
+      return null;
+  }
+}
+
+function fixtureValueForPrimitive(type: string, format: string | undefined, name: string): string | null {
+  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 `'${wireFieldName(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_${wireFieldName(name)}'`;
+    case 'integer':
+      return '1';
+    case 'number':
+      return '1';
+    case 'boolean':
+      return 'true';
+    default:
+      return null;
+  }
+}

package/src/node/type-map.ts

@@ -0,0 +1,56 @@
+import type { TypeRef, PrimitiveType } from '@workos/oagen';
+import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
+import { wireInterfaceName } from './naming.js';
+
+/**
+ * Map an IR TypeRef to a TypeScript domain type string.
+ * Domain types use PascalCase model names (e.g., `Organization`).
+ */
+export function mapTypeRef(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+    model: (r) => r.name,
+    enum: (r) => r.name,
+    union: (_r, variants) => variants.join(' | '),
+    nullable: (_r, inner) => `${inner} | null`,
+    literal: (r) => (typeof r.value === 'string' ? `'${r.value}'` : String(r.value)),
+    map: (_r, value) => `Record<string, ${value}>`,
+  });
+}
+
+/**
+ * Map an IR TypeRef to a TypeScript wire/response type string.
+ * Model references get the `Response` suffix (e.g., `OrganizationResponse`).
+ */
+export function mapWireTypeRef(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+    model: (r) => wireInterfaceName(r.name),
+    enum: (r) => r.name,
+    union: (_r, variants) => variants.join(' | '),
+    nullable: (_r, inner) => `${inner} | null`,
+    literal: (r) => (typeof r.value === 'string' ? `'${r.value}'` : String(r.value)),
+    map: (_r, value) => `Record<string, ${value}>`,
+  });
+}
+
+function mapPrimitive(ref: PrimitiveType): string {
+  switch (ref.type) {
+    case 'string':
+      return 'string';
+    case 'integer':
+    case 'number':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'unknown':
+      return 'any';
+  }
+}
+
+/** Wrap union types in parentheses when used as array item type. */
+function parenthesizeUnion(type: string): string {
+  return type.includes(' | ') ? `(${type})` : type;
+}

package/src/node/utils.ts

@@ -0,0 +1,164 @@
+import type { Model, Service, TypeRef } from '@workos/oagen';
+import { walkTypeRef } from '@workos/oagen';
+
+/**
+ * Collect all model names referenced (directly or transitively) by a TypeRef.
+ */
+export function collectModelRefs(ref: TypeRef): string[] {
+  const names: string[] = [];
+  walkTypeRef(ref, { model: (r) => names.push(r.name) });
+  return names;
+}
+
+/**
+ * Collect all enum names referenced by a TypeRef.
+ */
+export function collectEnumRefs(ref: TypeRef): string[] {
+  const names: string[] = [];
+  walkTypeRef(ref, { enum: (r) => names.push(r.name) });
+  return names;
+}
+
+/**
+ * Assign each model to the service that first references it.
+ * Models referenced by multiple services are assigned to the first.
+ * Models not referenced by any service are unassigned (returned as undefined).
+ */
+export function assignModelsToServices(models: Model[], services: Service[]): Map<string, string> {
+  const modelToService = new Map<string, string>();
+  const modelNames = new Set(models.map((m) => m.name));
+
+  for (const service of services) {
+    const referencedModels = new Set<string>();
+
+    // Collect directly referenced models from all operations
+    for (const op of service.operations) {
+      if (op.requestBody) {
+        for (const name of collectModelRefs(op.requestBody)) {
+          referencedModels.add(name);
+        }
+      }
+      for (const name of collectModelRefs(op.response)) {
+        referencedModels.add(name);
+      }
+      for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
+        for (const name of collectModelRefs(param.type)) {
+          referencedModels.add(name);
+        }
+      }
+      if (op.pagination) {
+        for (const name of collectModelRefs(op.pagination.itemType)) {
+          referencedModels.add(name);
+        }
+      }
+    }
+
+    // Transitively collect models referenced by the directly-referenced models
+    const toVisit = [...referencedModels];
+    while (toVisit.length > 0) {
+      const name = toVisit.pop()!;
+      const model = models.find((m) => m.name === name);
+      if (!model) continue;
+      for (const field of model.fields) {
+        for (const ref of collectModelRefs(field.type)) {
+          if (!referencedModels.has(ref) && modelNames.has(ref)) {
+            referencedModels.add(ref);
+            toVisit.push(ref);
+          }
+        }
+      }
+    }
+
+    // Assign models to this service (first-come)
+    for (const name of referencedModels) {
+      if (!modelToService.has(name)) {
+        modelToService.set(name, service.name);
+      }
+    }
+  }
+
+  return modelToService;
+}
+
+/**
+ * Collect all TypeRef-referenced model and enum names from a model's fields.
+ * Returns { models, enums } sets for generating import statements.
+ */
+export function collectFieldDependencies(model: Model): {
+  models: Set<string>;
+  enums: Set<string>;
+} {
+  const models = new Set<string>();
+  const enums = new Set<string>();
+
+  for (const field of model.fields) {
+    for (const name of collectModelRefs(field.type)) {
+      if (name !== model.name) models.add(name);
+    }
+    for (const name of collectEnumRefs(field.type)) {
+      enums.add(name);
+    }
+  }
+
+  return { models, enums };
+}
+
+/**
+ * Compute a relative import path between two files within the generated SDK.
+ * Strips .ts extension from the result.
+ */
+export function relativeImport(fromFile: string, toFile: string): string {
+  const fromDir = fromFile.split('/').slice(0, -1);
+  const toFileParts = toFile.split('/');
+  const toDir = toFileParts.slice(0, -1);
+  const toFileName = toFileParts[toFileParts.length - 1];
+
+  let common = 0;
+  while (common < fromDir.length && common < toDir.length && fromDir[common] === toDir[common]) {
+    common++;
+  }
+
+  const ups = fromDir.length - common;
+  const downs = toDir.slice(common);
+  const parts = [...Array(ups).fill('..'), ...downs, toFileName];
+  let result = parts.join('/');
+  result = result.replace(/\.ts$/, '');
+  if (!result.startsWith('.')) result = './' + result;
+  return result;
+}
+
+/**
+ * Render a JSDoc comment block from a description string.
+ * Handles multiline descriptions by prefixing each line with ` * `.
+ * Returns the lines with the given indent (default 0 spaces).
+ */
+export function docComment(description: string, indent = 0): string[] {
+  const pad = ' '.repeat(indent);
+  const descLines = description.split('\n');
+  if (descLines.length === 1) {
+    return [`${pad}/** ${descLines[0]} */`];
+  }
+  const lines: string[] = [`${pad}/**`];
+  for (const line of descLines) {
+    lines.push(line === '' ? `${pad} *` : `${pad} * ${line}`);
+  }
+  lines.push(`${pad} */`);
+  return lines;
+}
+
+/**
+ * Collect all model names referenced as request bodies across all services.
+ */
+export function collectRequestBodyModels(services: Service[]): Set<string> {
+  const result = new Set<string>();
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (op.requestBody) {
+        for (const name of collectModelRefs(op.requestBody)) {
+          result.add(name);
+        }
+      }
+    }
+  }
+  return result;
+}

package/test/compat/extractors/node.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect } from 'vitest';
+import { nodeExtractor } from '../../../src/compat/extractors/node.js';
+import { resolve } from 'node:path';
+
+const fixturePath = resolve(__dirname, '../../fixtures/sample-sdk-node');
+
+describe('nodeExtractor', () => {
+  it('extracts classes with methods and properties', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.classes).toHaveProperty('WorkOSClient');
+    const client = surface.classes['WorkOSClient'];
+
+    expect(client.methods).toHaveProperty('getOrganization');
+    expect(client.methods).toHaveProperty('listOrganizations');
+    expect(client.methods).toHaveProperty('deleteOrganization');
+
+    expect(client.properties).toHaveProperty('baseURL');
+    expect(client.properties['baseURL'].readonly).toBe(true);
+  });
+
+  it('extracts method params and return types', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+    const client = surface.classes['WorkOSClient'];
+
+    const getOrg = client.methods['getOrganization'][0];
+    expect(getOrg.params).toMatchObject([{ name: 'id', type: 'string', optional: false }]);
+    expect(getOrg.returnType).toBe('Promise<Organization>');
+    expect(getOrg.async).toBe(true);
+  });
+
+  it('extracts optional params', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+    const client = surface.classes['WorkOSClient'];
+
+    const listOrgs = client.methods['listOrganizations'][0];
+    expect(listOrgs.params).toMatchObject([{ name: 'limit', type: 'number | undefined', optional: true }]);
+  });
+
+  it('extracts delete method returning void', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+    const client = surface.classes['WorkOSClient'];
+
+    const deleteOrg = client.methods['deleteOrganization'][0];
+    expect(deleteOrg.returnType).toBe('Promise<void>');
+  });
+
+  it('extracts constructor params', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+    const client = surface.classes['WorkOSClient'];
+
+    expect(client.constructorParams).toMatchObject([{ name: 'options', type: 'WorkOSOptions', optional: false }]);
+  });
+
+  it('extracts interfaces with fields', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.interfaces).toHaveProperty('Organization');
+    const org = surface.interfaces['Organization'];
+    expect(org.fields).toHaveProperty('id');
+    expect(org.fields).toHaveProperty('name');
+    expect(org.fields).toHaveProperty('createdAt');
+    expect(org.fields['id'].type).toBe('string');
+  });
+
+  it('extracts wire response interface', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.interfaces).toHaveProperty('OrganizationResponse');
+    const resp = surface.interfaces['OrganizationResponse'];
+    expect(resp.fields).toHaveProperty('created_at');
+  });
+
+  it('extracts interfaces with optional fields', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.interfaces).toHaveProperty('WorkOSOptions');
+    const opts = surface.interfaces['WorkOSOptions'];
+    expect(opts.fields['apiKey'].optional).toBe(false);
+    expect(opts.fields['baseUrl'].optional).toBe(true);
+  });
+
+  it('extracts generic interfaces', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.interfaces).toHaveProperty('ListResponse');
+    const listResp = surface.interfaces['ListResponse'];
+    expect(listResp.fields).toHaveProperty('data');
+    expect(listResp.fields).toHaveProperty('hasMore');
+  });
+
+  it('extracts type aliases', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.typeAliases).toHaveProperty('StatusType');
+    expect(surface.typeAliases['StatusType'].value).toMatchInlineSnapshot(`""active" | "inactive""`);
+  });
+
+  it('extracts enums', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.enums).toHaveProperty('Status');
+    expect(surface.enums['Status'].members).toMatchObject({
+      Active: 'active',
+      Inactive: 'inactive',
+    });
+  });
+
+  it('builds export map', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    // Entry point should list all exported symbols
+    const entryExports = Object.values(surface.exports).flat();
+    expect(entryExports).toContain('WorkOSClient');
+    expect(entryExports).toContain('Organization');
+    expect(entryExports).toContain('Status');
+    expect(entryExports).toContain('StatusType');
+  });
+
+  it('sets metadata correctly', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+
+    expect(surface.language).toBe('node');
+    expect(surface.extractedFrom).toBe(fixturePath);
+    expect(surface.extractedAt).toBeTruthy();
+  });
+
+  it('produces deterministic output', async () => {
+    const surface1 = await nodeExtractor.extract(fixturePath);
+    const surface2 = await nodeExtractor.extract(fixturePath);
+
+    // Normalize timestamps for comparison
+    surface1.extractedAt = '';
+    surface2.extractedAt = '';
+
+    expect(JSON.stringify(surface1)).toBe(JSON.stringify(surface2));
+  });
+
+  it('does not extract private members', async () => {
+    const surface = await nodeExtractor.extract(fixturePath);
+    const client = surface.classes['WorkOSClient'];
+
+    expect(client.properties).not.toHaveProperty('apiKey');
+  });
+});