@workos/oagen-emitters 0.2.1 → 0.3.0

package/test/go/resources.test.ts

@@ -0,0 +1,408 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service, Operation, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateResources } from '../../src/go/resources.js';
+
+function makeSpec(services: Service[], models: Model[] = []): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: '',
+    services,
+    models,
+    enums: [],
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+function makeCtx(spec: ApiSpec): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec,
+  };
+}
+
+function makeOp(overrides: Partial<Operation>): Operation {
+  return {
+    name: 'listOrganizations',
+    httpMethod: 'get',
+    path: '/organizations',
+    pathParams: [],
+    queryParams: [],
+    headerParams: [],
+    requestBody: undefined,
+    response: { kind: 'model', name: 'Organization' },
+    errors: [],
+    injectIdempotencyKey: false,
+    ...overrides,
+  };
+}
+
+describe('go/resources', () => {
+  it('returns empty for no services', () => {
+    const spec = makeSpec([]);
+    expect(generateResources([], makeCtx(spec))).toEqual([]);
+  });
+
+  it('generates a service file with methods', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'listOrganizations',
+            httpMethod: 'get',
+            path: '/organizations',
+            queryParams: [
+              {
+                name: 'limit',
+                type: { kind: 'primitive', type: 'integer' },
+                required: false,
+              },
+            ],
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'Organization' },
+            },
+          }),
+          makeOp({
+            name: 'getOrganization',
+            httpMethod: 'get',
+            path: '/organizations/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+          }),
+          makeOp({
+            name: 'createOrganization',
+            httpMethod: 'post',
+            path: '/organizations',
+            requestBody: { kind: 'model', name: 'CreateOrganizationRequest' },
+          }),
+          makeOp({
+            name: 'deleteOrganization',
+            httpMethod: 'delete',
+            path: '/organizations/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+            response: { kind: 'primitive', type: 'unknown' },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services, [
+      {
+        name: 'CreateOrganizationRequest',
+        fields: [{ name: 'name', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ]);
+    const ctx = makeCtx(spec);
+    const files = generateResources(services, ctx);
+
+    expect(files.length).toBeGreaterThanOrEqual(1);
+    const content = files[0].content;
+    expect(content).toContain('package workos');
+    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(');
+  });
+
+  it('generates path interpolation with fmt.Sprintf', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'getUser',
+            httpMethod: 'get',
+            path: '/users/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('fmt.Sprintf("/users/%s", id)');
+  });
+
+  it('generates paginated methods returning Iterator', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'listUsers',
+            httpMethod: 'get',
+            path: '/users',
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'User' },
+            },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    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)');
+  });
+
+  it('generates delete methods returning error', () => {
+    const services: Service[] = [
+      {
+        name: 'Items',
+        operations: [
+          makeOp({
+            name: 'deleteItem',
+            httpMethod: 'delete',
+            path: '/items/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+            response: { kind: 'primitive', type: 'unknown' },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain(') error {');
+    expect(content).toContain('return err');
+  });
+
+  it('generates params struct for body + query params', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'createUser',
+            httpMethod: 'post',
+            path: '/users',
+            requestBody: { kind: 'model', name: 'CreateUserRequest' },
+            queryParams: [
+              {
+                name: 'notify',
+                type: { kind: 'primitive', type: 'boolean' },
+                required: false,
+              },
+            ],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services, [
+      {
+        name: 'CreateUserRequest',
+        fields: [{ name: 'email', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ]);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('type UsersCreateParams struct {');
+    expect(content).toContain('Email string `json:"email"`');
+    expect(content).toContain('Notify *bool `url:"notify,omitempty" json:"-"`');
+    expect(content).toContain('request(ctx, "POST", "/users", params, params, &result, opts)');
+  });
+
+  it('emits Deprecated comment for deprecated body field in params struct', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'createUser',
+            httpMethod: 'post',
+            path: '/users',
+            requestBody: { kind: 'model', name: 'CreateUserRequest' },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services, [
+      {
+        name: 'CreateUserRequest',
+        fields: [
+          {
+            name: 'email',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+            description: 'The user email.',
+            deprecated: true,
+          },
+          {
+            name: 'name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ]);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('\t// Email is the user email.\n\t//\n\t// Deprecated: this field is deprecated.');
+    expect(content).not.toMatch(/Deprecated.*\n\tName/);
+  });
+
+  it('emits Deprecated comment for deprecated query param in params struct', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          makeOp({
+            name: 'listUsers',
+            httpMethod: 'get',
+            path: '/users',
+            queryParams: [
+              {
+                name: 'old_filter',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+                description: 'A legacy filter.',
+                deprecated: true,
+              },
+              {
+                name: 'limit',
+                type: { kind: 'primitive', type: 'integer' },
+                required: false,
+              },
+            ],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain(
+      '\t// OldFilter is a legacy filter.\n\t//\n\t// Deprecated: this parameter is deprecated.',
+    );
+    expect(content).not.toMatch(/Deprecated.*\n\tLimit/);
+  });
+
+  it('emits Deprecated note in godoc for deprecated path param', () => {
+    const services: Service[] = [
+      {
+        name: 'Items',
+        operations: [
+          makeOp({
+            name: 'getItem',
+            httpMethod: 'get',
+            path: '/items/{old_id}',
+            pathParams: [
+              {
+                name: 'old_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+                deprecated: true,
+                description: 'use new_id instead',
+              },
+            ],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('// Deprecated parameter OldID: use new_id instead');
+  });
+
+  it('emits Deprecated note in godoc for deprecated path param without description', () => {
+    const services: Service[] = [
+      {
+        name: 'Items',
+        operations: [
+          makeOp({
+            name: 'getItem',
+            httpMethod: 'get',
+            path: '/items/{old_id}',
+            pathParams: [
+              {
+                name: 'old_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+                deprecated: true,
+              },
+            ],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('// Deprecated parameter OldID.');
+  });
+
+  it('emits Deprecated in godoc for deprecated operation', () => {
+    const services: Service[] = [
+      {
+        name: 'Items',
+        operations: [
+          makeOp({
+            name: 'getItem',
+            httpMethod: 'get',
+            path: '/items/{id}',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+            deprecated: true,
+            description: 'Get an item.',
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('// Deprecated: this operation is deprecated.');
+  });
+
+  it('uses params.Body for non-model request bodies', () => {
+    const services: Service[] = [
+      {
+        name: 'Connect',
+        operations: [
+          makeOp({
+            name: 'createApplications',
+            httpMethod: 'post',
+            path: '/connect/applications',
+            requestBody: { kind: 'primitive', type: 'unknown' },
+            response: { kind: 'model', name: 'ConnectApplication' },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('type ConnectCreateApplicationsParams struct {');
+    expect(content).toContain('Body interface{} `json:"-"`');
+    expect(content).toContain('request(ctx, "POST", "/connect/applications", nil, params.Body, &result, opts)');
+  });
+});

package/test/go/tests.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service, Operation, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateTests } from '../../src/go/tests.js';
+
+function makeOp(overrides: Partial<Operation>): Operation {
+  return {
+    name: 'getOrganization',
+    httpMethod: 'get',
+    path: '/organizations/{id}',
+    pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    queryParams: [],
+    headerParams: [],
+    requestBody: undefined,
+    response: { kind: 'model', name: 'Organization' },
+    errors: [],
+    injectIdempotencyKey: false,
+    ...overrides,
+  };
+}
+
+function makeSpec(services: Service[], models: Model[] = []): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: '',
+    services,
+    models: [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      ...models,
+    ],
+    enums: [],
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+function makeCtx(spec: ApiSpec): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec,
+  };
+}
+
+describe('go/tests', () => {
+  it('generates test files and fixtures', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [makeOp({})],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateTests(spec, makeCtx(spec));
+
+    // Should have fixture files and test files
+    const testFiles = files.filter((f) => f.path.endsWith('_test.go'));
+    const fixtureFiles = files.filter((f) => f.path.startsWith('testdata/'));
+
+    expect(testFiles.length).toBeGreaterThanOrEqual(1);
+    expect(fixtureFiles.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('generates httptest-based tests', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [makeOp({})],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateTests(spec, makeCtx(spec));
+    const testFile = files.find((f) => f.path.endsWith('_test.go') && !f.path.includes('helpers'))!;
+    const content = testFile.content;
+
+    expect(content).toContain('package workos_test');
+    expect(content).toContain('httptest.NewServer');
+    expect(content).toContain('require.Equal');
+    expect(content).toContain('workos.NewClient');
+  });
+
+  it('generates shared test helpers file', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [makeOp({})],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateTests(spec, makeCtx(spec));
+    const helperFile = files.find((f) => f.path === 'helpers_test.go')!;
+    expect(helperFile).toBeDefined();
+    expect(helperFile.content).toContain('ptrString');
+    expect(helperFile.content).toContain('ptrInt');
+    expect(helperFile.content).toContain('setupTestServer');
+  });
+
+  it('generates error test for 404 and 422', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [makeOp({})],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateTests(spec, makeCtx(spec));
+    const testFile = files.find((f) => f.path.endsWith('_test.go') && !f.path.includes('helpers'))!;
+    const content = testFile.content;
+
+    expect(content).toContain('Error404');
+    expect(content).toContain('NotFoundError');
+    expect(content).toContain('Error422');
+    expect(content).toContain('UnprocessableEntityError');
+  });
+
+  it('generates delete operation tests with no response assertion', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          makeOp({
+            name: 'deleteOrganization',
+            httpMethod: 'delete',
+            response: { kind: 'primitive', type: 'unknown' },
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services);
+    const files = generateTests(spec, makeCtx(spec));
+    const testFile = files.find((f) => f.path.endsWith('_test.go') && !f.path.includes('helpers'))!;
+    const content = testFile.content;
+
+    expect(content).toContain('StatusNoContent');
+    expect(content).toContain('require.NoError(t, err)');
+  });
+});

package/test/node/client.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { generateClient } from '../../src/node/client.js';
 import { isServiceCoveredByExisting } from '../../src/node/utils.js';
 import type { EmitterContext, ApiSpec, Service, Model, Enum } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
 import type { ApiSurface } from '@workos/oagen/compat';
 
 const service: Service = {
@@ -46,6 +47,7 @@ const spec: ApiSpec = {
   services: [service],
   models: [model],
   enums: [],
+  sdk: defaultSdkBehavior(),
 };
 
 const ctx: EmitterContext = {
@@ -98,16 +100,11 @@ describe('generateClient', () => {
     expect(serviceBarrel!.skipIfExists).toBe(true);
   });
 
-  it('generates package.json and tsconfig.json', () => {
+  it('does not generate package.json, tsconfig.json, or worker barrel (now hand-maintained)', () => {
     const files = generateClient(spec, ctx);
-    const pkg = files.find((f) => f.path === 'package.json');
-    const tsconfig = files.find((f) => f.path === 'tsconfig.json');
-
-    expect(pkg).toBeDefined();
-    expect(pkg!.skipIfExists).toBe(true);
-
-    expect(tsconfig).toBeDefined();
-    expect(tsconfig!.skipIfExists).toBe(true);
+    expect(files.find((f) => f.path === 'package.json')).toBeUndefined();
+    expect(files.find((f) => f.path === 'tsconfig.json')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/index.worker.ts')).toBeUndefined();
   });
 
   it('uses overlay-resolved names for imports and accessors', () => {
@@ -146,6 +143,7 @@ describe('generateClient', () => {
       services: [mfaService],
       models: [mfaModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const overlayCtx: EmitterContext = {
@@ -261,6 +259,7 @@ describe('generateClient', () => {
       services: [eventService],
       models: [eventModel, otherModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const surface: ApiSurface = {
@@ -300,9 +299,10 @@ describe('generateClient', () => {
     expect(content).not.toContain('export type { Event,');
     expect(content).not.toContain('export type { Event }');
 
-    // EventCursor is NOT in apiSurface.exports, so it should still be exported
-    // (via common barrel wildcard since it's unassigned to any service)
-    expect(content).toContain("export * from './common/interfaces'");
+    // EventCursor is unreachable (not referenced by any service), so it should
+    // NOT be exported — oagen only generates interface files for reachable models
+    expect(content).not.toContain("export * from './common/interfaces'");
+    expect(content).not.toContain('EventCursor');
 
     // The resource class export should still be present
     expect(content).toContain("export { Events } from './events/events'");
@@ -324,6 +324,7 @@ describe('generateClient', () => {
           ],
         },
       ],
+      sdk: defaultSdkBehavior(),
     };
 
     const surface: ApiSurface = {
@@ -454,6 +455,7 @@ describe('generateClient', () => {
       services: [service, enumService, dirService],
       models: [model],
       enums: [enumDef, aliasEnumDef],
+      sdk: defaultSdkBehavior(),
     };
     const enumCtx: EmitterContext = {
       namespace: 'workos',
@@ -575,6 +577,7 @@ describe('generateClient', () => {
       services: [connectionsService, radarService],
       models: [connectionModel, radarModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const coveredCtx: EmitterContext = {
@@ -715,6 +718,7 @@ describe('generateClient', () => {
       services: [partialService],
       models: [dirModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const partialCtx: EmitterContext = {
@@ -818,6 +822,7 @@ describe('generateClient', () => {
       services: [mfaService],
       models: [mfaModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const namingOnlyCtx: EmitterContext = {
@@ -859,6 +864,7 @@ describe('isServiceCoveredByExisting', () => {
     services: [],
     models: [],
     enums: [],
+    sdk: defaultSdkBehavior(),
   };
 
   it('returns false when no overlay is provided', () => {

package/test/node/enums.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { generateEnums } from '../../src/node/enums.js';
 import type { EmitterContext, ApiSpec, Enum, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
 
 const emptySpec: ApiSpec = {
   name: 'Test',
@@ -9,6 +10,7 @@ const emptySpec: ApiSpec = {
   services: [],
   models: [],
   enums: [],
+  sdk: defaultSdkBehavior(),
 };
 
 const ctx: EmitterContext = {