@workos/oagen-emitters 0.3.0 → 0.5.0

package/test/kotlin/resources.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest';
+import { defaultSdkBehavior, type ApiSpec, type EmitterContext, type Service } from '@workos/oagen';
+import { generateResources } from '../../src/kotlin/resources.js';
+import { generateEnums } from '../../src/kotlin/enums.js';
+
+const baseSpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: 'https://api.workos.com',
+  services: [],
+  models: [
+    {
+      name: 'AuthenticateResponse',
+      fields: [{ name: 'access_token', type: { kind: 'primitive', type: 'string' }, required: true }],
+    },
+    {
+      name: 'SSOTokenResponse',
+      fields: [{ name: 'access_token', type: { kind: 'primitive', type: 'string' }, required: true }],
+    },
+  ],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+function ctxFor(services: Service[], enums = baseSpec.enums): EmitterContext {
+  return {
+    namespace: 'workos',
+    namespacePascal: 'WorkOS',
+    spec: { ...baseSpec, services, enums },
+    resolvedOperations: services.flatMap((service) =>
+      service.operations.map((operation) => ({
+        service,
+        operation,
+        methodName: operation.name,
+        mountOn: service.name,
+        defaults: {},
+        inferFromClient: [],
+        urlBuilder: false,
+      })),
+    ),
+  };
+}
+
+describe('kotlin/resources', () => {
+  it('collapses duplicated query/body params into a single Kotlin parameter', () => {
+    const services: Service[] = [
+      {
+        name: 'SSO',
+        operations: [
+          {
+            name: 'getProfileAndToken',
+            httpMethod: 'post',
+            path: '/sso/token',
+            pathParams: [],
+            queryParams: [{ name: 'code', type: { kind: 'primitive', type: 'string' }, required: true }],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'GetProfileAndTokenRequest' },
+            response: { kind: 'model', name: 'SSOTokenResponse' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const spec = {
+      ...baseSpec,
+      services,
+      models: [
+        ...baseSpec.models,
+        {
+          name: 'GetProfileAndTokenRequest',
+          fields: [{ name: 'code', type: { kind: 'primitive', type: 'string' }, required: true }],
+        },
+      ],
+    };
+    const files = generateResources(services, { ...ctxFor(services), spec: spec as ApiSpec });
+    const ssoFile = files.find((file) => file.path.endsWith('/Sso.kt'));
+    expect(ssoFile).toBeDefined();
+    expect(ssoFile!.content).toContain('fun getProfileAndToken(');
+    expect(ssoFile!.content).toContain('code: String');
+    expect(ssoFile!.content).not.toContain('bodyCode');
+    expect(ssoFile!.content).toContain('params += "code" to code');
+    expect(ssoFile!.content).toContain('"code" to code');
+  });
+
+  it('emits a shared authenticate helper for user management authenticate variants', () => {
+    const services: Service[] = [
+      {
+        name: 'UserManagement',
+        operations: [
+          {
+            name: 'authenticateWithPassword',
+            httpMethod: 'post',
+            path: '/user_management/authenticate',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'AuthenticatePasswordRequest' },
+            response: { kind: 'model', name: 'AuthenticateResponse' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const spec = {
+      ...baseSpec,
+      services,
+      models: [
+        ...baseSpec.models,
+        {
+          name: 'AuthenticatePasswordRequest',
+          fields: [
+            { name: 'email', type: { kind: 'primitive', type: 'string' }, required: true },
+            { name: 'password', type: { kind: 'primitive', type: 'string' }, required: true },
+          ],
+        },
+      ],
+    };
+    const files = generateResources(services, { ...ctxFor(services), spec: spec as ApiSpec });
+    const userManagementFile = files.find((file) => file.path.endsWith('/UserManagement.kt'));
+    expect(userManagementFile).toBeDefined();
+    expect(userManagementFile!.content).toContain('private fun authenticate(');
+    expect(userManagementFile!.content).toContain('grantType = "authorization_code"');
+  });
+
+  it('renames package-level parameter group helpers to avoid Role/Password collisions', () => {
+    const services: Service[] = [
+      {
+        name: 'UserManagement',
+        operations: [
+          {
+            name: 'createUser',
+            httpMethod: 'post',
+            path: '/users',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateUserRequest' },
+            response: { kind: 'model', name: 'AuthenticateResponse' },
+            errors: [],
+            injectIdempotencyKey: false,
+            parameterGroups: [
+              {
+                name: 'Password',
+                optional: true,
+                variants: [
+                  {
+                    name: 'Plaintext',
+                    parameters: [{ name: 'password', type: { kind: 'primitive', type: 'string' }, required: true }],
+                  },
+                ],
+              },
+              {
+                name: 'Role',
+                optional: true,
+                variants: [
+                  {
+                    name: 'Single',
+                    parameters: [{ name: 'role_slug', type: { kind: 'primitive', type: 'string' }, required: true }],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+    const spec = {
+      ...baseSpec,
+      services,
+      models: [
+        ...baseSpec.models,
+        {
+          name: 'CreateUserRequest',
+          fields: [
+            { name: 'password', type: { kind: 'primitive', type: 'string' }, required: false },
+            { name: 'role_slug', type: { kind: 'primitive', type: 'string' }, required: false },
+          ],
+        },
+      ],
+    };
+    const files = generateResources(services, { ...ctxFor(services), spec: spec as ApiSpec });
+    const userManagementFile = files.find((file) => file.path.endsWith('/UserManagement.kt'));
+    expect(userManagementFile).toBeDefined();
+    expect(userManagementFile!.content).toContain('sealed class CreateUserPassword');
+    expect(userManagementFile!.content).toContain('sealed class CreateUserRole');
+  });
+
+  it('collapses asc/desc order enums into SortOrder', () => {
+    const enums = [
+      {
+        name: 'EventsOrder',
+        values: [{ value: 'asc' }, { value: 'desc' }],
+      },
+      {
+        name: 'OrganizationsOrder',
+        values: [{ value: 'asc' }, { value: 'desc' }],
+      },
+    ];
+
+    const files = generateEnums(enums as never, ctxFor([], enums as never));
+    const sortOrder = files.find((file) => file.path.endsWith('/SortOrder.kt'));
+    const aliases = files.filter((file) => file.path.endsWith('Order.kt') && !file.path.endsWith('/SortOrder.kt'));
+
+    expect(sortOrder).toBeDefined();
+    expect(sortOrder!.content).toContain('enum class SortOrder');
+    expect(aliases.length).toBeLessThanOrEqual(1);
+  });
+});

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

@@ -194,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')!;

package/test/node/models.test.ts

@@ -182,6 +182,23 @@ describe('generateModels', () => {
   });
 
   it('handles generic type params', () => {
+    const service: Service = {
+      name: 'DirectorySync',
+      operations: [
+        {
+          name: 'getDirectoryUser',
+          httpMethod: 'get',
+          path: '/directory_users/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'DirectoryUser' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
     const models: Model[] = [
       {
         name: 'DirectoryUser',
@@ -204,7 +221,12 @@ describe('generateModels', () => {
       },
     ];
 
-    const files = generateModels(models, ctx);
+    const ctxWithServices: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+    };
+
+    const files = generateModels(models, ctxWithServices);
     expect(files[0].content).toContain('export interface DirectoryUser<TCustom = Record<string, any>> {');
     expect(files[0].content).toContain('export interface DirectoryUserResponse<TCustom = Record<string, any>> {');
   });
@@ -733,6 +755,23 @@ describe('model deduplication', () => {
           errors: [],
           injectIdempotencyKey: false,
         },
+        {
+          name: 'getOrganizationRole',
+          httpMethod: 'get',
+          path: '/organization_roles/{id}',
+          pathParams: [
+            {
+              name: 'id',
+              type: { kind: 'primitive', type: 'string' },
+              required: true,
+            },
+          ],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'OrganizationRole' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
       ],
     };
 
@@ -794,4 +833,98 @@ describe('model deduplication', () => {
     expect(files[1].content).toContain('export type OrganizationRole = EnvironmentRole');
     expect(files[1].content).toContain('export type OrganizationRoleResponse = EnvironmentRoleResponse');
   });
+
+  it('generates Date type for date-time fields even when baseline says string', () => {
+    const service: Service = {
+      name: 'Authorization',
+      operations: [
+        {
+          name: 'getRoleAssignment',
+          httpMethod: 'get',
+          path: '/role_assignments/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'model', name: 'RoleAssignment' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const models: Model[] = [
+      {
+        name: 'RoleAssignment',
+        fields: [
+          {
+            name: 'id',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+          {
+            name: 'created_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+          },
+          {
+            name: 'updated_at',
+            type: { kind: 'primitive', type: 'string', format: 'date-time' },
+            required: true,
+          },
+          // Extra field not in baseline so modelHasNewFields returns true
+          // (allowing the dedup test to proceed with generation)
+          {
+            name: 'role_name',
+            type: { kind: 'primitive', type: 'string' },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      spec: { ...emptySpec, services: [service], models },
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          RoleAssignment: {
+            name: 'RoleAssignment',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              createdAt: { name: 'createdAt', type: 'string', optional: false },
+              updatedAt: { name: 'updatedAt', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+          RoleAssignmentResponse: {
+            name: 'RoleAssignmentResponse',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              created_at: { name: 'created_at', type: 'string', optional: false },
+              updated_at: { name: 'updated_at', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+
+    const files = generateModels(models, ctxWithBaseline);
+    const content = files[0].content;
+
+    // Domain interface should use Date, not string from baseline
+    expect(content).toContain('  createdAt: Date;');
+    expect(content).toContain('  updatedAt: Date;');
+
+    // Wire interface should stay as string (JSON native)
+    expect(content).toContain('  created_at: string;');
+    expect(content).toContain('  updated_at: string;');
+  });
 });