@workos/oagen-emitters 0.0.1 → 0.2.1

package/test/node/serializers.test.ts

@@ -15,7 +15,6 @@ const ctx: EmitterContext = {
   namespace: 'workos',
   namespacePascal: 'WorkOS',
   spec: emptySpec,
-  irVersion: 6,
 };
 
 describe('generateSerializers', () => {
@@ -31,7 +30,13 @@ describe('generateSerializers', () => {
           name: 'getOrganization',
           httpMethod: 'get',
           path: '/organizations/{id}',
-          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          pathParams: [
+            {
+              name: 'id',
+              type: { kind: 'primitive', type: 'string' },
+              required: true,
+            },
+          ],
           queryParams: [],
           headerParams: [],
           response: { kind: 'model', name: 'Organization' },
@@ -78,8 +83,8 @@ describe('generateSerializers', () => {
 
     const content = files[0].content;
     expect(content).toContain('export const deserializeOrganization');
-    expect(content).toContain("  id: response.id ?? '',");
-    expect(content).toContain("  createdAt: response.created_at ?? '',");
+    expect(content).toContain('  id: response.id,');
+    expect(content).toContain('  createdAt: new Date(response.created_at),');
     expect(content).toContain('  externalId: response.external_id ?? null,');
   });
 
@@ -91,7 +96,13 @@ describe('generateSerializers', () => {
           name: 'getOrganization',
           httpMethod: 'get',
           path: '/organizations/{id}',
-          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          pathParams: [
+            {
+              name: 'id',
+              type: { kind: 'primitive', type: 'string' },
+              required: true,
+            },
+          ],
           queryParams: [],
           headerParams: [],
           response: { kind: 'model', name: 'Organization' },
@@ -144,6 +155,83 @@ describe('generateSerializers', () => {
     expect(orgSerializer.content).toContain('import { deserializeOrganizationDomain, serializeOrganizationDomain }');
   });
 
+  it('preserves null fallback for optional nullable model fields', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [
+            {
+              name: 'id',
+              type: { kind: 'primitive', type: 'string' },
+              required: true,
+            },
+          ],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'parent',
+            type: {
+              kind: 'nullable',
+              inner: { kind: 'model', name: 'ParentOrg' },
+            },
+            required: false,
+          },
+        ],
+      },
+      {
+        name: 'ParentOrg',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateSerializers(models, ctxWithServices);
+    const orgSerializer = files.find((f) => f.path.includes('organization.serializer.ts'))!;
+    const content = orgSerializer.content;
+
+    // Deserialize: optional nullable model field should fall back to null, not undefined
+    expect(content).toContain('parent: response.parent != null ?');
+    expect(content).toContain(': null,');
+    expect(content).not.toMatch(/parent:.*: undefined,/);
+
+    // Serialize: optional nullable model field should fall back to null, not undefined
+    expect(content).toContain('parent: model.parent != null ?');
+    // Ensure the serialize side also uses null fallback
+    const serializeSection = content.split('serializeOrganization')[1];
+    expect(serializeSection).toContain(': null,');
+    expect(serializeSection).not.toMatch(/parent:.*: undefined/);
+  });
+
   it('generates serialize function for request body models', () => {
     const service: Service = {
       name: 'Organizations',
@@ -203,4 +291,152 @@ describe('generateSerializers', () => {
     expect(inputSerializer.content).toContain('export const deserializeCreateOrganizationInput');
     expect(inputSerializer.content).toContain('export const serializeCreateOrganizationInput');
   });
+
+  it('skips per-domain ListMetadata serializers (Fix #5)', () => {
+    const service: Service = {
+      name: 'Connections',
+      operations: [
+        {
+          name: 'listConnections',
+          httpMethod: 'get',
+          path: '/connections',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'ConnectionList' },
+          errors: [],
+          injectIdempotencyKey: false,
+          pagination: {
+            strategy: 'cursor',
+            param: 'after',
+            itemType: { kind: 'model', name: 'Connection' },
+          },
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'ConnectionListListMetadata',
+        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,
+          },
+        ],
+      },
+      {
+        name: 'Connection',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateSerializers(models, ctxWithServices);
+
+    // The ListMetadata serializer should be skipped
+    const listMetadataSerializer = files.find((f) => f.path.includes('list-metadata'));
+    expect(listMetadataSerializer).toBeUndefined();
+
+    // The Connection serializer should still be generated
+    const connectionSerializer = files.find((f) => f.path.includes('connection.serializer.ts'));
+    expect(connectionSerializer).toBeDefined();
+  });
+
+  it('skips per-domain list wrapper serializers (Fix #7)', () => {
+    const service: Service = {
+      name: 'Connections',
+      operations: [
+        {
+          name: 'listConnections',
+          httpMethod: 'get',
+          path: '/connections',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'ConnectionList' },
+          errors: [],
+          injectIdempotencyKey: false,
+          pagination: {
+            strategy: 'cursor',
+            param: 'after',
+            itemType: { kind: 'model', name: 'Connection' },
+          },
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'ConnectionList',
+        fields: [
+          {
+            name: 'object',
+            type: { kind: 'literal', value: 'list' },
+            required: true,
+          },
+          {
+            name: 'data',
+            type: {
+              kind: 'array',
+              items: { kind: 'model', name: 'Connection' },
+            },
+            required: true,
+          },
+          {
+            name: 'list_metadata',
+            type: { kind: 'model', name: 'ConnectionListListMetadata' },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'Connection',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateSerializers(models, ctxWithServices);
+
+    // The list wrapper serializer should be skipped
+    const listSerializer = files.find((f) => f.path.includes('connection-list.serializer.ts'));
+    expect(listSerializer).toBeUndefined();
+
+    // The Connection serializer should still be generated
+    const connectionSerializer = files.find((f) => f.path.includes('connection.serializer.ts'));
+    expect(connectionSerializer).toBeDefined();
+  });
 });

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
+    "target": "ES2024",
     "module": "ESNext",
     "moduleResolution": "bundler",
     "strict": true,
@@ -12,8 +12,7 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true
+    "resolveJsonModule": true
   },
   "include": ["src", "test"],
   "exclude": ["node_modules", "dist"]

package/{tsup.config.ts → tsdown.config.ts}

@@ -1,4 +1,4 @@
-import { defineConfig } from 'tsup';
+import { defineConfig } from 'tsdown';
 export default defineConfig({
   entry: { index: 'src/index.ts' },
   format: ['esm'],

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-import { Emitter } from '@workos/oagen';
-
-declare const nodeEmitter: Emitter;
-
-export { nodeEmitter };