@workos/oagen-emitters 0.4.0 → 0.5.0

package/test/dotnet/resources.test.ts

@@ -139,8 +139,9 @@ describe('dotnet/resources', () => {
 
     const content = optionsFile.content;
     expect(content).toContain('Options');
-    expect(content).toContain('[JsonProperty("name")]');
     expect(content).toContain('public string Name');
+    // Convention-based naming — no per-property JSON attributes
+    expect(content).not.toContain('[JsonProperty("name")]');
   });
 
   it('generates paginated list method with auto-pagination', () => {
@@ -204,9 +205,9 @@ describe('dotnet/resources', () => {
     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)
+    // List method (return type is async Task)
     expect(content).toContain('async Task<WorkOSList<Organization>>');
-    expect(content).toContain('List(');
+    expect(content).toContain('ListAsync(');
 
     // Auto-pagination method
     expect(content).toContain('ListAutoPagingAsync');
@@ -252,4 +253,135 @@ describe('dotnet/resources', () => {
 
     expect(serviceFile.content).toContain('[System.Obsolete');
   });
+
+  it('generates parameter group abstract base + variant classes and query serialization', () => {
+    const models: Model[] = [
+      {
+        name: 'Authorization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'AuthorizationList',
+        fields: [
+          {
+            name: 'data',
+            type: { kind: 'array', items: { kind: 'model', name: 'Authorization' } },
+            required: true,
+          },
+          {
+            name: 'list_metadata',
+            type: { kind: 'model', name: 'ListMetadata' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const services: Service[] = [
+      {
+        name: 'Fga',
+        operations: [
+          {
+            name: 'listAuthorizations',
+            httpMethod: 'get',
+            path: '/fga/authorizations',
+            pathParams: [],
+            queryParams: [
+              { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+              { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+              { name: 'parent_resource_id', type: { kind: 'primitive', type: 'string' }, required: false },
+              { name: 'parent_resource_type_slug', type: { kind: 'primitive', type: 'string' }, required: false },
+              { name: 'parent_resource_external_id', type: { kind: 'primitive', type: 'string' }, required: false },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'AuthorizationList' },
+            errors: [],
+            injectIdempotencyKey: false,
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Authorization' },
+            },
+            parameterGroups: [
+              {
+                name: 'parent_resource',
+                optional: false,
+                variants: [
+                  {
+                    name: 'by_id',
+                    parameters: [
+                      { name: 'parent_resource_id', type: { kind: 'primitive', type: 'string' }, required: true },
+                    ],
+                  },
+                  {
+                    name: 'by_external_id',
+                    parameters: [
+                      {
+                        name: 'parent_resource_type_slug',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                      {
+                        name: 'parent_resource_external_id',
+                        type: { kind: 'primitive', type: 'string' },
+                        required: true,
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services, models },
+    };
+
+    const files = generateResources(services, ctxWithServices);
+
+    // Options file should exist and contain group types
+    const optionsFile = files.find((f) => f.path.includes('Options.cs'))!;
+    expect(optionsFile).toBeDefined();
+    const optContent = optionsFile.content;
+
+    // Abstract base class (prefixed with service name)
+    expect(optContent).toContain('public abstract class FGAParentResource { }');
+
+    // Concrete variant: ById
+    expect(optContent).toContain('public class FGAParentResourceById : FGAParentResource');
+    expect(optContent).toContain('public string ParentResourceId { get; set; } = default!;');
+
+    // Concrete variant: ByExternalId
+    expect(optContent).toContain('public class FGAParentResourceByExternalId : FGAParentResource');
+    expect(optContent).toContain('public string ParentResourceTypeSlug { get; set; } = default!;');
+    expect(optContent).toContain('public string ParentResourceExternalId { get; set; } = default!;');
+
+    // Group property on options class with JsonIgnore
+    expect(optContent).toContain('[JsonIgnore]');
+    expect(optContent).toContain('[STJS.JsonIgnore]');
+    expect(optContent).toContain('public FGAParentResource ParentResource { get; set; } = default!;');
+
+    // Grouped params should NOT appear as individual properties
+    expect(optContent).not.toMatch(/\[JsonProperty\("parent_resource_id"\)\]/);
+    expect(optContent).not.toMatch(/\[JsonProperty\("parent_resource_type_slug"\)\]/);
+    expect(optContent).not.toMatch(/\[JsonProperty\("parent_resource_external_id"\)\]/);
+
+    // Service file should contain group query serialization
+    const serviceFile = files.find((f) => f.path.endsWith('Service.cs'))!;
+    expect(serviceFile).toBeDefined();
+    const svcContent = serviceFile.content;
+
+    // Pattern matching for group variants
+    expect(svcContent).toContain('ParentResourceById');
+    expect(svcContent).toContain('ParentResourceByExternalId');
+    expect(svcContent).toContain('AddQueryParam("parent_resource_id"');
+    expect(svcContent).toContain('AddQueryParam("parent_resource_type_slug"');
+    expect(svcContent).toContain('AddQueryParam("parent_resource_external_id"');
+  });
 });

package/test/dotnet/tests.test.ts

@@ -105,15 +105,15 @@ describe('dotnet/tests', () => {
     const content = testFile.content;
 
     expect(content).toContain('TestError401');
-    expect(content).toContain('AuthenticationError');
+    expect(content).toContain('AuthenticationException');
     expect(content).toContain('TestError404');
-    expect(content).toContain('NotFoundError');
+    expect(content).toContain('NotFoundException');
     expect(content).toContain('TestError422');
-    expect(content).toContain('UnprocessableEntityError');
+    expect(content).toContain('UnprocessableEntityException');
     expect(content).toContain('TestError429');
-    expect(content).toContain('RateLimitExceededError');
+    expect(content).toContain('RateLimitExceededException');
     expect(content).toContain('TestError500');
-    expect(content).toContain('ServerError');
+    expect(content).toContain('ServerException');
   });
 
   it('generates fixture JSON files', () => {

package/test/entrypoint.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Verify the public entrypoint exports the plugin bundle
+ * and all intended direct symbols (emitters + extractors).
+ */
+describe('public entrypoint (@workos/oagen-emitters)', () => {
+  it('exports workosEmittersPlugin', async () => {
+    const mod = await import('../src/index.js');
+    expect(mod.workosEmittersPlugin).toBeDefined();
+    expect(mod.workosEmittersPlugin.emitters).toBeDefined();
+    expect(mod.workosEmittersPlugin.extractors).toBeDefined();
+    expect(mod.workosEmittersPlugin.smokeRunners).toBeDefined();
+  });
+
+  it('exports all individual emitters', async () => {
+    const mod = await import('../src/index.js');
+    const expectedEmitters = [
+      'nodeEmitter',
+      'pythonEmitter',
+      'phpEmitter',
+      'goEmitter',
+      'dotnetEmitter',
+      'kotlinEmitter',
+      'rubyEmitter',
+    ];
+    for (const name of expectedEmitters) {
+      expect(mod).toHaveProperty(name);
+      expect((mod as Record<string, unknown>)[name]).toHaveProperty('language');
+    }
+  });
+
+  it('exports all individual extractors', async () => {
+    const mod = await import('../src/index.js');
+    const expectedExtractors = [
+      'nodeExtractor',
+      'rubyExtractor',
+      'pythonExtractor',
+      'phpExtractor',
+      'goExtractor',
+      'rustExtractor',
+      'kotlinExtractor',
+      'dotnetExtractor',
+      'elixirExtractor',
+    ];
+    for (const name of expectedExtractors) {
+      expect(mod).toHaveProperty(name);
+      expect((mod as Record<string, unknown>)[name]).toHaveProperty('language');
+    }
+  });
+
+  it('plugin bundle emitters match individual emitter exports', async () => {
+    const mod = await import('../src/index.js');
+    const pluginLanguages = mod.workosEmittersPlugin.emitters!.map((e) => e.language);
+    const directEmitters = [
+      mod.nodeEmitter,
+      mod.pythonEmitter,
+      mod.phpEmitter,
+      mod.goEmitter,
+      mod.dotnetEmitter,
+      mod.kotlinEmitter,
+      mod.rubyEmitter,
+    ];
+    for (const emitter of directEmitters) {
+      expect(pluginLanguages).toContain(emitter.language);
+    }
+    expect(pluginLanguages).toHaveLength(directEmitters.length);
+  });
+
+  it('plugin bundle extractors match individual extractor exports', async () => {
+    const mod = await import('../src/index.js');
+    const pluginLanguages = mod.workosEmittersPlugin.extractors!.map((e) => e.language);
+    const directExtractors = [
+      mod.nodeExtractor,
+      mod.rubyExtractor,
+      mod.pythonExtractor,
+      mod.phpExtractor,
+      mod.goExtractor,
+      mod.rustExtractor,
+      mod.kotlinExtractor,
+      mod.dotnetExtractor,
+      mod.elixirExtractor,
+    ];
+    for (const extractor of directExtractors) {
+      expect(pluginLanguages).toContain(extractor.language);
+    }
+    expect(pluginLanguages).toHaveLength(directExtractors.length);
+  });
+});

package/test/go/client.test.ts

@@ -55,9 +55,9 @@ describe('go/client', () => {
     const content = workosFile.content;
 
     expect(content).toContain('package workos');
-    expect(content).toContain('organizations *organizationService');
+    expect(content).toContain('organizations *OrganizationService');
     expect(content).toContain('func NewClient(apiKey string, opts ...ClientOption) *Client {');
-    expect(content).toContain('func (c *Client) Organizations() *organizationService {');
+    expect(content).toContain('func (c *Client) Organizations() *OrganizationService {');
   });
 
   it('does not emit static options or HTTP infrastructure', () => {
@@ -84,9 +84,9 @@ describe('go/client', () => {
     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 {');
+    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/resources.test.ts

@@ -114,12 +114,12 @@ describe('go/resources', () => {
     expect(files.length).toBeGreaterThanOrEqual(1);
     const content = files[0].content;
     expect(content).toContain('package workos');
-    expect(content).toContain('type organizationService struct {');
+    expect(content).toContain('type OrganizationService struct {');
     expect(content).toContain('Limit *int `url:"limit,omitempty" json:"-"`');
-    expect(content).toContain('func (s *organizationService) List(');
-    expect(content).toContain('func (s *organizationService) Get(');
-    expect(content).toContain('func (s *organizationService) Create(');
-    expect(content).toContain('func (s *organizationService) Delete(');
+    expect(content).toContain('func (s *OrganizationService) List(');
+    expect(content).toContain('func (s *OrganizationService) Get(');
+    expect(content).toContain('func (s *OrganizationService) Create(');
+    expect(content).toContain('func (s *OrganizationService) Delete(');
   });
 
   it('generates path interpolation with fmt.Sprintf', () => {
@@ -139,7 +139,7 @@ describe('go/resources', () => {
     const spec = makeSpec(services);
     const files = generateResources(services, makeCtx(spec));
     const content = files[0].content;
-    expect(content).toContain('fmt.Sprintf("/users/%s", id)');
+    expect(content).toContain('fmt.Sprintf("/users/%s", url.PathEscape(id))');
   });
 
   it('generates paginated methods returning Iterator', () => {
@@ -165,7 +165,7 @@ describe('go/resources', () => {
     const files = generateResources(services, makeCtx(spec));
     const content = files[0].content;
     expect(content).toContain('*Iterator[User]');
-    expect(content).toContain('newIterator[User](ctx, s.client, "GET", "/users", nil, "after", "data", opts)');
+    expect(content).toContain('newIterator[User](ctx, s.client, "GET", "/users", nil, "after", "data", opts,');
   });
 
   it('generates delete methods returning error', () => {
@@ -405,4 +405,153 @@ describe('go/resources', () => {
     expect(content).toContain('Body interface{} `json:"-"`');
     expect(content).toContain('request(ctx, "POST", "/connect/applications", nil, params.Body, &result, opts)');
   });
+
+  describe('mutually-exclusive parameter groups', () => {
+    const groupedOp = makeOp({
+      name: 'listResources',
+      httpMethod: 'get',
+      path: '/authorization/organization_memberships/{organization_membership_id}/resources',
+      pathParams: [{ name: 'organization_membership_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      queryParams: [
+        { name: 'before', type: { kind: 'primitive', type: 'string' }, required: false },
+        { name: 'after', type: { kind: 'primitive', type: 'string' }, required: false },
+        { name: 'limit', type: { kind: 'primitive', type: 'integer' }, required: false },
+        { name: 'order', type: { kind: 'primitive', type: 'string' }, required: false },
+        { name: 'permission_slug', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'parent_resource_id', type: { kind: 'primitive', type: 'string' }, required: false },
+        { name: 'parent_resource_type_slug', type: { kind: 'primitive', type: 'string' }, required: false },
+        { name: 'parent_resource_external_id', type: { kind: 'primitive', type: 'string' }, required: false },
+      ],
+      parameterGroups: [
+        {
+          name: 'parent_resource',
+          optional: false,
+          variants: [
+            {
+              name: 'by_id',
+              parameters: [
+                { name: 'parent_resource_id', type: { kind: 'primitive', type: 'string' }, required: false },
+              ],
+            },
+            {
+              name: 'by_external_id',
+              parameters: [
+                { name: 'parent_resource_type_slug', type: { kind: 'primitive', type: 'string' }, required: false },
+                { name: 'parent_resource_external_id', type: { kind: 'primitive', type: 'string' }, required: false },
+              ],
+            },
+          ],
+        },
+      ],
+      pagination: {
+        strategy: 'cursor' as const,
+        param: 'after',
+        dataPath: 'data',
+        itemType: { kind: 'model' as const, name: 'AuthorizationResource' },
+      },
+    });
+
+    function makeGroupedServices(): Service[] {
+      return [{ name: 'Authorization', operations: [groupedOp] }];
+    }
+
+    it('generates a sealed interface for the parameter group', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      // Interface declaration with unexported marker + applyToQuery
+      expect(content).toContain('type AuthorizationParentResource interface {');
+      expect(content).toContain('isAuthorizationParentResource()');
+      expect(content).toContain('applyToQuery(url.Values)');
+    });
+
+    it('generates variant structs with shortened field names', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      // ByID variant
+      expect(content).toContain('type AuthorizationParentResourceByID struct {');
+      expect(content).toContain('\tID string');
+
+      // ByExternalID variant
+      expect(content).toContain('type AuthorizationParentResourceByExternalID struct {');
+      expect(content).toContain('\tTypeSlug string');
+      expect(content).toContain('\tExternalID string');
+    });
+
+    it('generates marker methods on each variant', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      expect(content).toContain('func (p AuthorizationParentResourceByID) isAuthorizationParentResource()');
+      expect(content).toContain('func (p AuthorizationParentResourceByExternalID) isAuthorizationParentResource()');
+    });
+
+    it('generates applyToQuery methods using original wire names', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      // ByID variant sets parent_resource_id
+      expect(content).toContain('func (p AuthorizationParentResourceByID) applyToQuery(v url.Values)');
+      expect(content).toContain('v.Set("parent_resource_id", p.ID)');
+
+      // ByExternalID variant sets both wire-name params
+      expect(content).toContain('func (p AuthorizationParentResourceByExternalID) applyToQuery(v url.Values)');
+      expect(content).toContain('v.Set("parent_resource_type_slug", p.TypeSlug)');
+      expect(content).toContain('v.Set("parent_resource_external_id", p.ExternalID)');
+    });
+
+    it('params struct uses group interface instead of flat pointers', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      // Should have the group field
+      expect(content).toContain('ParentResource AuthorizationParentResource `url:"-" json:"-"`');
+
+      // Should NOT have the flat pointer fields
+      expect(content).not.toMatch(/ParentResourceID\s+\*string/);
+      expect(content).not.toMatch(/ParentResourceTypeSlug\s+\*string/);
+      expect(content).not.toMatch(/ParentResourceExternalID\s+\*string/);
+
+      // Should still have non-grouped params
+      expect(content).toContain('PermissionSlug string');
+      expect(content).toContain('PaginationParams');
+    });
+
+    it('method body builds url.Values and calls applyToQuery', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      // Should build url.Values manually
+      expect(content).toContain('query := url.Values{}');
+      // Should encode the non-grouped required param
+      expect(content).toContain('query.Set("permission_slug", params.PermissionSlug)');
+      // Should call applyToQuery on the group
+      expect(content).toContain('params.ParentResource.applyToQuery(query)');
+      // Should pass query to the iterator (not params)
+      expect(content).toContain('newIterator[AuthorizationResource](ctx, s.client, "GET"');
+      expect(content).toContain(', query, "after", "data", opts, nil)');
+    });
+
+    it('imports net/url when parameter groups are present', () => {
+      const services = makeGroupedServices();
+      const spec = makeSpec(services);
+      const files = generateResources(services, makeCtx(spec));
+      const content = files[0].content;
+
+      expect(content).toContain('"net/url"');
+    });
+  });
 });

package/test/kotlin/models.test.ts

@@ -57,7 +57,7 @@ describe('kotlin/models', () => {
     const content = modelFile.content;
     expect(content).toContain('data class Organization');
     expect(content).toContain('@JsonProperty("id")');
-    expect(content).toContain('@JvmField');
+    expect(content).not.toContain('@JvmField');
     expect(content).toContain('OffsetDateTime');
     expect(content).toContain('externalId: String?');
   });