@workos/oagen-emitters 0.14.1 → 0.14.3

package/src/shared/model-utils.ts

@@ -1,5 +1,5 @@
 import type { Model, Field, TypeRef, Enum, Service } from '@workos/oagen';
-import { toSnakeCase, toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
+import { collectFieldDependencies, toSnakeCase, toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 // @ts-ignore -- js-yaml has no type declarations in this project
@@ -72,6 +72,41 @@ export function isListMetadataModel(model: Model): boolean {
   return isNullableString(before) && isNullableString(after);
 }
 
+/**
+ * Compute the `ListMetadata`-shape model names that must still be emitted
+ * because some surviving wrapper references them.
+ *
+ * Each language emitter blanket-skips `isListMetadataModel` models on the
+ * assumption that the SDK's shared pagination wrapper subsumes them. That
+ * is correct for paginated list envelopes (the iterator unwraps the
+ * envelope and `list_metadata` is handled at runtime), but a *non-paginated*
+ * wrapper like vault's `VersionListResponse` still has a
+ * `list_metadata: ListMetadata` field — and skipping emission of
+ * `ListMetadata` leaves the wrapper's interface importing from a file that
+ * was never written.
+ *
+ * Pass the same `nonPaginatedRefs` set the emitter uses for its own
+ * wrapper-survival decision so the two answers stay in sync.
+ */
+export function collectReferencedListMetadataModels(models: Model[], nonPaginatedRefs: Set<string>): Set<string> {
+  const listMetadataNames = new Set<string>();
+  for (const m of models) {
+    if (isListMetadataModel(m)) listMetadataNames.add(m.name);
+  }
+  if (listMetadataNames.size === 0) return new Set();
+
+  const referenced = new Set<string>();
+  for (const model of models) {
+    if (isListMetadataModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
+    const deps = collectFieldDependencies(model);
+    for (const dep of deps.models) {
+      if (listMetadataNames.has(dep)) referenced.add(dep);
+    }
+  }
+  return referenced;
+}
+
 /** Check if a field type is nullable string (nullable<string> or just string). */
 function isNullableString(field: Field): boolean {
   if (field.type.kind === 'primitive' && field.type.type === 'string') return true;

package/test/node/naming.test.ts

@@ -1,7 +1,13 @@
 import { afterEach, describe, expect, it } from 'vitest';
 import type { EmitterContext } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
-import { resolveInterfaceName, setAdoptedModelNames } from '../../src/node/naming.js';
+import {
+  resolveInterfaceName,
+  setAdoptedModelNames,
+  setBaselineInterfaceNames,
+  setStructurallyRenamedDomainNames,
+  wireInterfaceName,
+} from '../../src/node/naming.js';
 
 const ctx: EmitterContext = {
   namespace: 'workos',
@@ -19,6 +25,8 @@ const ctx: EmitterContext = {
 
 afterEach(() => {
   setAdoptedModelNames(new Set());
+  setBaselineInterfaceNames(new Set());
+  setStructurallyRenamedDomainNames(new Set());
 });
 
 describe('resolveInterfaceName', () => {
@@ -75,3 +83,39 @@ describe('resolveInterfaceName', () => {
     expect(result).toBe('CreateM2MApplication');
   });
 });
+
+describe('wireInterfaceName', () => {
+  it('emits *Wire for a fresh `*Response`-named IR model with an empty baseline', () => {
+    expect(wireInterfaceName('CreateDataKeyResponse')).toBe('CreateDataKeyResponseWire');
+  });
+
+  it('returns *Wire even when a prior buggy regen poisoned the baseline with the bare name', () => {
+    // Reproduces the vault regression: `CreateDataKeyResponse` is its own IR
+    // name (no structural rename), so the resolver does not flag it. A prior
+    // broken emission wrote `export interface CreateDataKeyResponse { ... }`
+    // twice into the file, and the baseline now contains the bare name.
+    // Without the rename signal, `wireInterfaceName` must still pick `*Wire`
+    // — otherwise the duplicate emission perpetuates across regens.
+    setBaselineInterfaceNames(new Set(['CreateDataKeyResponse']));
+    expect(wireInterfaceName('CreateDataKeyResponse')).toBe('CreateDataKeyResponseWire');
+  });
+
+  it('uses *Wire when baseline already has a separate `*Wire` companion', () => {
+    setBaselineInterfaceNames(new Set(['DecryptResponse', 'DecryptResponseWire']));
+    expect(wireInterfaceName('DecryptResponse')).toBe('DecryptResponseWire');
+  });
+
+  it('returns the bare name when a structural rename mapped a differently-named IR model onto a baseline `*Response`', () => {
+    // The legitimate single-form case the heuristic was designed for:
+    // `AuditLogSchemaJson` → `AuditLogSchemaResponse` via structural match,
+    // and the baseline owns just the one `AuditLogSchemaResponse` interface
+    // representing the wire shape.
+    setBaselineInterfaceNames(new Set(['AuditLogSchemaResponse']));
+    setStructurallyRenamedDomainNames(new Set(['AuditLogSchemaResponse']));
+    expect(wireInterfaceName('AuditLogSchemaResponse')).toBe('AuditLogSchemaResponse');
+  });
+
+  it('falls back to `${name}Response` for non-`*Response` IR names', () => {
+    expect(wireInterfaceName('Organization')).toBe('OrganizationResponse');
+  });
+});

package/test/node/tests.test.ts

@@ -268,4 +268,73 @@ describe('node test generation ownership', () => {
       fs.rmSync(tmpRoot, { recursive: true, force: true });
     }
   });
+
+  it('asserts toBeNull() for nullable fields whose example is null', () => {
+    // When the spec gives `example: null` on a nullable field — common for
+    // optional date-times like `last_used_at` — the previous emitter would
+    // emit `expect(x.toISOString()).toBe(null)`, which both blows up at
+    // runtime on a null `x` and never matches when `x` is a Date.
+    const secretModel: Model = {
+      name: 'Secret',
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true, example: 'sec_1' },
+        {
+          name: 'last_used_at',
+          type: {
+            kind: 'nullable',
+            inner: { kind: 'primitive', type: 'string', format: 'date-time' },
+          },
+          required: true,
+          example: null,
+        },
+        {
+          name: 'created_at',
+          type: { kind: 'primitive', type: 'string', format: 'date-time' },
+          required: true,
+          example: '2026-01-15T12:00:00.000Z',
+        },
+      ],
+    };
+
+    const showOp = {
+      name: 'showSecret',
+      httpMethod: 'get' as const,
+      path: '/secrets/{id}',
+      pathParams: [{ name: 'id', type: { kind: 'primitive' as const, type: 'string' as const }, required: true }],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'model' as const, name: 'Secret' },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+    const secretService: Service = { name: 'Secrets', operations: [showOp] };
+    const secretSpec: ApiSpec = {
+      ...spec,
+      models: [secretModel],
+      services: [secretService],
+    };
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      fs.mkdirSync(path.join(tmpRoot, 'src', 'secrets', 'fixtures'), { recursive: true });
+      execFileSync('git', ['add', 'src'], { cwd: tmpRoot, stdio: 'ignore' });
+
+      const result = nodeEmitter.generateTests!(secretSpec, {
+        ...ctx,
+        spec: secretSpec,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['Secrets'], regenerateOwnedTests: true },
+      } as EmitterContext);
+
+      const testFile = result.find((f) => f.path === 'src/secrets/secrets.spec.ts');
+      expect(testFile).toBeDefined();
+      const content = testFile!.content;
+      // Null example on a nullable date-time → toBeNull(), not `.toISOString().toBe(null)`.
+      expect(content).toContain('expect(result.lastUsedAt).toBeNull();');
+      expect(content).not.toContain('lastUsedAt.toISOString()).toBe(null)');
+      // Non-null date-time examples still go through `.toISOString()`.
+      expect(content).toContain("expect(result.createdAt.toISOString()).toBe('2026-01-15T12:00:00.000Z');");
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
 });

package/test/shared/model-utils.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import type { Model } from '@workos/oagen';
+import {
+  collectReferencedListMetadataModels,
+  isListMetadataModel,
+  isListWrapperModel,
+} from '../../src/shared/model-utils.js';
+
+const listMetadataModel: Model = {
+  name: 'ListMetadata',
+  fields: [
+    {
+      name: 'before',
+      type: { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } },
+      required: false,
+    },
+    {
+      name: 'after',
+      type: { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } },
+      required: false,
+    },
+  ],
+};
+
+describe('isListMetadataModel', () => {
+  it('matches a two-field nullable-string before/after shape', () => {
+    expect(isListMetadataModel(listMetadataModel)).toBe(true);
+  });
+});
+
+describe('collectReferencedListMetadataModels', () => {
+  it('returns nothing when no surviving wrapper references the model', () => {
+    // A paginated list wrapper that the SDK pagination machinery unwraps —
+    // not in `nonPaginatedRefs`, so it counts as skipped.
+    const paginatedWrapper: Model = {
+      name: 'OrgList',
+      fields: [
+        { name: 'data', type: { kind: 'array', items: { kind: 'model', name: 'Org' } }, required: true },
+        { name: 'list_metadata', type: { kind: 'model', name: 'ListMetadata' }, required: true },
+      ],
+    };
+    const result = collectReferencedListMetadataModels([listMetadataModel, paginatedWrapper], new Set());
+    expect(result.size).toBe(0);
+  });
+
+  it('flags the ListMetadata model when a non-paginated wrapper still references it', () => {
+    // `VersionListResponse` is shaped like a list envelope but the operation
+    // has no pagination params, so it survives the wrapper skip — and its
+    // `list_metadata` field needs the `ListMetadata` interface on disk.
+    const versionWrapper: Model = {
+      name: 'VersionListResponse',
+      fields: [
+        { name: 'data', type: { kind: 'array', items: { kind: 'model', name: 'Version' } }, required: true },
+        { name: 'list_metadata', type: { kind: 'model', name: 'ListMetadata' }, required: true },
+      ],
+    };
+    const result = collectReferencedListMetadataModels(
+      [listMetadataModel, versionWrapper],
+      new Set(['VersionListResponse']),
+    );
+    expect(result.has('ListMetadata')).toBe(true);
+  });
+
+  it('flags the ListMetadata model when a non-wrapper IR model references it directly', () => {
+    // Defensive: should anything else point at a `ListMetadata`-shape model
+    // as a regular field, we still need the file.
+    const customModel: Model = {
+      name: 'Custom',
+      fields: [{ name: 'meta', type: { kind: 'model', name: 'ListMetadata' }, required: true }],
+    };
+    const result = collectReferencedListMetadataModels([listMetadataModel, customModel], new Set());
+    expect(result.has('ListMetadata')).toBe(true);
+  });
+
+  it('returns an empty set when no ListMetadata-shape model exists in the IR', () => {
+    const regular: Model = {
+      name: 'Foo',
+      fields: [{ name: 'bar', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const result = collectReferencedListMetadataModels([regular], new Set());
+    expect(result.size).toBe(0);
+  });
+});
+
+describe('isListWrapperModel + isListMetadataModel — sanity', () => {
+  it('does not classify a wrapper as a metadata model', () => {
+    const wrapper: Model = {
+      name: 'OrgList',
+      fields: [
+        { name: 'data', type: { kind: 'array', items: { kind: 'model', name: 'Org' } }, required: true },
+        { name: 'list_metadata', type: { kind: 'model', name: 'ListMetadata' }, required: true },
+      ],
+    };
+    expect(isListWrapperModel(wrapper)).toBe(true);
+    expect(isListMetadataModel(wrapper)).toBe(false);
+  });
+});