@workos/oagen-emitters 0.2.1 → 0.4.0

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/go/client.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateClient } from '../../src/go/client.js';
+
+function makeSpec(services: Service[]): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: 'https://api.workos.com',
+    services,
+    models: [],
+    enums: [],
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+function makeCtx(spec: ApiSpec): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec,
+  };
+}
+
+describe('go/client', () => {
+  it('generates only workos.go', () => {
+    const spec = makeSpec([]);
+    const files = generateClient(spec, makeCtx(spec));
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('workos.go');
+  });
+
+  it('generates Client struct with service fields', () => {
+    const spec = makeSpec([
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'Organization' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ]);
+    const files = generateClient(spec, makeCtx(spec));
+    const workosFile = files.find((f) => f.path === 'workos.go')!;
+    const content = workosFile.content;
+
+    expect(content).toContain('package workos');
+    expect(content).toContain('organizations *organizationService');
+    expect(content).toContain('func NewClient(apiKey string, opts ...ClientOption) *Client {');
+    expect(content).toContain('func (c *Client) Organizations() *organizationService {');
+  });
+
+  it('does not emit static options or HTTP infrastructure', () => {
+    const spec = makeSpec([]);
+    const files = generateClient(spec, makeCtx(spec));
+    const workosFile = files.find((f) => f.path === 'workos.go')!;
+    const content = workosFile.content;
+
+    // These definitions are now in hand-maintained options.go
+    expect(content).not.toContain('type ClientOption func(*Client)');
+    expect(content).not.toContain('func WithBaseURL');
+    expect(content).not.toContain('type RequestOption');
+    expect(content).not.toContain('type requestConfig struct');
+    // Constants are defined in options.go, but referenced in NewClient
+    expect(content).not.toContain('defaultBaseURL    =');
+  });
+
+  it('uses acronym-aware service accessors and fields', () => {
+    const spec = makeSpec([
+      { name: 'ApiKeys', operations: [] },
+      { name: 'SSO', operations: [] },
+    ]);
+    const files = generateClient(spec, makeCtx(spec));
+    const workosFile = files.find((f) => f.path === 'workos.go')!;
+    const content = workosFile.content;
+
+    expect(content).toContain('apiKeys *apiKeyService');
+    expect(content).toContain('sso *ssoService');
+    expect(content).toContain('func (c *Client) APIKeys() *apiKeyService {');
+    expect(content).toContain('func (c *Client) SSO() *ssoService {');
+  });
+});

