@workos/oagen-emitters 0.2.1 → 0.4.0

package/test/php/tests.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateTests } from '../../src/php/tests.js';
+
+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: 'listOrganizations',
+        httpMethod: 'get',
+        path: '/organizations',
+        pathParams: [],
+        queryParams: [{ name: 'after', type: { kind: 'primitive', type: 'string' }, required: false }],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        errors: [],
+        pagination: {
+          strategy: 'cursor',
+          param: 'after',
+          dataPath: 'data',
+          itemType: { kind: 'model', name: 'Organization' },
+        },
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+];
+
+const spec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services,
+  models,
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+};
+
+describe('generateTests', () => {
+  it('does not generate TestHelper (now hand-maintained)', () => {
+    const result = generateTests(spec, ctx);
+
+    const helper = result.find((f) => f.path === 'tests/TestHelper.php');
+    expect(helper).toBeUndefined();
+  });
+
+  it('generates resource test files', () => {
+    const result = generateTests(spec, ctx);
+
+    const resourceTest = result.find((f) => f.path === 'tests/Service/OrganizationsTest.php');
+    expect(resourceTest).toBeDefined();
+    expect(resourceTest!.content).toContain('class OrganizationsTest extends TestCase');
+    expect(resourceTest!.content).toContain('use TestHelper;');
+    expect(resourceTest!.content).toContain('testGet');
+    // Round-trip assertion: fromArray -> toArray must not throw
+    expect(resourceTest!.content).toContain('$result->toArray()');
+  });
+
+  it('generates client test', () => {
+    const result = generateTests(spec, ctx);
+
+    const clientTest = result.find((f) => f.path === 'tests/ClientTest.php');
+    expect(clientTest).toBeDefined();
+    expect(clientTest!.content).toContain('testConstructor');
+  });
+
+  it('generates pagination boundary test with cursor null assertions', () => {
+    const result = generateTests(spec, ctx);
+
+    const resourceTest = result.find((f) => f.path === 'tests/Service/OrganizationsTest.php');
+    expect(resourceTest).toBeDefined();
+    expect(resourceTest!.content).toContain('testPaginationBoundary');
+    // Cursor null assertions
+    expect(resourceTest!.content).toContain("$this->assertNull($result->listMetadata['before'])");
+    expect(resourceTest!.content).toContain("$this->assertNull($result->listMetadata['after'])");
+    // Iteration still tested
+    expect(resourceTest!.content).toContain('foreach ($result as $item)');
+  });
+
+  it('generates redirect endpoint test with query param assertions', () => {
+    const ssoServices: Service[] = [
+      {
+        name: 'SSO',
+        operations: [
+          {
+            name: 'getAuthorizationUrl',
+            httpMethod: 'get',
+            path: '/sso/authorize',
+            pathParams: [],
+            queryParams: [
+              { name: 'client_id', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'response_type', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'redirect_uri', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'state', type: { kind: 'primitive', type: 'string' }, required: false },
+            ],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const ssoSpec = { ...spec, services: ssoServices };
+    const ssoCtx: EmitterContext = {
+      ...ctx,
+      spec: ssoSpec,
+      resolvedOperations: [
+        {
+          operation: ssoServices[0].operations[0],
+          service: ssoServices[0],
+          methodName: 'get_authorization_url',
+          mountOn: 'SSO',
+          defaults: { response_type: 'code' },
+          inferFromClient: ['client_id'],
+        } as any,
+      ],
+    };
+
+    const result = generateTests(ssoSpec, ssoCtx);
+    const testFile = result.find((f) => f.path === 'tests/Service/SSOTest.php');
+    expect(testFile).toBeDefined();
+    const content = testFile!.content;
+
+    // Should be a redirect endpoint test (no mock responses, returns string)
+    expect(content).toContain('$this->assertIsString($result)');
+    expect(content).toContain("assertStringContainsString('sso/authorize'");
+
+    // Should parse query params from URL
+    expect(content).toContain('parse_str(parse_url($result, PHP_URL_QUERY)');
+
+    // Should assert visible query params (required and optional)
+    expect(content).toContain("assertSame('test_value', $query['redirect_uri'])");
+    expect(content).toContain("assertSame('test_value', $query['state'])");
+
+    // Should pass optional params in the method call
+    expect(content).toContain("state: 'test_value'");
+
+    // Should assert hidden defaults
+    expect(content).toContain("assertSame('code', $query['response_type'])");
+
+    // Should assert inferred client fields
+    expect(content).toContain("assertArrayHasKey('client_id', $query)");
+  });
+
+  it('generates fixture JSON files', () => {
+    const result = generateTests(spec, ctx);
+
+    const fixture = result.find((f) => f.path.includes('Fixtures/organization.json'));
+    expect(fixture).toBeDefined();
+    const parsed = JSON.parse(fixture!.content);
+    expect(parsed).toHaveProperty('id');
+    expect(parsed).toHaveProperty('name');
+  });
+});

package/test/python/client.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest';
+import { generateClient } from '../../src/python/client.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: 'listOrganizations',
+        httpMethod: 'get',
+        path: '/organizations',
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        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('generateClient', () => {
+  it('generates slim client that subclasses _base_client', () => {
+    const files = generateClient(spec, ctx);
+
+    const clientFile = files.find((f) => f.path === 'src/workos/_client.py');
+    expect(clientFile).toBeDefined();
+
+    const content = clientFile!.content;
+    // Imports from _base_client
+    expect(content).toContain('from ._base_client import');
+    expect(content).toContain('WorkOSClient as _SyncBase');
+    expect(content).toContain('AsyncWorkOSClient as _AsyncBase');
+    // Subclass definitions
+    expect(content).toContain('class WorkOSClient(_SyncBase):');
+    expect(content).toContain('class AsyncWorkOSClient(_AsyncBase):');
+    // Lazy resource accessors via cached_property
+    expect(content).toContain('@functools.cached_property');
+    expect(content).toContain('def organizations(self) -> Organizations:');
+  });
+
+  it('does not contain static HTTP infrastructure', () => {
+    const files = generateClient(spec, ctx);
+    const clientFile = files.find((f) => f.path === 'src/workos/_client.py');
+    const content = clientFile!.content;
+
+    // Static code should NOT be in the generated file
+    expect(content).not.toContain('class _BaseWorkOSClient:');
+    expect(content).not.toContain('def request(');
+    expect(content).not.toContain('def request_page(');
+    expect(content).not.toContain('RETRY_STATUS_CODES');
+    expect(content).not.toContain('Idempotency-Key');
+    expect(content).not.toContain('def _parse_retry_after(');
+    expect(content).not.toContain('def _raise_error(');
+    expect(content).not.toContain('def close(self)');
+    expect(content).not.toContain('def __enter__');
+    expect(content).not.toContain('import httpx');
+  });
+
+  it('does not generate barrel __init__.py (now @oagen-ignore-file)', () => {
+    const files = generateClient(spec, ctx);
+    const barrel = files.find((f) => f.path === 'src/workos/__init__.py');
+    expect(barrel).toBeUndefined();
+  });
+
+  it('does not generate pyproject.toml or py.typed (now in target)', () => {
+    const files = generateClient(spec, ctx);
+    expect(files.find((f) => f.path === 'pyproject.toml')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/workos/py.typed')).toBeUndefined();
+  });
+
+  it('generates service __init__.py', () => {
+    const files = generateClient(spec, ctx);
+
+    const serviceInit = files.find((f) => f.path === 'src/workos/organizations/__init__.py');
+    expect(serviceInit).toBeDefined();
+    expect(serviceInit!.content).toContain('from ._resource import Organizations, AsyncOrganizations');
+  });
+
+  it('generates flat directory structure for services (no nested namespaces)', () => {
+    const nestedSpec: ApiSpec = {
+      ...spec,
+      services: [
+        ...services,
+        {
+          name: 'OrganizationsApiKeys',
+          operations: [
+            {
+              name: 'listOrganizationApiKeys',
+              httpMethod: 'get',
+              path: '/organizations/api_keys',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+
+    const files = generateClient(nestedSpec, { ...ctx, spec: nestedSpec });
+
+    // Service gets its own flat directory (no nesting)
+    const serviceInit = files.find((f) => f.path === 'src/workos/organizations_api_keys/__init__.py');
+    expect(serviceInit).toBeDefined();
+
+    // Client should import from the flat path
+    const clientFile = files.find((f) => f.path === 'src/workos/_client.py');
+    expect(clientFile!.content).toContain('OrganizationsApiKeys');
+  });
+
+  it('does not generate compat shim modules', () => {
+    const files = generateClient(spec, ctx);
+
+    expect(files.find((f) => f.path === 'src/workos/client.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/workos/async_client.py')).toBeUndefined();
+    expect(files.find((f) => f.path === 'src/workos/exceptions.py')).toBeUndefined();
+  });
+
+  it('does not generate user_management helper methods but generates types barrels', () => {
+    const compatSpec: ApiSpec = {
+      ...spec,
+      services: [
+        {
+          name: 'UserManagementUsers',
+          operations: [
+            {
+              name: 'listUsers',
+              httpMethod: 'get',
+              path: '/user_management/users',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+        {
+          name: 'UserManagementAuthentication',
+          operations: [
+            {
+              name: 'authorize',
+              httpMethod: 'get',
+              path: '/user_management/authorize',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+
+    const files = generateClient(compatSpec, { ...ctx, spec: compatSpec });
+    const clientFile = files.find((f) => f.path === 'src/workos/_client.py');
+    // load_sealed_session is now added via @oagen-ignore in the target SDK, not emitter-generated
+    expect(clientFile!.content).not.toContain('def load_sealed_session');
+    // Client has flat accessors, no methods from child services
+    expect(clientFile!.content).not.toContain('def get_authorization_url');
+    expect(clientFile!.content).not.toContain('def get_user(');
+    expect(clientFile!.content).not.toContain('def create_user(');
+  });
+});

package/test/python/enums.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect } from 'vitest';
+import { generateEnums } from '../../src/python/enums.js';
+import type { EmitterContext, ApiSpec, Enum, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+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('generateEnums', () => {
+  it('returns empty for no enums', () => {
+    expect(generateEnums([], ctx)).toEqual([]);
+  });
+
+  it('generates str, Enum class', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+          { name: 'PENDING', value: 'pending' },
+        ],
+      },
+    ];
+
+    const service: 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,
+        },
+      ],
+    };
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service] },
+    });
+    expect(files.length).toBe(1);
+    expect(files[0].content).toContain('from enum import Enum');
+    expect(files[0].content).toContain('class Status(str, Enum):');
+    expect(files[0].content).toContain('    ACTIVE = "active"');
+    expect(files[0].content).toContain('    INACTIVE = "inactive"');
+    expect(files[0].content).toContain('    PENDING = "pending"');
+    expect(files[0].content).toContain('def _missing_(cls, value: object) -> Optional["Status"]:');
+    expect(files[0].content).toContain('unknown = str.__new__(cls, value)');
+    expect(files[0].content).toContain('StatusLiteral: TypeAlias = Literal["active", "inactive", "pending"]');
+  });
+
+  it('places enum in service directory when referenced', () => {
+    const service: Service = {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'listOrganizations',
+          httpMethod: 'get',
+          path: '/organizations',
+          pathParams: [],
+          queryParams: [
+            {
+              name: 'status',
+              type: { kind: 'enum', name: 'OrgStatus' },
+              required: false,
+            },
+          ],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    };
+
+    const enums: Enum[] = [
+      {
+        name: 'OrgStatus',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'INACTIVE', value: 'inactive' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, {
+      ...ctx,
+      spec: { ...emptySpec, services: [service] },
+    });
+    expect(files.length).toBe(1);
+    expect(files[0].path).toBe('src/workos/organizations/models/org_status.py');
+  });
+
+  it('deduplicates values that produce the same string', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Action',
+        values: [
+          { name: 'SIGN_UP', value: 'sign-up' },
+          { name: 'SIGN_UP_2', value: 'sign_up' },
+          { name: 'SIGN_UP_3', value: 'sign up' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    expect(files.length).toBe(1);
+    expect(files[0].content).toContain('class Action(str, Enum):');
+    expect(files[0].content).toContain('SIGN_UP = "sign-up"');
+    expect(files[0].content).toContain('SIGN_UP_2 = "sign_up"');
+    expect(files[0].content).toContain('SIGN_UP_3 = "sign up"');
+  });
+
+  it('generates type alias for structurally identical enums', () => {
+    const enums: Enum[] = [
+      {
+        name: 'ConnectionType',
+        values: [
+          { name: 'SAML', value: 'saml' },
+          { name: 'OIDC', value: 'oidc' },
+        ],
+      },
+      {
+        name: 'ProfileConnectionType',
+        values: [
+          { name: 'SAML', value: 'saml' },
+          { name: 'OIDC', value: 'oidc' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    expect(files.length).toBe(2);
+
+    // Canonical (alphabetically first) should be a full enum
+    const canonical = files.find((f) => f.path.includes('connection_type.py') && !f.path.includes('profile'))!;
+    expect(canonical).toBeDefined();
+    expect(canonical.content).toContain('class ConnectionType(str, Enum):');
+
+    // Alias should import canonical and create assignment alias
+    const alias = files.find((f) => f.path.includes('profile_connection_type.py'))!;
+    expect(alias).toBeDefined();
+    expect(alias.content).toContain('import ConnectionType');
+    expect(alias.content).toContain('ProfileConnectionType: TypeAlias = ConnectionType');
+    expect(alias.content).not.toContain('Literal');
+  });
+
+  it('handles enum with descriptions', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Role',
+        values: [
+          { name: 'ADMIN', value: 'admin', description: 'Administrator role' },
+          { name: 'MEMBER', value: 'member', description: 'Regular member' },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    expect(files.length).toBe(1);
+    expect(files[0].content).toContain('class Role(str, Enum):');
+    expect(files[0].content).toContain('ADMIN = "admin"');
+    expect(files[0].content).toContain('Administrator role');
+  });
+
+  it('preserves canonical enum values from the spec', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Provider',
+        values: [{ name: 'GITHUB_OAUTH', value: 'GithubOAuth' }],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    expect(files[0].content).toContain('"GithubOAuth"');
+    expect(files[0].content).not.toContain('"GitHubOAuth"');
+  });
+
+  it('adds .. deprecated:: docstring for deprecated enum values', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'ACTIVE', value: 'active' },
+          { name: 'OLD_STATUS', value: 'old_status', deprecated: true, description: 'Use ACTIVE instead' },
+          { name: 'LEGACY', value: 'legacy', deprecated: true },
+        ],
+      },
+    ];
+
+    const files = generateEnums(enums, ctx);
+    expect(files.length).toBe(1);
+    const content = files[0].content;
+
+    // Deprecated value with description gets both
+    expect(content).toContain('OLD_STATUS = "old_status"');
+    expect(content).toContain('"""Use ACTIVE instead\n\n    .. deprecated::"""');
+
+    // Deprecated value without description gets just .. deprecated::
+    expect(content).toContain('LEGACY = "legacy"');
+    expect(content).toContain('""".. deprecated::"""');
+
+    // Non-deprecated value should not get a docstring
+    expect(content).toContain('ACTIVE = "active"');
+    const activeIdx = content.indexOf('ACTIVE = "active"');
+    const nextLine = content.slice(activeIdx).split('\n')[1];
+    expect(nextLine).not.toContain('"""');
+  });
+});

package/test/python/errors.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { pythonEmitter } from '../../src/python/index.js';
+import type { EmitterContext } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: { name: 'Test', version: '1.0.0', baseUrl: '', services: [], models: [], enums: [], sdk: defaultSdkBehavior() },
+};
+
+describe('generateErrors', () => {
+  it('returns empty array (errors now hand-maintained in target SDK)', () => {
+    expect(pythonEmitter.generateErrors!(ctx)).toEqual([]);
+  });
+});