@workos/oagen-emitters 0.14.1 → 0.14.2

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);
+  });
+});