package/test/go/enums.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Enum } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateEnums } from '../../src/go/enums.js';
+
+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('go/enums', () => {
+  it('returns empty for no enums', () => {
+    expect(generateEnums([], ctx)).toEqual([]);
+  });
+
+  it('generates typed string constants', () => {
+    const enums: Enum[] = [
+      {
+        name: 'ConnectionStatus',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('enums.go');
+    const content = files[0].content;
+    expect(content).toContain('package workos');
+    expect(content).toContain('type ConnectionStatus string');
+    expect(content).toContain('ConnectionStatusActive ConnectionStatus = "active"');
+    expect(content).toContain('ConnectionStatusInactive ConnectionStatus = "inactive"');
+  });
+
+  it('deduplicates identical enums as type aliases', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Alpha',
+        values: [{ name: 'A', value: 'a' }],
+      },
+      {
+        name: 'Beta',
+        values: [{ name: 'A', value: 'a' }],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const content = files[0].content;
+    expect(content).toContain('type Alpha string');
+    expect(content).toContain('type Beta = Alpha');
+  });
+
+  it('handles empty enums as type aliases to string', () => {
+    const enums: Enum[] = [{ name: 'UnknownType', values: [] }];
+    const files = generateEnums(enums, ctx);
+    const content = files[0].content;
+    expect(content).toContain('type UnknownType = string');
+  });
+
+  it('snapshot: ConnectionStatus enum', () => {
+    const enums: Enum[] = [
+      {
+        name: 'ConnectionStatus',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+          { name: 'PENDING', value: 'pending' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    expect(files[0].content).toMatchInlineSnapshot(`
+      "package workos
+
+      // ConnectionStatus represents connection status values.
+      type ConnectionStatus string
+
+      const (
+      	ConnectionStatusActive ConnectionStatus = "active"
+      	ConnectionStatusInactive ConnectionStatus = "inactive"
+      	ConnectionStatusPending ConnectionStatus = "pending"
+      )
+      "
+    `);
+  });
+
+  it('emits Deprecated comments for deprecated enum values', () => {
+    const enums: Enum[] = [
+      {
+        name: 'WidgetStatus',
+        values: [
+          { name: 'ACTIVE', value: 'active', description: 'Currently active', deprecated: true },
+          { name: 'LEGACY', value: 'legacy', deprecated: true },
+          { name: 'CURRENT', value: 'current' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const content = files[0].content;
+    // deprecated value WITH description gets separator + Deprecated
+    expect(content).toContain(
+      '\t// WidgetStatusActive is Currently active.\n\t//\n\t// Deprecated: this value is deprecated.',
+    );
+    // deprecated value WITHOUT description gets Deprecated only
+    expect(content).toContain('\t// Deprecated: this value is deprecated.\n\tWidgetStatusLegacy');
+    // non-deprecated value does NOT get Deprecated
+    expect(content).not.toMatch(/Deprecated.*\n\tWidgetStatusCurrent/);
+  });
+
+  it('uses Go acronym conventions for enum type names', () => {
+    const enums: Enum[] = [
+      {
+        name: 'SsoConnectionType',
+        values: [{ name: 'SAML', value: 'saml' }],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const content = files[0].content;
+    expect(content).toContain('type SSOConnectionType string');
+  });
+});

package/test/go/errors.test.ts

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

package/test/go/models.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateModels } from '../../src/go/models.js';
+
+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('go/models', () => {
+  it('returns empty for no models', () => {
+    expect(generateModels([], ctx)).toEqual([]);
+  });
+
+  it('generates a struct with required and optional fields', () => {
+    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: 'metadata',
+            type: { kind: 'map', valueType: { kind: 'primitive', type: 'string' } },
+            required: false,
+          },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('models.go');
+    const content = files[0].content;
+    expect(content).toContain('package workos');
+    expect(content).toContain('type Organization struct {');
+    expect(content).toContain('ID string `json:"id"`');
+    expect(content).toContain('Name string `json:"name"`');
+    expect(content).toContain('Metadata map[string]string `json:"metadata,omitempty"`');
+  });
+
+  it('handles model refs as pointer types', () => {
+    const models: Model[] = [
+      {
+        name: 'User',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'profile', type: { kind: 'model', name: 'Profile' }, required: true },
+        ],
+      },
+      {
+        name: 'Profile',
+        fields: [{ name: 'bio', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('Profile *Profile `json:"profile"`');
+  });
+
+  it('handles nullable fields as pointers', () => {
+    const models: Model[] = [
+      {
+        name: 'Item',
+        fields: [
+          {
+            name: 'description',
+            type: { kind: 'nullable', inner: { kind: 'primitive', type: 'string' } },
+            required: false,
+          },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('Description *string');
+  });
+
+  it('skips list wrapper models', () => {
+    const models: Model[] = [
+      {
+        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 files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).not.toContain('OrganizationList');
+  });
+
+  it('deduplicates structurally identical models', () => {
+    const models: Model[] = [
+      {
+        name: 'Alpha',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'Beta',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('type Alpha struct {');
+    expect(content).toContain('type Beta = Alpha');
+  });
+
+  it('uses Go acronym conventions for field names', () => {
+    const models: Model[] = [
+      {
+        name: 'Connection',
+        fields: [
+          { name: 'connection_id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'sso_url', type: { kind: 'primitive', type: 'string' }, required: false },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('ConnectionID string');
+    expect(content).toContain('SSOURL *string');
+  });
+
+  it('generates array fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Org',
+        fields: [
+          {
+            name: 'domains',
+            type: { kind: 'array', items: { kind: 'primitive', type: 'string' } },
+            required: true,
+          },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('Domains []string `json:"domains"`');
+  });
+
+  it('generates enum field references', () => {
+    const models: Model[] = [
+      {
+        name: 'Connection',
+        fields: [{ name: 'status', type: { kind: 'enum', name: 'ConnectionStatus' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('Status ConnectionStatus `json:"status"`');
+  });
+
+  it('preserves DTO model names when emitting distinct types', () => {
+    const models: Model[] = [
+      {
+        name: 'RedirectUriDto',
+        fields: [{ name: 'uri', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    expect(content).toContain('type RedirectURIDto struct {');
+    expect(content).toContain('URI string `json:"uri"`');
+  });
+
+  it('emits Deprecated comments for deprecated fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Widget',
+        fields: [
+          {
+            name: 'old_name',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+            description: 'The original name.',
+            deprecated: true,
+          },
+          {
+            name: 'legacy_id',
+            type: { kind: 'primitive', type: 'string' },
+            required: false,
+            deprecated: true,
+          },
+          {
+            name: 'current_name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    const content = files[0].content;
+    // deprecated field WITH description gets separator + Deprecated
+    expect(content).toContain('\t// OldName is the original name.\n\t//\n\t// Deprecated: this field is deprecated.');
+    // deprecated field WITHOUT description gets Deprecated only (no separator)
+    expect(content).toContain('\t// Deprecated: this field is deprecated.\n\tLegacyID');
+    // non-deprecated field does NOT get Deprecated
+    expect(content).not.toMatch(/Deprecated.*\n\tCurrentName/);
+  });
+
+  it('snapshot: Organization struct', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        description: 'Represents an 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 },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx);
+    expect(files[0].content).toMatchInlineSnapshot(`
+      "package workos
+
+      // Organization represents an organization.
+      type Organization struct {
+      	ID string \`json:"id"\`
+      	Name string \`json:"name"\`
+      	CreatedAt string \`json:"created_at"\`
+      }
+
+      // PaginationParams contains common pagination parameters for list operations.
+      type PaginationParams struct {
+      	// Before is a cursor for reverse pagination.
+      	Before *string \`url:"before,omitempty" json:"-"\`
+      	// After is a cursor for forward pagination.
+      	After *string \`url:"after,omitempty" json:"-"\`
+      	// Limit is the maximum number of items to return per page.
+      	Limit *int \`url:"limit,omitempty" json:"-"\`
+      	// Order is the sort order for results (asc or desc).
+      	Order *string \`url:"order,omitempty" json:"-"\`
+      }
+      "
+    `);
+  });
+});