@workos/oagen-emitters 0.3.0 → 0.4.0

package/test/dotnet/enums.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest';
+import { generateEnums } from '../../src/dotnet/enums.js';
+import type { EmitterContext, ApiSpec, Enum, Service } 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/enums', () => {
+  it('returns empty for no enums', () => {
+    expect(generateEnums([], ctx)).toEqual([]);
+  });
+
+  it('generates C# enum with EnumMember attributes', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+          { name: 'PENDING', value: 'pending' },
+        ],
+      },
+    ];
+
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [{ name: 'status', type: { kind: 'enum', name: 'Status' }, required: false }],
+          headerParams: [],
+          response: { kind: 'model', name: 'Organization' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    expect(files.length).toBe(1);
+
+    const content = files[0].content;
+    expect(content).toContain('namespace WorkOS');
+    expect(content).toContain('public enum Status');
+    expect(content).toContain('[EnumMember(Value = "active")]');
+    expect(content).toContain('Active');
+    expect(content).toContain('[EnumMember(Value = "inactive")]');
+    expect(content).toContain('Inactive');
+    expect(content).toContain('[EnumMember(Value = "pending")]');
+    expect(content).toContain('Pending');
+    // Unknown sentinel for forward compatibility
+    expect(content).toContain('Unknown');
+  });
+
+  it('skips single-value enums (discriminator consts)', () => {
+    const enums: Enum[] = [
+      {
+        name: 'DiscriminatorType',
+        values: [{ name: 'ONLY_VALUE', value: 'only_value' }],
+      },
+    ];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, enums },
+    });
+    expect(files).toHaveLength(0);
+  });
+
+  it('deduplicates structurally identical enums', () => {
+    const enums: Enum[] = [
+      {
+        name: 'ConnectionType',
+        values: [
+          { name: 'SAML', value: 'saml' },
+          { name: 'OIDC', value: 'oidc' },
+        ],
+      },
+      {
+        name: 'ProfileConnectionType',
+        values: [
+          { name: 'SAML', value: 'saml' },
+          { name: 'OIDC', value: 'oidc' },
+        ],
+      },
+    ];
+
+    const service: Service = {
+      name: 'Test',
+      operations: [
+        {
+          name: 'test',
+          httpMethod: 'get',
+          path: '/test',
+          pathParams: [],
+          queryParams: [
+            { name: 'type', type: { kind: 'enum', name: 'ConnectionType' }, required: false },
+            { name: 'profile_type', type: { kind: 'enum', name: 'ProfileConnectionType' }, required: false },
+          ],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    // Only one enum file should be generated (the canonical)
+    expect(files).toHaveLength(1);
+    expect(files[0].content).toContain('ConnectionType');
+  });
+
+  it('skips orphan enums not referenced by models or operations', () => {
+    const enums: Enum[] = [
+      {
+        name: 'OrphanEnum',
+        values: [
+          { name: 'A', value: 'a' },
+          { name: 'B', value: 'b' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, enums },
+    });
+    expect(files).toHaveLength(0);
+  });
+
+  it('generates deprecated enum values with Obsolete attribute', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'OLD_STATUS', value: 'old_status', deprecated: true, description: 'Use ACTIVE instead' },
+        ],
+      },
+    ];
+
+    const service: Service = {
+      name: 'Test',
+      operations: [
+        {
+          name: 'test',
+          httpMethod: 'get',
+          path: '/test',
+          pathParams: [],
+          queryParams: [{ name: 'status', type: { kind: 'enum', name: 'Status' }, required: false }],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], enums },
+    });
+    expect(files).toHaveLength(1);
+    const content = files[0].content;
+
+    expect(content).toContain('[System.Obsolete');
+    expect(content).toContain('OldStatus');
+  });
+});

package/test/dotnet/errors.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import { dotnetEmitter } from '../../src/dotnet/index.js';
+
+describe('dotnet/errors', () => {
+  it('returns empty array (errors are hand-maintained in the target SDK)', () => {
+    const files = dotnetEmitter.generateErrors!({} as any);
+    expect(files).toHaveLength(0);
+  });
+});

