@workos/oagen-emitters 0.0.1

package/test/node/resources.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect } from 'vitest';
+import { generateResources } from '../../src/node/resources.js';
+import type { EmitterContext, ApiSpec, Service } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+  irVersion: 6,
+};
+
+describe('generateResources', () => {
+  it('returns empty for no services', () => {
+    expect(generateResources([], ctx)).toEqual([]);
+  });
+
+  it('generates a resource class with GET method', () => {
+    const services: 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 files = generateResources(services, ctx);
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('src/organizations/organizations.ts');
+
+    const content = files[0].content;
+    expect(content).toContain('export class Organizations {');
+    expect(content).toContain('constructor(private readonly workos: WorkOS) {}');
+    expect(content).toContain('async getOrganization(id: string): Promise<Organization>');
+    expect(content).toContain('deserializeOrganization(data)');
+  });
+
+  it('generates paginated list method', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [
+              {
+                name: 'domains',
+                type: { kind: 'array', items: { kind: 'primitive', type: 'string' } },
+                required: false,
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'Organization' },
+            errors: [],
+            pagination: {
+              cursorParam: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+
+    // Should have AutoPaginatable imports
+    expect(content).toContain('import { AutoPaginatable }');
+    expect(content).toContain('import { fetchAndDeserialize }');
+
+    // Should generate options interface
+    expect(content).toContain('export interface ListOrganizationsOptions extends PaginationOptions {');
+    expect(content).toContain('domains?: string[];');
+
+    // Should return AutoPaginatable
+    expect(content).toContain('Promise<AutoPaginatable<Organization, ListOrganizationsOptions>>');
+  });
+
+  it('generates DELETE method returning void', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'deleteOrganization',
+            httpMethod: 'delete',
+            path: '/organizations/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+    expect(content).toContain('async deleteOrganization(id: string): Promise<void>');
+    expect(content).toContain('await this.workos.delete(');
+  });
+
+  it('generates POST method with body and idempotency', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'createOrganization',
+            httpMethod: 'post',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateOrganizationInput' },
+            response: { kind: 'model', name: 'Organization' },
+            errors: [],
+            injectIdempotencyKey: true,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+    expect(content).toContain(
+      'async createOrganization(payload: CreateOrganizationInput, requestOptions: PostOptions = {}): Promise<Organization>',
+    );
+    expect(content).toContain('serializeCreateOrganizationInput(payload)');
+    expect(content).toContain('requestOptions,');
+  });
+
+  it('uses overlay-resolved name for output path and class', () => {
+    const mfaService: Service = {
+      name: 'MultiFactorAuth',
+      operations: [
+        {
+          name: 'enrollFactor',
+          httpMethod: 'post',
+          path: '/auth/factors/enroll',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          requestBody: { kind: 'model', name: 'EnrollFactorInput' },
+          response: { kind: 'model', name: 'AuthenticationFactor' },
+          errors: [],
+          injectIdempotencyKey: true,
+        },
+      ],
+    };
+
+    const overlayCtx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, services: [mfaService], models: [] },
+      irVersion: 6,
+      overlayLookup: {
+        methodByOperation: new Map([
+          [
+            'POST /auth/factors/enroll',
+            { className: 'Mfa', methodName: 'enrollFactor', params: [], returnType: 'void' },
+          ],
+        ]),
+        httpKeyByMethod: new Map(),
+        interfaceByName: new Map(),
+        typeAliasByName: new Map(),
+        requiredExports: new Map(),
+        modelNameByIR: new Map(),
+        fileBySymbol: new Map(),
+      },
+    };
+
+    const files = generateResources([mfaService], overlayCtx);
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('src/mfa/mfa.ts');
+
+    const content = files[0].content;
+    expect(content).toContain('export class Mfa {');
+  });
+
+  it('renders multiline description and @deprecated in method docstring', () => {
+    const services: Service[] = [
+      {
+        name: 'Radar',
+        operations: [
+          {
+            name: 'updateAttempt',
+            description: 'Update a Radar attempt\n\nYou may optionally inform Radar that an attempt was successful.',
+            httpMethod: 'put',
+            path: '/radar/attempts/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+                description: 'The unique identifier of the attempt.',
+              },
+            ],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'UpdateAttemptInput' },
+            response: { kind: 'model', name: 'RadarAttempt' },
+            errors: [],
+            injectIdempotencyKey: false,
+            deprecated: true,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+
+    expect(content).toContain('  /**');
+    expect(content).toContain('   * Update a Radar attempt');
+    expect(content).toContain('   *');
+    expect(content).toContain('   * You may optionally inform Radar that an attempt was successful.');
+    expect(content).toContain('   * @param id - The unique identifier of the attempt.');
+    expect(content).toContain('   * @deprecated');
+    expect(content).toContain('   */');
+  });
+});

