@workos/oagen-emitters 0.11.0 → 0.12.0

package/test/rust/enums.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Enum } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateEnums } from '../../src/rust/enums.js';
+
+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('rust/enums', () => {
+  it('emits a non_exhaustive enum with manual Serialize/Deserialize and a fallback variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Status',
+        values: [
+          { name: 'active', value: 'active' },
+          { name: 'inactive', value: 'inactive' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/status.rs')!;
+    expect(f.content).toContain('pub enum Status {');
+    expect(f.content).toContain('Active,');
+    expect(f.content).toContain('Inactive,');
+    expect(f.content).toContain('#[non_exhaustive]');
+    expect(f.content).toContain('Unknown(String),');
+    expect(f.content).toContain('impl Serialize for Status');
+    expect(f.content).toContain("impl<'de> Deserialize<'de> for Status");
+    expect(f.content).toContain('Self::Active => "active"');
+    expect(f.content).toContain('Self::Inactive => "inactive"');
+    // No derive(Serialize/Deserialize) — they're hand-written.
+    expect(f.content).not.toContain('Serialize, Deserialize)]');
+  });
+
+  it('round-trips non-snake-case wire values through canonical strings', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Mode',
+        values: [
+          { name: 'kebab-case', value: 'kebab-case' },
+          { name: 'mixedCase', value: 'mixedCase' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/mode.rs')!;
+    // FromStr matches the original wire string; as_str returns it back.
+    expect(f.content).toContain('"kebab-case" => Self::KebabCase');
+    expect(f.content).toContain('"mixedCase" => Self::MixedCase');
+    expect(f.content).toContain('Self::KebabCase => "kebab-case"');
+    expect(f.content).toContain('Self::MixedCase => "mixedCase"');
+  });
+
+  it('collapses alias wire values into a single canonical variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'Trigger',
+        values: [
+          { name: 'sign-up', value: 'sign-up' },
+          { name: 'sign_up', value: 'sign_up' },
+          { name: 'sign up', value: 'sign up' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/trigger.rs')!;
+    // One Rust variant for all three aliases.
+    expect(f.content.match(/^\s+SignUp,$/m)).not.toBeNull();
+    // Canonical wire value is the first one seen.
+    expect(f.content).toContain('Self::SignUp => "sign-up"');
+    // Every alias deserializes into the same variant.
+    expect(f.content).toContain('"sign-up" => Self::SignUp');
+    expect(f.content).toContain('"sign_up" => Self::SignUp');
+    expect(f.content).toContain('"sign up" => Self::SignUp');
+  });
+
+  it('falls back to a non-Unknown name when the spec defines an Unknown variant', () => {
+    const enums: Enum[] = [
+      {
+        name: 'State',
+        values: [
+          { name: 'unknown', value: 'unknown' },
+          { name: 'ready', value: 'ready' },
+        ],
+      },
+    ];
+    const files = generateEnums(enums, ctx);
+    const f = files.find((x) => x.path === 'src/enums/state.rs')!;
+    expect(f.content).toContain('Unknown,');
+    expect(f.content).toContain('Unrecognized(String),');
+  });
+
+  it('skips empty enums', () => {
+    const enums: Enum[] = [{ name: 'Empty', values: [] }];
+    const files = generateEnums(enums, ctx);
+    expect(files.find((f) => f.path === 'src/enums/empty.rs')).toBeUndefined();
+  });
+
+  it('always emits a barrel even when no enums', () => {
+    const files = generateEnums([], ctx);
+    expect(files).toHaveLength(1);
+    expect(files[0]!.path).toBe('src/enums/mod.rs');
+  });
+});

package/test/rust/manifest.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { buildOperationsMap } from '../../src/rust/manifest.js';
+
+const spec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [
+    {
+      name: 'Organizations',
+      operations: [
+        {
+          name: 'createOrganization',
+          httpMethod: 'post',
+          path: '/organizations',
+          pathParams: [],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+        {
+          name: 'getOrganization',
+          httpMethod: 'get',
+          path: '/organizations/{id}',
+          pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+          queryParams: [],
+          headerParams: [],
+          response: { kind: 'primitive', type: 'unknown' },
+          errors: [],
+          injectIdempotencyKey: false,
+        },
+      ],
+    },
+  ],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec,
+  resolvedOperations: spec.services.flatMap((service) =>
+    service.operations.map((operation) => ({
+      service,
+      operation,
+      methodName: operation.name,
+      mountOn: service.name,
+      defaults: {},
+      inferFromClient: [],
+      urlBuilder: false,
+    })),
+  ),
+};
+
+describe('rust/manifest', () => {
+  it('maps each HTTP operation to an SDK method + service accessor', () => {
+    const map = buildOperationsMap(spec, ctx);
+    expect(map['POST /organizations']).toEqual({
+      sdkMethod: 'create_organization',
+      service: 'organizations',
+    });
+    expect(map['GET /organizations/{id}']).toEqual({
+      sdkMethod: 'get_organization',
+      service: 'organizations',
+    });
+  });
+});

package/test/rust/models.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateModels } from '../../src/rust/models.js';
+import { generateClient } from '../../src/rust/client.js';
+import { UnionRegistry } from '../../src/rust/type-map.js';
+
+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('rust/models', () => {
+  it('emits only an empty barrel when no models', () => {
+    const files = generateModels([], ctx, new UnionRegistry());
+    expect(files).toHaveLength(1);
+    expect(files[0]!.path).toBe('src/models/mod.rs');
+  });
+
+  it('generates a struct with required and optional fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'metadata',
+            type: { kind: 'map', valueType: { kind: 'primitive', type: 'string' } },
+            required: false,
+          },
+        ],
+      },
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    expect(files.length).toBeGreaterThanOrEqual(2); // model + barrel
+    const orgFile = files.find((f) => f.path === 'src/models/organization.rs')!;
+    expect(orgFile).toBeDefined();
+    const content = orgFile.content;
+    expect(content).toContain('use serde::{Deserialize, Serialize};');
+    expect(content).toContain('pub struct Organization {');
+    expect(content).toContain('pub id: String,');
+    expect(content).toContain('pub name: String,');
+    expect(content).toContain('pub metadata: Option<std::collections::HashMap<String, String>>,');
+    expect(content).toContain('#[derive(Debug, Clone, Serialize, Deserialize)]');
+  });
+
+  it('renames struct fields when serde wire name differs', () => {
+    const models: Model[] = [
+      {
+        name: 'User',
+        fields: [{ name: 'userId', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    const userFile = files.find((f) => f.path === 'src/models/user.rs')!;
+    expect(userFile.content).toContain('#[serde(rename = "userId")]');
+    expect(userFile.content).toContain('pub user_id: String,');
+  });
+
+  it('skips serializing None for optional fields', () => {
+    const models: Model[] = [
+      {
+        name: 'Maybe',
+        fields: [{ name: 'value', type: { kind: 'primitive', type: 'string' }, required: false }],
+      },
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    const f = files.find((x) => x.path === 'src/models/maybe.rs')!;
+    expect(f.content).toContain('#[serde(skip_serializing_if = "Option::is_none", default)]');
+    expect(f.content).toContain('pub value: Option<String>,');
+  });
+
+  it('synthesises a _unions module when a model has an inline union field', () => {
+    const models: Model[] = [
+      {
+        name: 'Event',
+        fields: [
+          {
+            name: 'payload',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'UserCreated' },
+                { kind: 'model', name: 'UserDeleted' },
+              ],
+              discriminator: {
+                property: 'event',
+                mapping: { 'user.created': 'UserCreated', 'user.deleted': 'UserDeleted' },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+    ];
+    const registry = new UnionRegistry();
+    const files = generateModels(models, ctx, registry);
+    const event = files.find((f) => f.path === 'src/models/event.rs')!;
+    expect(event.content).toContain('pub payload: EventPayloadOneOf,');
+    const barrel = files.find((f) => f.path === 'src/models/mod.rs')!;
+    expect(barrel.content).toContain('pub mod _unions;');
+    // The _unions.rs file is rendered by generateClient (the final structural
+    // pass) so resource-side body unions can join the same registry.
+    const clientFiles = generateClient(emptySpec, ctx, registry);
+    const unions = clientFiles.find((f) => f.path === 'src/models/_unions.rs')!;
+    expect(unions.content).toContain('#[serde(tag = "event")]');
+    expect(unions.content).toContain('pub enum EventPayloadOneOf {');
+  });
+
+  it('emits a barrel re-exporting each module', () => {
+    const models: Model[] = [
+      {
+        name: 'Alpha',
+        fields: [{ name: 'x', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'Beta',
+        fields: [{ name: 'y', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    const barrel = files.find((f) => f.path === 'src/models/mod.rs')!;
+    expect(barrel.content).toContain('pub mod alpha;');
+    expect(barrel.content).toContain('pub mod beta;');
+    expect(barrel.content).toContain('pub use alpha::*;');
+  });
+});

package/test/rust/resources.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import { generateResources } from '../../src/rust/resources.js';
+import { UnionRegistry } from '../../src/rust/type-map.js';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+/**
+ * Build a resolved-operations-aware context. The Rust emitter groups
+ * operations by `mountOn`, which the resolver populates; tests that want to
+ * exercise the per-resource emitter need to seed those entries themselves.
+ */
+function ctxWithResolved(services: Service[]): EmitterContext {
+  return {
+    ...ctx,
+    spec: { ...emptySpec, services },
+    resolvedOperations: services.flatMap((service) =>
+      service.operations.map((operation) => ({
+        service,
+        operation,
+        methodName: operation.name,
+        mountOn: service.name,
+        defaults: {},
+        inferFromClient: [],
+        urlBuilder: false,
+      })),
+    ),
+  };
+}
+
+describe('rust/resources', () => {
+  it('skips services with no operations', () => {
+    const services: Service[] = [{ name: 'Empty', operations: [] }];
+    const files = generateResources(services, ctxWithResolved(services), new UnionRegistry());
+    expect(files.find((f) => f.path.startsWith('src/resources/empty'))).toBeUndefined();
+  });
+
+  it('emits a resource struct with async methods', () => {
+    const services: Service[] = [
+      {
+        name: 'Organizations',
+        operations: [
+          {
+            name: 'createOrganization',
+            httpMethod: 'post',
+            path: '/organizations',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'Organization' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const files = generateResources(services, ctxWithResolved(services), new UnionRegistry());
+    const f = files.find((x) => x.path === 'src/resources/organizations.rs')!;
+    expect(f.content).toContain("pub struct OrganizationsApi<'a> {");
+    expect(f.content).toContain("pub(crate) client: &'a Client,");
+    expect(f.content).toContain('pub async fn create_organization(');
+    expect(f.content).toContain(' -> Result<Organization, Error>');
+    expect(f.content).toContain('http::Method::POST');
+  });
+
+  it('treats request body as required by default and passes Some(&body)', () => {
+    const services: Service[] = [
+      {
+        name: 'Issues',
+        operations: [
+          {
+            name: 'createIssue',
+            httpMethod: 'post',
+            path: '/issues',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateIssueRequest' },
+            response: { kind: 'model', name: 'Issue' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const f = generateResources(services, ctxWithResolved(services), new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/issues.rs',
+    )!;
+    expect(f.content).toContain('pub struct CreateIssueParams {');
+    expect(f.content).toContain('pub body: CreateIssueRequest,');
+    expect(f.content).not.toContain('pub body: Option<CreateIssueRequest>');
+    expect(f.content).toContain('Some(&params.body)');
+    // Required body forbids the Default derive.
+    expect(f.content).toContain('#[derive(Debug, Clone, Serialize)]');
+  });
+
+  it('treats nullable request body as optional and passes params.body.as_ref()', () => {
+    const services: Service[] = [
+      {
+        name: 'Issues',
+        operations: [
+          {
+            name: 'updateIssue',
+            httpMethod: 'patch',
+            path: '/issues/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+            queryParams: [],
+            headerParams: [],
+            requestBody: {
+              kind: 'nullable',
+              inner: { kind: 'model', name: 'UpdateIssueRequest' },
+            },
+            response: { kind: 'model', name: 'Issue' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const f = generateResources(services, ctxWithResolved(services), new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/issues.rs',
+    )!;
+    expect(f.content).toContain('pub body: Option<UpdateIssueRequest>,');
+    expect(f.content).toContain('params.body.as_ref()');
+    expect(f.content).toContain('#[derive(Debug, Clone, Default, Serialize)]');
+  });
+
+  it('renders multi-line operation descriptions as multi-line doc comments', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          {
+            name: 'listUsers',
+            description: 'List all users.\n\nSupports cursor pagination via `after`.',
+            httpMethod: 'get',
+            path: '/users',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'UsersList' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const f = generateResources(services, ctxWithResolved(services), new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/users.rs',
+    )!;
+    expect(f.content).toContain('    /// List all users.');
+    expect(f.content).toContain('    ///');
+    expect(f.content).toContain('    /// Supports cursor pagination via `after`.');
+  });
+
+  it('reads inferFromClient body fields from the runtime client', () => {
+    const services: Service[] = [
+      {
+        name: 'UserManagement',
+        operations: [
+          {
+            name: 'authenticate',
+            httpMethod: 'post',
+            path: '/user_management/authenticate',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'AuthenticateResponse' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const baseCtx = ctxWithResolved(services);
+    const ctxWithWrapper: EmitterContext = {
+      ...baseCtx,
+      resolvedOperations: baseCtx.resolvedOperations!.map((r) => ({
+        ...r,
+        wrappers: [
+          {
+            name: 'authenticate_with_code',
+            targetVariant: 'AuthorizationCodeSessionAuthenticateRequest',
+            defaults: { grant_type: 'authorization_code' },
+            inferFromClient: ['client_id', 'client_secret'],
+            exposedParams: ['code'],
+            optionalParams: [],
+            responseModelName: null,
+          },
+        ],
+      })),
+    };
+    const f = generateResources(services, ctxWithWrapper, new UnionRegistry()).find(
+      (x) => x.path === 'src/resources/user_management.rs',
+    )!;
+    // Inferred fields read from the runtime client, not empty literals.
+    expect(f.content).toContain('"client_id": self.client.client_id()');
+    expect(f.content).toContain('"client_secret": self.client.api_key()');
+    expect(f.content).not.toContain('"client_id": "",');
+    expect(f.content).not.toContain('"client_secret": "",');
+    // Defaults are still emitted as literal JSON values.
+    expect(f.content).toContain('"grant_type": "authorization_code"');
+  });
+
+  it('interpolates path parameters via format!', () => {
+    const services: Service[] = [
+      {
+        name: 'Users',
+        operations: [
+          {
+            name: 'getUser',
+            httpMethod: 'get',
+            path: '/users/{id}',
+            pathParams: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'User' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+    const files = generateResources(services, ctxWithResolved(services), new UnionRegistry());
+    const f = files.find((x) => x.path === 'src/resources/users.rs')!;
+    expect(f.content).toContain('let id = crate::client::path_segment(id);');
+    expect(f.content).toContain('let path = format!("/users/{id}");');
+    expect(f.content).toContain('pub async fn get_user(&self, id: &str');
+  });
+});

package/test/rust/type-map.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import type { TypeRef, UnionType } from '@workos/oagen';
+import { mapTypeRef, UnionRegistry } from '../../src/rust/type-map.js';
+
+describe('rust/type-map', () => {
+  it('falls back to serde_json::Value for non-discriminated unions when no registry', () => {
+    const u: UnionType = {
+      kind: 'union',
+      variants: [
+        { kind: 'model', name: 'Foo' },
+        { kind: 'model', name: 'Bar' },
+      ],
+    };
+    expect(mapTypeRef(u)).toBe('serde_json::Value');
+  });
+
+  it('synthesises a named enum when a registry is provided', () => {
+    const reg = new UnionRegistry();
+    const u: TypeRef = {
+      kind: 'union',
+      variants: [
+        { kind: 'model', name: 'Foo' },
+        { kind: 'model', name: 'Bar' },
+      ],
+    };
+    const name = mapTypeRef(u, { hint: 'WidgetThing', registry: reg });
+    expect(name).toBe('WidgetThingOneOf');
+    const body = reg.render();
+    expect(body).toContain('#[serde(untagged)]');
+    expect(body).toContain('pub enum WidgetThingOneOf {');
+    expect(body).toContain('Foo(Foo),');
+    expect(body).toContain('Bar(Bar),');
+  });
+
+  it('emits a tagged enum when the union has a discriminator', () => {
+    const reg = new UnionRegistry();
+    const u: TypeRef = {
+      kind: 'union',
+      variants: [
+        { kind: 'model', name: 'CatEvent' },
+        { kind: 'model', name: 'DogEvent' },
+      ],
+      discriminator: {
+        property: 'event',
+        mapping: { 'cat.created': 'CatEvent', 'dog.created': 'DogEvent' },
+      },
+    };
+    mapTypeRef(u, { hint: 'EventPayload', registry: reg });
+    const body = reg.render();
+    expect(body).toContain('#[serde(tag = "event")]');
+    expect(body).toContain('pub enum EventPayloadOneOf {');
+  });
+
+  it('deduplicates structurally identical unions to a single type', () => {
+    const reg = new UnionRegistry();
+    const u: TypeRef = {
+      kind: 'union',
+      variants: [
+        { kind: 'model', name: 'A' },
+        { kind: 'model', name: 'B' },
+      ],
+    };
+    const a = mapTypeRef(u, { hint: 'First', registry: reg });
+    const b = mapTypeRef(u, { hint: 'Second', registry: reg });
+    expect(a).toBe(b);
+    expect(reg.size()).toBe(1);
+  });
+
+  it('collapses single-variant unions to the inner type', () => {
+    const reg = new UnionRegistry();
+    const u: TypeRef = {
+      kind: 'union',
+      variants: [{ kind: 'primitive', type: 'string' }],
+    };
+    expect(mapTypeRef(u, { hint: 'X', registry: reg })).toBe('String');
+    expect(reg.size()).toBe(0);
+  });
+
+  it('maps int32 format to i32 and float to f32', () => {
+    expect(mapTypeRef({ kind: 'primitive', type: 'integer', format: 'int32' })).toBe('i32');
+    expect(mapTypeRef({ kind: 'primitive', type: 'number', format: 'float' })).toBe('f32');
+  });
+});