package/test/dotnet/manifest.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { generateManifest } from '../../src/dotnet/manifest.js';
+import type { ApiSpec, EmitterContext, 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 }],
+  },
+];
+
+const services: Service[] = [
+  {
+    name: 'Organizations',
+    operations: [
+      {
+        name: 'listOrganizations',
+        httpMethod: 'get',
+        path: '/organizations',
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+  {
+    name: 'OrganizationsApiKeys',
+    operations: [
+      {
+        name: 'listOrganizationApiKeys',
+        httpMethod: 'get',
+        path: '/organizations/api_keys',
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        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/manifest', () => {
+  it('generates smoke-manifest.json', () => {
+    const files = generateManifest(spec, ctx);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('smoke-manifest.json');
+  });
+
+  it('maps HTTP operations to SDK method names and services', () => {
+    const files = generateManifest(spec, ctx);
+    const manifest = JSON.parse(files[0].content) as Record<string, { sdkMethod: string; service: string }>;
+
+    expect(manifest['GET /organizations']).toBeDefined();
+    expect(manifest['GET /organizations'].sdkMethod).toBeDefined();
+    expect(manifest['GET /organizations'].service).toBeDefined();
+
+    expect(manifest['GET /organizations/api_keys']).toBeDefined();
+    expect(manifest['GET /organizations/api_keys'].sdkMethod).toBeDefined();
+  });
+});

package/test/dotnet/models.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect } from 'vitest';
+import { generateModels } from '../../src/dotnet/models.js';
+import { primeEnumAliases } from '../../src/dotnet/enums.js';
+import type { EmitterContext, ApiSpec, Model, Service } 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/models', () => {
+  it('returns empty for no models', () => {
+    expect(generateModels([], ctx)).toEqual([]);
+  });
+
+  it('generates a C# class with JSON attributes', () => {
+    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: '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,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    });
+
+    expect(files.length).toBeGreaterThanOrEqual(1);
+
+    const modelFile = files.find((f) => f.path === 'Entities/Organization.cs')!;
+    expect(modelFile).toBeDefined();
+
+    const content = modelFile.content;
+    // Namespace
+    expect(content).toContain('namespace WorkOS');
+    // Class definition
+    expect(content).toContain('public class Organization');
+
+    // Required fields with JSON attributes
+    expect(content).toContain('[JsonProperty("id")]');
+    expect(content).toContain('public string Id');
+    expect(content).toContain('[JsonProperty("name")]');
+    expect(content).toContain('public string Name');
+
+    // DateTime field
+    expect(content).toContain('DateTimeOffset');
+    expect(content).toContain('[JsonProperty("created_at")]');
+
+    // Optional/nullable field
+    expect(content).toContain('[JsonProperty("external_id")]');
+  });
+
+  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 },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, models },
+    });
+    const filePaths = files.map((f) => f.path);
+
+    // Should generate Organization but NOT OrganizationList or ListMetadata
+    expect(filePaths.some((p) => p.includes('Organization.cs') && !p.includes('List'))).toBe(true);
+    expect(filePaths.some((p) => p.includes('OrganizationList.cs'))).toBe(false);
+    expect(filePaths.some((p) => p.includes('ListMetadata.cs'))).toBe(false);
+  });
+
+  it('deduplicates structurally identical models', () => {
+    const models: Model[] = [
+      {
+        name: 'OrganizationDomain',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'domain', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      {
+        name: 'OrganizationDomainStandAlone',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'domain', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, models },
+    });
+
+    // Canonical model should have a full class
+    const canonicalFile = files.find(
+      (f) => f.path.includes('OrganizationDomain.cs') && !f.path.includes('StandAlone'),
+    )!;
+    expect(canonicalFile).toBeDefined();
+    expect(canonicalFile.content).toContain('public class OrganizationDomain');
+
+    // Alias model should be a subclass of canonical
+    const aliasFile = files.find((f) => f.path.includes('OrganizationDomainStandAlone.cs'))!;
+    expect(aliasFile).toBeDefined();
+    expect(aliasFile.content).toContain('OrganizationDomain');
+  });
+
+  it('emits [System.Obsolete] for deprecated fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'old_field',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            deprecated: true,
+            description: 'Legacy field',
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, models },
+    });
+    const modelFile = files.find((f) => f.path.includes('Organization.cs'))!;
+
+    expect(modelFile.content).toContain('[System.Obsolete');
+  });
+
+  it('handles map fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'metadata',
+            type: { kind: 'map', valueType: { kind: 'primitive', type: 'string' } },
+            required: false,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, models },
+    });
+    const modelFile = files.find((f) => f.path.includes('Organization.cs'))!;
+
+    expect(modelFile.content).toContain('Dictionary<string,');
+  });
+
+  it('handles array fields with model refs', () => {
+    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 },
+          { name: 'domain', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const files = generateModels(models, {
+      ...ctx,
+      spec: { ...emptySpec, models },
+    });
+    const orgFile = files.find((f) => f.path.includes('Organization.cs') && !f.path.includes('Domain'))!;
+    expect(orgFile).toBeDefined();
+    expect(orgFile.content).toContain('List<OrganizationDomain>');
+  });
+});