@workos/oagen-emitters 0.3.0 → 0.4.0

package/test/dotnet/resources.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from 'vitest';
+import { generateResources } from '../../src/dotnet/resources.js';
+import { primeEnumAliases } from '../../src/dotnet/enums.js';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+describe('dotnet/resources', () => {
+  it('returns empty for no services', () => {
+    primeEnumAliases([]);
+    expect(generateResources([], ctx)).toEqual([]);
+  });
+
+  it('generates a service class with methods', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+    ];
+
+    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,
+          },
+          {
+            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,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+
+    const serviceFile = files.find((f) => f.path.includes('OrganizationsService.cs'))!;
+    expect(serviceFile).toBeDefined();
+
+    const content = serviceFile.content;
+    // Namespace and class
+    expect(content).toContain('namespace WorkOS');
+    expect(content).toContain('public class OrganizationsService : Service');
+
+    // GET method
+    expect(content).toContain('GetAsync');
+    expect(content).toContain('async Task');
+
+    // DELETE method
+    expect(content).toContain('DeleteAsync');
+  });
+
+  it('generates options classes for operations with params', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      {
+        name: 'CreateOrganizationRequest',
+        fields: [{ name: 'name', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'createOrganization',
+            httpMethod: 'post',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateOrganizationRequest' },
+            response: { kind: 'model', name: 'Organization' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    const optionsFile = files.find((f) => f.path.includes('Options.cs'))!;
+    expect(optionsFile).toBeDefined();
+
+    const content = optionsFile.content;
+    expect(content).toContain('Options');
+    expect(content).toContain('[JsonProperty("name")]');
+    expect(content).toContain('public string Name');
+  });
+
+  it('generates paginated list method with auto-pagination', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'OrganizationList',
+        fields: [
+          {
+            name: 'data',
+            type: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+            required: true,
+          },
+          {
+            name: 'list_metadata',
+            type: { kind: 'model', name: 'ListMetadata' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [
+              { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'OrganizationList' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    const serviceFile = files.find((f) => f.path.includes('OrganizationsService.cs'))!;
+    const content = serviceFile.content;
+
+    // List method (public method name omits Async suffix; return type is async Task)
+    expect(content).toContain('async Task<WorkOSList<Organization>>');
+    expect(content).toContain('List(');
+
+    // Auto-pagination method
+    expect(content).toContain('ListAutoPagingAsync');
+    expect(content).toContain('IAsyncEnumerable<Organization>');
+  });
+
+  it('generates deprecated operations with Obsolete attribute', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    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,
+            deprecated: true,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+    const serviceFile = files.find((f) => f.path.includes('OrganizationsService.cs'))!;
+
+    expect(serviceFile.content).toContain('[System.Obsolete');
+  });
+});

package/test/dotnet/tests.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect } from 'vitest';
+import { generateTests } from '../../src/dotnet/tests.js';
+import { primeEnumAliases } from '../../src/dotnet/enums.js';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const models: Model[] = [
+  {
+    name: 'Organization',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  },
+];
+
+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,
+      },
+      {
+        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 spec: ApiSpec = {
+  name: 'TestAPI',
+  version: '1.0.0',
+  baseUrl: 'https://api.workos.com',
+  services,
+  models,
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+};
+
+describe('dotnet/tests', () => {
+  it('generates per-service test files', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'Tests/OrganizationsServiceTest.cs');
+    expect(testFile).toBeDefined();
+
+    const content = testFile!.content;
+    expect(content).toContain('namespace WorkOSTests');
+    expect(content).toContain('public class OrganizationsServiceTest');
+    expect(content).toContain('HttpMock');
+    expect(content).toContain('[Fact]');
+  });
+
+  it('generates GET operation test with fixture', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'Tests/OrganizationsServiceTest.cs')!;
+    const content = testFile.content;
+
+    expect(content).toContain('TestGet');
+    expect(content).toContain('ReadAllText');
+    expect(content).toContain('MockResponse');
+    expect(content).toContain('Assert.NotNull(result)');
+    expect(content).toContain('AssertRequestWasMade');
+  });
+
+  it('generates DELETE operation test', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'Tests/OrganizationsServiceTest.cs')!;
+    const content = testFile.content;
+
+    expect(content).toContain('TestDelete');
+    expect(content).toContain('HttpMethod.Delete');
+    expect(content).toContain('NoContent');
+  });
+
+  it('generates error tests (401, 404, 422, 429, 500)', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path === 'Tests/OrganizationsServiceTest.cs')!;
+    const content = testFile.content;
+
+    expect(content).toContain('TestError401');
+    expect(content).toContain('AuthenticationError');
+    expect(content).toContain('TestError404');
+    expect(content).toContain('NotFoundError');
+    expect(content).toContain('TestError422');
+    expect(content).toContain('UnprocessableEntityError');
+    expect(content).toContain('TestError429');
+    expect(content).toContain('RateLimitExceededError');
+    expect(content).toContain('TestError500');
+    expect(content).toContain('ServerError');
+  });
+
+  it('generates fixture JSON files', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const fixture = files.find((f) => f.path === 'testdata/organization.json');
+    expect(fixture).toBeDefined();
+    expect(fixture!.headerPlacement).toBe('skip');
+
+    const data = JSON.parse(fixture!.content);
+    expect(data).toHaveProperty('id');
+    expect(data).toHaveProperty('name');
+  });
+
+  it('does not generate static test infrastructure', () => {
+    primeEnumAliases([]);
+    const files = generateTests(spec, ctx);
+    const paths = files.map((f) => f.path);
+
+    // HttpMock and other static helpers are @oagen-ignore-file in target SDK
+    expect(paths.find((p) => p.includes('HttpMock'))).toBeUndefined();
+    expect(paths.find((p) => p.includes('WorkOSClientTest'))).toBeUndefined();
+  });
+
+  it('generates auto-pagination tests for paginated operations', () => {
+    const paginatedModels: Model[] = [
+      ...models,
+      {
+        name: 'OrganizationList',
+        fields: [
+          {
+            name: 'data',
+            type: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+            required: true,
+          },
+          {
+            name: 'list_metadata',
+            type: { kind: 'model', name: 'ListMetadata' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const paginatedServices: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'OrganizationList' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          },
+        ],
+      },
+    ];
+
+    const paginatedSpec: ApiSpec = {
+      ...spec,
+      services: paginatedServices,
+      models: paginatedModels,
+    };
+
+    primeEnumAliases([]);
+    const files = generateTests(paginatedSpec, { ...ctx, spec: paginatedSpec });
+    const testFile = files.find((f) => f.path === 'Tests/OrganizationsServiceTest.cs')!;
+    const content = testFile.content;
+
+    // Auto-paging test
+    expect(content).toContain('AutoPagingAsync');
+    expect(content).toContain('MockSequentialResponses');
+    expect(content).toContain('await foreach');
+  });
+});

