@workos/oagen-emitters 0.2.1 → 0.4.0

package/test/kotlin/tests.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import { generateTests } from '../../src/kotlin/tests.js';
+import { generateEnums } from '../../src/kotlin/enums.js';
+import type { EmitterContext, ApiSpec, Service, Model, ResolvedOperation } 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(),
+};
+
+function buildResolvedOps(services: Service[]): ResolvedOperation[] {
+  return services.flatMap((svc) =>
+    svc.operations.map((op) => ({
+      service: svc,
+      operation: op,
+      methodName: op.name,
+      mountOn: svc.name,
+    })),
+  ) as ResolvedOperation[];
+}
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+  resolvedOperations: buildResolvedOps(services),
+};
+
+describe('kotlin/tests', () => {
+  it('generates per-mount-group test files', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path.includes('OrganizationsTest.kt'));
+    expect(testFile).toBeDefined();
+
+    const content = testFile!.content;
+    expect(content).toContain('class OrganizationsTest');
+    expect(content).toContain('TestBase');
+    expect(content).toContain('@Test');
+  });
+
+  it('generates happy-path test for void/delete methods', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path.includes('OrganizationsTest.kt'))!;
+    const content = testFile.content;
+
+    // Delete method should have an active test, not a @Disabled placeholder.
+    // Method name is trimmed from deleteOrganization -> delete by resolveMethodName.
+    expect(content).toContain('delete completes without throwing');
+    expect(content).not.toContain('@Disabled("generator: could not synthesize required arguments for delete")');
+  });
+
+  it('generates field-value assertions for non-void responses', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path.includes('OrganizationsTest.kt'))!;
+    const content = testFile.content;
+
+    // GET method returning Organization should assert field values
+    expect(content).toContain('assertEquals("sample", result.id)');
+    expect(content).toContain('assertEquals("sample", result.name)');
+  });
+
+  it('generates error-mapping tests', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const testFile = files.find((f) => f.path.includes('OrganizationsTest.kt'))!;
+    const content = testFile.content;
+
+    expect(content).toContain('UnauthorizedException');
+    expect(content).toContain('NotFoundException');
+    expect(content).toContain('RateLimitException');
+    expect(content).toContain('GenericServerException');
+  });
+
+  it('generates round-trip test using synthJson for broader coverage', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const roundTrip = files.find((f) => f.path.includes('GeneratedModelRoundTripTest.kt'));
+    expect(roundTrip).toBeDefined();
+
+    const content = roundTrip!.content;
+    expect(content).toContain('Organization round-trips through Jackson');
+    expect(content).toContain('assertEquals(tree1, tree2)');
+  });
+
+  it('generates forward-compat test with OffsetDateTime round-trip', () => {
+    generateEnums([], ctx);
+    const files = generateTests(spec, ctx);
+    const fwdCompat = files.find((f) => f.path.includes('GeneratedForwardCompatTest.kt'));
+    expect(fwdCompat).toBeDefined();
+
+    const content = fwdCompat!.content;
+    expect(content).toContain('OffsetDateTime round-trips');
+    expect(content).toContain('assertEquals(parsed.toInstant(), reparsed.toInstant())');
+  });
+
+  it('emits valid ISO-8601 for date-time fields in round-trip fixtures', () => {
+    const dtModels: Model[] = [
+      {
+        name: 'Event',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'created_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+          },
+        ],
+      },
+    ];
+    const dtSpec: ApiSpec = { ...spec, models: dtModels };
+    const dtCtx: EmitterContext = {
+      ...ctx,
+      spec: dtSpec,
+      resolvedOperations: buildResolvedOps(services),
+    };
+
+    generateEnums([], dtCtx);
+    const files = generateTests(dtSpec, dtCtx);
+    const roundTrip = files.find((f) => f.path.includes('GeneratedModelRoundTripTest.kt'));
+    expect(roundTrip).toBeDefined();
+
+    const content = roundTrip!.content;
+    // Should use ISO-8601 timestamp, not "sample"
+    expect(content).toContain('2024-01-01T00:00:00Z');
+    expect(content).not.toMatch(/created_at.*"sample"/);
+  });
+});

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 = {
@@ -196,6 +194,80 @@ describe('generateClient', () => {
     expect(serviceBarrel!.content).toContain("export * from './authentication-factor.interface';");
   });
 
+  it('propagates @deprecated from baseline service class to the property declaration', () => {
+    // Regression test for PR #1535 reviewer comment r3075509969: when a
+    // service class has `@deprecated` in its JSDoc, TS's deprecation-lint
+    // only fires at `new X()` call sites — not at `workos.x` access unless
+    // the property itself is annotated.  The emitter propagates the class
+    // deprecation to the property JSDoc so IDEs surface the strikethrough
+    // on every access.
+    const deprecatedCtx: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2026-01-01',
+        classes: {
+          Organizations: {
+            name: 'Organizations',
+            methods: {},
+            properties: {},
+            constructorParams: [{ name: 'workos', type: 'WorkOS', optional: false }],
+            deprecationMessage: 'Use `workos.connect` instead.',
+          },
+        },
+        interfaces: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+      },
+    };
+
+    const files = generateClient(spec, deprecatedCtx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts')!;
+    const content = workosFile.content;
+
+    // Property JSDoc carries the deprecation and the directive is preserved
+    // on the line immediately above the accessor.
+    expect(content).toMatch(
+      /\/\*\* @deprecated Use `workos\.connect` instead\. \*\/\s+readonly organizations = new Organizations\(this\);/,
+    );
+  });
+
+  it('emits a bare @deprecated when the baseline class deprecation has no message', () => {
+    const deprecatedCtx: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2026-01-01',
+        classes: {
+          Organizations: {
+            name: 'Organizations',
+            methods: {},
+            properties: {},
+            constructorParams: [{ name: 'workos', type: 'WorkOS', optional: false }],
+            deprecationMessage: '',
+          },
+        },
+        interfaces: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+      },
+    };
+
+    const files = generateClient(spec, deprecatedCtx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts')!;
+    expect(workosFile.content).toMatch(/\/\*\* @deprecated \*\/\s+readonly organizations = new Organizations\(this\);/);
+  });
+
+  it('does not emit @deprecated when the baseline class has no deprecationMessage', () => {
+    const files = generateClient(spec, ctx);
+    const workosFile = files.find((f) => f.path === 'src/workos.ts')!;
+    expect(workosFile.content).not.toContain('@deprecated');
+  });
+
   it('does not generate error handling in WorkOS client (lives in WorkOSBase)', () => {
     const files = generateClient(spec, ctx);
     const workosFile = files.find((f) => f.path === 'src/workos.ts')!;
@@ -261,6 +333,7 @@ describe('generateClient', () => {
       services: [eventService],
       models: [eventModel, otherModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const surface: ApiSurface = {
@@ -300,9 +373,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 +398,7 @@ describe('generateClient', () => {
           ],
         },
       ],
+      sdk: defaultSdkBehavior(),
     };
 
     const surface: ApiSurface = {
@@ -454,6 +529,7 @@ describe('generateClient', () => {
       services: [service, enumService, dirService],
       models: [model],
       enums: [enumDef, aliasEnumDef],
+      sdk: defaultSdkBehavior(),
     };
     const enumCtx: EmitterContext = {
       namespace: 'workos',
@@ -575,6 +651,7 @@ describe('generateClient', () => {
       services: [connectionsService, radarService],
       models: [connectionModel, radarModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const coveredCtx: EmitterContext = {
@@ -715,6 +792,7 @@ describe('generateClient', () => {
       services: [partialService],
       models: [dirModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const partialCtx: EmitterContext = {
@@ -818,6 +896,7 @@ describe('generateClient', () => {
       services: [mfaService],
       models: [mfaModel],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     const namingOnlyCtx: EmitterContext = {
@@ -859,6 +938,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 = {

package/test/node/errors.test.ts

@@ -2,47 +2,8 @@ import { describe, it, expect } from 'vitest';
 import { generateErrors } from '../../src/node/errors.js';
 
 describe('generateErrors', () => {
-  it('generates all exception classes', () => {
+  it('returns empty array without context (static exceptions now hand-maintained)', () => {
     const files = generateErrors();
-
-    const names = files.map((f) => f.path);
-    expect(names).toContain('src/common/exceptions/bad-request.exception.ts');
-    expect(names).toContain('src/common/exceptions/unauthorized.exception.ts');
-    expect(names).toContain('src/common/exceptions/not-found.exception.ts');
-    expect(names).toContain('src/common/exceptions/conflict.exception.ts');
-    expect(names).toContain('src/common/exceptions/unprocessable-entity.exception.ts');
-    expect(names).toContain('src/common/exceptions/rate-limit-exceeded.exception.ts');
-    expect(names).toContain('src/common/exceptions/generic-server.exception.ts');
-    expect(names).toContain('src/common/exceptions/no-api-key-provided.exception.ts');
-    expect(names).toContain('src/common/exceptions/index.ts');
-  });
-
-  it('generates NotFoundException with correct status', () => {
-    const files = generateErrors();
-    const notFoundFile = files.find((f) => f.path.includes('not-found.exception.ts'))!;
-
-    expect(notFoundFile.content).toContain('export class NotFoundException extends Error');
-    expect(notFoundFile.content).toContain('readonly status = 404;');
-    expect(notFoundFile.content).toContain('requestID: string');
-  });
-
-  it('generates RateLimitExceededException with retryAfter', () => {
-    const files = generateErrors();
-    const rateLimitFile = files.find((f) => f.path.includes('rate-limit-exceeded.exception.ts'))!;
-
-    expect(rateLimitFile.content).toContain('export class RateLimitExceededException extends Error');
-    expect(rateLimitFile.content).toContain('readonly status = 429;');
-    expect(rateLimitFile.content).toContain('retryAfter?: number');
-  });
-
-  it('generates exception barrel with all exports', () => {
-    const files = generateErrors();
-    const barrel = files.find((f) => f.path === 'src/common/exceptions/index.ts')!;
-
-    expect(barrel.content).toContain('export { BadRequestException }');
-    expect(barrel.content).toContain('export { UnauthorizedException }');
-    expect(barrel.content).toContain('export { NotFoundException }');
-    expect(barrel.content).toContain('export { RateLimitExceededException }');
-    expect(barrel.content).toContain('export { NoApiKeyProvidedException }');
+    expect(files).toEqual([]);
   });
 });

package/test/node/models.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { generateModels } from '../../src/node/models.js';
 import type { EmitterContext, ApiSpec, Model, 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 = {

package/test/node/naming.test.ts

@@ -10,10 +10,31 @@ import {
   servicePropertyName,
   resolveServiceName,
   buildServiceNameMap,
+  stripNoiseSuffixes,
 } from '../../src/node/naming.js';
 import type { EmitterContext, ApiSpec, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
 
 describe('naming', () => {
+  describe('stripNoiseSuffixes', () => {
+    it('strips trailing Dto', () => {
+      expect(stripNoiseSuffixes('OrganizationDto')).toBe('Organization');
+      expect(stripNoiseSuffixes('UpdateOrganizationDto')).toBe('UpdateOrganization');
+    });
+
+    it('is case-insensitive for the Dto suffix', () => {
+      expect(stripNoiseSuffixes('OrganizationDTO')).toBe('Organization');
+    });
+
+    it('does not strip Dto from the middle of a name', () => {
+      expect(stripNoiseSuffixes('DtoFactory')).toBe('DtoFactory');
+    });
+
+    it('leaves names without Dto unchanged', () => {
+      expect(stripNoiseSuffixes('Organization')).toBe('Organization');
+    });
+  });
+
   describe('className', () => {
     it('converts to PascalCase', () => {
       expect(className('organizations')).toBe('Organizations');
@@ -88,6 +109,7 @@ describe('naming', () => {
       services: [],
       models: [],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     it('returns overlay class name when available', () => {
@@ -160,6 +182,7 @@ describe('naming', () => {
       services: [],
       models: [],
       enums: [],
+      sdk: defaultSdkBehavior(),
     };
 
     it('maps IR names to resolved names', () => {