package/test/node/serializers.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect } from 'vitest';
+import { generateSerializers } from '../../src/node/serializers.js';
+import type { EmitterContext, ApiSpec, Model, Service } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+  irVersion: 6,
+};
+
+describe('generateSerializers', () => {
+  it('returns empty for no models', () => {
+    expect(generateSerializers([], ctx)).toEqual([]);
+  });
+
+  it('generates deserializer with camelCase→snake_case mapping', () => {
+    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: 'created_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+          },
+          {
+            name: 'external_id',
+            type: {
+              kind: 'nullable',
+              inner: { kind: 'primitive', type: 'string' },
+            },
+            required: false,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateSerializers(models, ctxWithServices);
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('src/organizations/serializers/organization.serializer.ts');
+
+    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('  externalId: response.external_id ?? null,');
+  });
+
+  it('generates nested model deserialization', () => {
+    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: 'domains',
+            type: {
+              kind: 'array',
+              items: { kind: 'model', name: 'OrganizationDomain' },
+            },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'OrganizationDomain',
+        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'))!;
+
+    expect(orgSerializer.content).toContain('domains: response.domains.map(deserializeOrganizationDomain),');
+    expect(orgSerializer.content).toContain('import { deserializeOrganizationDomain, serializeOrganizationDomain }');
+  });
+
+  it('generates serialize function for request body models', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'createOrganization',
+          httpMethod: 'post',
+          path: '/organizations',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          requestBody: { kind: 'model', name: 'CreateOrganizationInput' },
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'CreateOrganizationInput',
+        fields: [
+          {
+            name: 'name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'external_id',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateSerializers(models, ctxWithServices);
+    const inputSerializer = files.find((f) => f.path.includes('create-organization-input.serializer.ts'))!;
+
+    // Should have both deserialize AND serialize
+    expect(inputSerializer.content).toContain('export const deserializeCreateOrganizationInput');
+    expect(inputSerializer.content).toContain('export const serializeCreateOrganizationInput');
+  });
+});

package/test/node/type-map.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest';
+import { mapTypeRef, mapWireTypeRef } from '../../src/node/type-map.js';
+import type { TypeRef } from '@workos/oagen';
+
+describe('mapTypeRef', () => {
+  it('maps primitive string', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'string' };
+    expect(mapTypeRef(ref)).toBe('string');
+  });
+
+  it('maps primitive integer to number', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'integer' };
+    expect(mapTypeRef(ref)).toBe('number');
+  });
+
+  it('maps primitive boolean', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'boolean' };
+    expect(mapTypeRef(ref)).toBe('boolean');
+  });
+
+  it('maps unknown to any', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'unknown' };
+    expect(mapTypeRef(ref)).toBe('any');
+  });
+
+  it('maps array of strings', () => {
+    const ref: TypeRef = {
+      kind: 'array',
+      items: { kind: 'primitive', type: 'string' },
+    };
+    expect(mapTypeRef(ref)).toBe('string[]');
+  });
+
+  it('maps model reference', () => {
+    const ref: TypeRef = { kind: 'model', name: 'Organization' };
+    expect(mapTypeRef(ref)).toBe('Organization');
+  });
+
+  it('maps enum reference', () => {
+    const ref: TypeRef = { kind: 'enum', name: 'Status' };
+    expect(mapTypeRef(ref)).toBe('Status');
+  });
+
+  it('maps nullable type', () => {
+    const ref: TypeRef = {
+      kind: 'nullable',
+      inner: { kind: 'primitive', type: 'string' },
+    };
+    expect(mapTypeRef(ref)).toBe('string | null');
+  });
+
+  it('maps union type', () => {
+    const ref: TypeRef = {
+      kind: 'union',
+      variants: [
+        { kind: 'primitive', type: 'string' },
+        { kind: 'primitive', type: 'number' },
+      ],
+    };
+    expect(mapTypeRef(ref)).toBe('string | number');
+  });
+
+  it('maps map type', () => {
+    const ref: TypeRef = {
+      kind: 'map',
+      valueType: { kind: 'primitive', type: 'string' },
+    };
+    expect(mapTypeRef(ref)).toBe('Record<string, string>');
+  });
+
+  it('maps literal string', () => {
+    const ref: TypeRef = { kind: 'literal', value: 'organization' };
+    expect(mapTypeRef(ref)).toBe("'organization'");
+  });
+
+  it('maps literal number', () => {
+    const ref: TypeRef = { kind: 'literal', value: 42 };
+    expect(mapTypeRef(ref)).toBe('42');
+  });
+
+  it('parenthesizes union in array', () => {
+    const ref: TypeRef = {
+      kind: 'array',
+      items: {
+        kind: 'union',
+        variants: [
+          { kind: 'primitive', type: 'string' },
+          { kind: 'primitive', type: 'number' },
+        ],
+      },
+    };
+    expect(mapTypeRef(ref)).toBe('(string | number)[]');
+  });
+});
+
+describe('mapWireTypeRef', () => {
+  it('maps model reference with Response suffix', () => {
+    const ref: TypeRef = { kind: 'model', name: 'Organization' };
+    expect(mapWireTypeRef(ref)).toBe('OrganizationResponse');
+  });
+
+  it('maps array of models with Response suffix', () => {
+    const ref: TypeRef = {
+      kind: 'array',
+      items: { kind: 'model', name: 'OrganizationDomain' },
+    };
+    expect(mapWireTypeRef(ref)).toBe('OrganizationDomainResponse[]');
+  });
+
+  it('keeps primitives unchanged', () => {
+    const ref: TypeRef = { kind: 'primitive', type: 'string' };
+    expect(mapWireTypeRef(ref)).toBe('string');
+  });
+
+  it('keeps enum references unchanged', () => {
+    const ref: TypeRef = { kind: 'enum', name: 'Status' };
+    expect(mapWireTypeRef(ref)).toBe('Status');
+  });
+
+  it('maps nullable model with Response suffix', () => {
+    const ref: TypeRef = {
+      kind: 'nullable',
+      inner: { kind: 'model', name: 'Organization' },
+    };
+    expect(mapWireTypeRef(ref)).toBe('OrganizationResponse | null');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src", "test"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+export default defineConfig({
+  entry: { index: 'src/index.ts' },
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  target: 'node20',
+});

package/vitest.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: { globals: true, include: ['test/**/*.test.ts'] },
+});