package/test/kotlin/models.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { generateModels } from '../../src/kotlin/models.js';
+import { generateEnums } from '../../src/kotlin/enums.js';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+describe('kotlin/models', () => {
+  it('returns empty for no models', () => {
+    generateEnums([], ctx);
+    expect(generateModels([], ctx)).toEqual([]);
+  });
+
+  it('generates a Kotlin data class with Jackson annotations', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', 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,
+          },
+        ],
+      },
+    ];
+
+    generateEnums([], ctx);
+    const files = generateModels(models, { ...ctx, spec: { ...emptySpec, models } });
+
+    expect(files.length).toBeGreaterThanOrEqual(1);
+    const modelFile = files.find((f) => f.path.includes('Organization.kt'))!;
+    expect(modelFile).toBeDefined();
+
+    const content = modelFile.content;
+    expect(content).toContain('data class Organization');
+    expect(content).toContain('@JsonProperty("id")');
+    expect(content).toContain('@JvmField');
+    expect(content).toContain('OffsetDateTime');
+    expect(content).toContain('externalId: String?');
+  });
+
+  it('skips list wrapper and list metadata models', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'OrganizationList',
+        fields: [
+          {
+            name: 'data',
+            type: { kind: 'array', items: { kind: 'model', name: 'Organization' } },
+            required: true,
+          },
+          {
+            name: 'list_metadata',
+            type: { kind: 'model', name: 'ListMetadata' },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'ListMetadata',
+        fields: [
+          { name: 'before', type: { kind: 'primitive', type: 'string' }, required: false },
+          { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+        ],
+      },
+    ];
+
+    generateEnums([], ctx);
+    const files = generateModels(models, { ...ctx, spec: { ...emptySpec, models } });
+    const filePaths = files.map((f) => f.path);
+
+    expect(filePaths.some((p) => p.includes('Organization.kt') && !p.includes('List'))).toBe(true);
+    expect(filePaths.some((p) => p.includes('OrganizationList.kt'))).toBe(false);
+    expect(filePaths.some((p) => p.includes('ListMetadata.kt'))).toBe(false);
+  });
+
+  it('deduplicates structurally identical models preferring shorter names', () => {
+    const models: Model[] = [
+      {
+        name: 'EmailChangeConfirmationUser',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'email', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      {
+        name: 'User',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'email', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+    ];
+
+    generateEnums([], ctx);
+    const files = generateModels(models, { ...ctx, spec: { ...emptySpec, models } });
+
+    // User should be the canonical (shorter name) — a data class
+    const userFile = files.find((f) => f.path.includes('/User.kt'))!;
+    expect(userFile).toBeDefined();
+    expect(userFile.content).toContain('data class User');
+
+    // EmailChangeConfirmationUser should be the typealias
+    const aliasFile = files.find((f) => f.path.includes('/EmailChangeConfirmationUser.kt'))!;
+    expect(aliasFile).toBeDefined();
+    expect(aliasFile.content).toContain('typealias EmailChangeConfirmationUser = User');
+  });
+});