@workos/oagen-emitters 0.10.0 → 0.12.0

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","names":[],"sources":["../src/plugin.ts"],"mappings":";;;cAyBa,oBAAA,EAAsB,IAAA,CAAK,WAAA"}
+{"version":3,"file":"plugin.d.mts","names":[],"sources":["../src/plugin.ts"],"mappings":";;;cA0Ba,oBAAA,EAAsB,IAAA,CAAK,WAAA"}

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-H0KhxbN7.mjs";
+import { t as workosEmittersPlugin } from "./plugin-C408Wh-o.mjs";
 export { workosEmittersPlugin };

package/docs/sdk-architecture/rust.md

@@ -0,0 +1,323 @@
+# Rust SDK Architecture
+
+Scenario B (fresh) — no backwards-compatibility constraints.
+Reference idioms drawn from popular Rust SDK ecosystems (e.g., `octocrab`, `stripe-rust`,
+`aws-sdk-rust`) — async-first with `reqwest` + `tokio`, `serde` for serialization,
+`thiserror` for the error hierarchy.
+
+## Architecture Overview
+
+Single crate (e.g., `workos`). All public types are re-exported from the crate root via
+`src/lib.rs`. Consumers use `workos::Client::new(api_key)` and call resource methods like
+`client.organizations().create_organization(params).await?`.
+
+- **Client**: `Client` struct holding an `Arc<ClientInner>` so it is cheap to clone and
+  share across tasks. Constructed via `Client::new(api_key)` or `Client::builder()`.
+- **Resources**: Per-mount-group handle structs (e.g., `OrganizationsResource<'a>`)
+  borrowing the `Client` and exposing methods.
+- **Models**: `#[derive(Debug, Clone, Serialize, Deserialize)]` structs with
+  `#[serde(rename_all = "snake_case")]` and per-field `#[serde(rename = "...")]` when the
+  IR field name does not match the Rust ident.
+- **Enums**: Real Rust `enum`s with `#[serde(rename_all = "snake_case")]` (or per-variant
+  `#[serde(rename = "...")]`) — not string constants.
+- **Params**: One `*Params` struct per operation with `#[serde(skip_serializing_if = "Option::is_none")]`
+  on every optional field. Builders are not generated by default; users construct with
+  struct-init syntax or `..Default::default()`.
+- **Errors**: Single `Error` enum derived with `thiserror::Error` covering `Api`,
+  `Network`, `Decode`, `Builder`, and per-status convenience variants.
+- **Pagination**: A `Pagination<T>` page wrapper plus an async stream iterator
+  (`futures::Stream`) for auto-paging.
+- **HTTP**: `reqwest::Client` (async), JSON via `serde_json`, retries with exponential
+  backoff on 429/5xx (configurable on the client builder).
+
+## Naming Conventions
+
+| IR Name                    | Rust Name                | Context                                          |
+| -------------------------- | ------------------------ | ------------------------------------------------ |
+| `Organization` (model)     | `Organization`           | Struct type                                      |
+| `organization` (file)      | `organization.rs`        | Module file (snake_case)                         |
+| `listUsers` (method)       | `list_users`             | Method (snake_case)                              |
+| `user_id` (field)          | `user_id`                | Struct field (snake_case, no acronym hacks)      |
+| `Status` (enum)            | `Status`                 | Enum type                                        |
+| `active` (enum value)      | `Status::Active`         | Variant: PascalCase                              |
+| `Organizations` (service)  | `OrganizationsResource`  | Resource handle struct                           |
+| `organizations` (accessor) | `client.organizations()` | Method on `Client` returning the resource handle |
+
+### Casing rules
+
+Rust convention: types and enum variants `PascalCase`, fields/methods/modules
+`snake_case`, constants `SCREAMING_SNAKE_CASE`. Acronyms are _not_ preserved — `ID` →
+`id`, `URL` → `url`, `JWT` → `jwt` — matching the standard library and `serde` ecosystem.
+
+## Type Mapping
+
+| IR TypeRef                      | Rust Type                                                                             |
+| ------------------------------- | ------------------------------------------------------------------------------------- |
+| `primitive:string`              | `String`                                                                              |
+| `primitive:string:date`         | `String`                                                                              |
+| `primitive:string:date-time`    | `String`                                                                              |
+| `primitive:string:uuid`         | `String`                                                                              |
+| `primitive:string:binary`       | `Vec<u8>`                                                                             |
+| `primitive:integer`             | `i64`                                                                                 |
+| `primitive:integer:int32`       | `i32`                                                                                 |
+| `primitive:number`              | `f64`                                                                                 |
+| `primitive:boolean`             | `bool`                                                                                |
+| `primitive:unknown`             | `serde_json::Value`                                                                   |
+| `array<T>`                      | `Vec<T>`                                                                              |
+| `map<V>`                        | `std::collections::HashMap<String, V>`                                                |
+| `nullable<T>`                   | `Option<T>`                                                                           |
+| `model:Foo`                     | `Foo`                                                                                 |
+| `enum:Bar`                      | `Bar`                                                                                 |
+| `union<A,B>` (discriminated)    | Rust enum `Either { A(A), B(B) }` with `#[serde(tag = "...")]`                        |
+| `union<A,B>` (no discriminator) | `#[serde(untagged)]` enum                                                             |
+| `literal:"foo"`                 | `String` (default; literal preserved in serde rename only when used as discriminator) |
+
+Optional fields (`required: false`) are wrapped in `Option<...>` independent of nullability.
+
+## Model Pattern
+
+```rust
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Organization {
+    pub id: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    pub created_at: String,
+}
+```
+
+- `Debug` + `Clone` always derived.
+- `Serialize` + `Deserialize` always derived.
+- Optional fields skip serialization when `None` to avoid sending `null` for absent
+  values.
+
+## Enum Pattern
+
+```rust
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Status {
+    Active,
+    Inactive,
+    Pending,
+}
+```
+
+When raw values do not match `snake_case` lowercase variants, per-variant
+`#[serde(rename = "exact_value")]` is emitted. `Copy` is derived only when all variants
+are unit (no payload).
+
+## Resource / Client Pattern
+
+```rust
+// src/client.rs
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct Client {
+    inner: Arc<ClientInner>,
+}
+
+pub(crate) struct ClientInner {
+    pub(crate) http: reqwest::Client,
+    pub(crate) base_url: String,
+    pub(crate) api_key: String,
+}
+
+impl Client {
+    pub fn new(api_key: impl Into<String>) -> Self {
+        Self::builder().api_key(api_key).build()
+    }
+
+    pub fn builder() -> ClientBuilder { ClientBuilder::default() }
+
+    pub fn organizations(&self) -> OrganizationsResource<'_> {
+        OrganizationsResource { client: self }
+    }
+}
+```
+
+```rust
+// src/resources/organizations.rs
+pub struct OrganizationsResource<'a> {
+    pub(crate) client: &'a Client,
+}
+
+impl OrganizationsResource<'_> {
+    pub async fn create_organization(
+        &self,
+        params: CreateOrganizationParams,
+    ) -> Result<Organization, Error> {
+        self.client.request_json(
+            reqwest::Method::POST,
+            "/organizations",
+            Some(&params),
+        ).await
+    }
+}
+```
+
+- Resource methods are `async fn` and return `Result<T, Error>`.
+- Path parameters are positional Rust args; query/body parameters are folded into a
+  single `*Params` struct passed by value.
+- The shared HTTP plumbing (`request_json`, `request_empty`, query string serialization,
+  retry) lives on `ClientInner` so resources stay thin.
+
+## Pagination Pattern
+
+```rust
+#[derive(Debug, Clone, Deserialize)]
+pub struct Page<T> {
+    pub data: Vec<T>,
+    pub list_metadata: ListMetadata,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ListMetadata {
+    pub before: Option<String>,
+    pub after: Option<String>,
+}
+```
+
+A future iteration may add a `futures::Stream`-based auto-pager; v1 returns a single
+page and lets callers loop on `list_metadata.after`.
+
+## Error Pattern
+
+```rust
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("API error {status}: {message}")]
+    Api {
+        status: u16,
+        code: Option<String>,
+        message: String,
+    },
+    #[error("network error: {0}")]
+    Network(#[from] reqwest::Error),
+    #[error("decode error: {0}")]
+    Decode(#[from] serde_json::Error),
+    #[error("invalid request: {0}")]
+    Builder(String),
+}
+```
+
+Status-specific helpers (`is_unauthorized()`, `is_not_found()`, `is_rate_limited()`) are
+provided as inherent methods on `Error`. The `Api` variant always carries the raw HTTP
+status so callers can match on numeric ranges.
+
+## Retry Logic
+
+Retries live on `ClientInner::request`:
+
+- Retry on 429 and 5xx status codes.
+- Exponential backoff with jitter: `base * 2^n + rand(0..jitter)`.
+- Defaults: `max_retries = 3`, `base = 100ms`, `max_delay = 5s` (overridable on
+  `ClientBuilder`).
+- Network errors (`reqwest::Error::is_connect()` / `is_timeout()`) are also retried.
+
+## Test Pattern
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wiremock::matchers::{method, path};
+    use wiremock::{Mock, MockServer, ResponseTemplate};
+
+    #[tokio::test]
+    async fn create_organization_success() {
+        let server = MockServer::start().await;
+        let body = include_str!("../tests/fixtures/organization.json");
+        Mock::given(method("POST")).and(path("/organizations"))
+            .respond_with(ResponseTemplate::new(200).set_body_string(body))
+            .mount(&server).await;
+
+        let client = Client::builder()
+            .api_key("test")
+            .base_url(server.uri())
+            .build();
+        let org = client.organizations()
+            .create_organization(CreateOrganizationParams { name: "Acme".into(), ..Default::default() })
+            .await.unwrap();
+
+        assert_eq!(org.name, "Acme");
+    }
+}
+```
+
+Tests use the built-in `cargo test` harness with `#[tokio::test]` for async cases and
+`wiremock` for HTTP mocking. JSON fixtures live under `tests/fixtures/` and are pulled in
+with `include_str!` so no I/O is required at test time.
+
+## Structural Guidelines
+
+| Concern               | Choice                                                   |
+| --------------------- | -------------------------------------------------------- |
+| Edition               | `2024` (falls back to `2021` if compiler too old)        |
+| HTTP client           | `reqwest` (async, default features minus blocking)       |
+| Async runtime         | `tokio` 1.x with `rt-multi-thread` and `macros` features |
+| JSON                  | `serde` + `serde_json`                                   |
+| Error derive          | `thiserror`                                              |
+| Stream / future utils | `futures` (only when paginated streams are emitted)      |
+| Test framework        | `cargo test` (built-in)                                  |
+| HTTP mocking          | `wiremock` (dev-dependency)                              |
+| Async tests           | `#[tokio::test]`                                         |
+| Linting               | `cargo clippy -- -D warnings`                            |
+| Formatting            | `cargo fmt`                                              |
+| Package manager       | `cargo`                                                  |
+| Build tool            | `cargo`                                                  |
+| Documentation         | Rustdoc (`///` doc comments)                             |
+
+## Directory Structure
+
+```
+{output}/
+├── Cargo.toml
+├── README.md                   (placeholder; only emitted if missing)
+├── src/
+│   ├── lib.rs                  (crate root: re-exports public surface, doc-comment, prelude)
+│   ├── client.rs               (Client, ClientBuilder, ClientInner, request plumbing)
+│   ├── error.rs                (Error enum + helpers)
+│   ├── models/
+│   │   ├── mod.rs              (re-exports each model module)
+│   │   ├── organization.rs
+│   │   └── ...
+│   ├── enums/
+│   │   ├── mod.rs
+│   │   ├── status.rs
+│   │   └── ...
+│   ├── resources/
+│   │   ├── mod.rs              (re-exports each resource handle)
+│   │   ├── organizations.rs
+│   │   └── ...
+│   └── pagination.rs           (Page<T>, ListMetadata)
+└── tests/
+    ├── common/
+    │   └── mod.rs              (shared test helpers, fixture loader)
+    ├── fixtures/
+    │   ├── organization.json
+    │   └── ...
+    └── organizations_test.rs
+```
+
+One file per model and one file per resource. The crate root (`lib.rs`) is the public
+surface that the `rust` extractor reads.
+
+## Auto-generated File Header
+
+Every generated file begins with:
+
+```rust
+// Code generated by oagen. DO NOT EDIT.
+```
+
+`Cargo.toml` uses the TOML-style equivalent (`# Code generated by oagen. DO NOT EDIT.`)
+and JSON fixtures skip the header (`headerPlacement: 'skip'`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.18.0"
+    "@workos/oagen": "^0.18.1"
   }
 }

package/src/go/models.ts

@@ -198,7 +198,16 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     lines.push('');
   }
 
-  // Emit shared PaginationParams struct for list operations to embed
+  // Emit shared PaginationParams struct for list operations to embed.
+  //
+  // The Order field's type is derived from the spec rather than hardcoded:
+  // when every paginated `order` query parameter $refs the same top-level
+  // enum (typically `PaginationOrder` in the WorkOS spec), we emit the typed
+  // enum so callers get compile-time validation. Otherwise we fall back to
+  // *string. The fallback handles older specs that don't lift the enum into a
+  // named component schema.
+  const orderEnumType = detectSharedOrderEnum(ctx.spec.services);
+  const orderGoType = orderEnumType ? `*${className(orderEnumType)}` : '*string';
   lines.push('// PaginationParams contains common pagination parameters for list operations.');
   lines.push('type PaginationParams struct {');
   lines.push('\t// Before is a cursor for reverse pagination.');
@@ -207,8 +216,8 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   lines.push('\tAfter *string `url:"after,omitempty" json:"-"`');
   lines.push('\t// Limit is the maximum number of items to return per page.');
   lines.push('\tLimit *int `url:"limit,omitempty" json:"-"`');
-  lines.push('\t// Order is the sort order for results (asc or desc).');
-  lines.push('\tOrder *string `url:"order,omitempty" json:"-"`');
+  lines.push('\t// Order is the sort order for results.');
+  lines.push(`\tOrder ${orderGoType} \`url:"order,omitempty" json:"-"\``);
   lines.push('}');
   lines.push('');
 
@@ -311,6 +320,42 @@ function lowerFirst(s: string): string {
   return lowerFirstForDoc(s);
 }
 
+/**
+ * If every paginated list operation's `order` query parameter $refs the same
+ * top-level enum, return that enum's IR name. Otherwise return null. When
+ * the spec is consistent this lifts `PaginationParams.Order` from `*string`
+ * to `*PaginationOrder` (or whatever the spec calls it), giving callers
+ * compile-time validation.
+ *
+ * We require strict consistency: if any operation uses a primitive string for
+ * `order`, or two operations reference different enums, we conservatively
+ * stay on `*string` so the shared struct doesn't lie about its accepted
+ * values.
+ */
+function detectSharedOrderEnum(services: Service[]): string | null {
+  let candidate: string | null = null;
+  let sawAny = false;
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (!op.pagination) continue;
+      const orderParam = op.queryParams.find((p) => p.name === 'order');
+      if (!orderParam) continue;
+      sawAny = true;
+      const enumName = unwrapEnumName(orderParam.type);
+      if (!enumName) return null;
+      if (candidate === null) candidate = enumName;
+      else if (candidate !== enumName) return null;
+    }
+  }
+  return sawAny ? candidate : null;
+}
+
+function unwrapEnumName(ref: TypeRef): string | null {
+  if (ref.kind === 'enum') return ref.name;
+  if (ref.kind === 'nullable') return unwrapEnumName(ref.inner);
+  return null;
+}
+
 /**
  * Extract a deprecation reason from a field description.
  * Looks for patterns like "Use X instead", "Replaced by Y", etc.

package/src/index.ts

@@ -5,6 +5,7 @@ export { goEmitter } from './go/index.js';
 export { dotnetEmitter } from './dotnet/index.js';
 export { kotlinEmitter } from './kotlin/index.js';
 export { rubyEmitter } from './ruby/index.js';
+export { rustEmitter } from './rust/index.js';
 
 export { nodeExtractor } from './compat/extractors/node.js';
 export { rubyExtractor } from './compat/extractors/ruby.js';

package/src/php/models.ts

@@ -221,15 +221,19 @@ function generateFromArrayValue(ref: TypeRef, accessor: string): string {
       return generateFromArrayValue(ref.inner, accessor);
     case 'union': {
       // Discriminated union: dispatch via match() on the discriminator
-      // property to call the matching variant's fromArray. Unknown values
-      // pass through as raw arrays so callers can introspect.
+      // property to call the matching variant's fromArray. An unknown
+      // discriminator value would otherwise assign a raw array to a typed
+      // property and crash later with a confusing TypeError, so throw
+      // immediately with the offending value.
       if (ref.discriminator && ref.discriminator.mapping) {
         const entries = Object.entries(ref.discriminator.mapping);
         if (entries.length > 0) {
           const arms = entries
             .map(([value, modelName]) => `'${value}' => ${className(modelName)}::fromArray(${accessor})`)
             .join(', ');
-          return `match (${accessor}['${ref.discriminator.property}'] ?? null) { ${arms}, default => ${accessor} }`;
+          const discProp = ref.discriminator.property;
+          const throwArm = `default => throw new \\UnexpectedValueException(sprintf('Unknown ${discProp}: %s', json_encode(${accessor}['${discProp}'] ?? null)))`;
+          return `match (${accessor}['${discProp}'] ?? null) { ${arms}, ${throwArm} }`;
         }
       }
       const resolved = resolveDegenerateUnion(ref);
@@ -313,6 +317,26 @@ function generateToArrayValue(ref: TypeRef, accessor: string, nullable = false):
     case 'union': {
       const resolved = resolveDegenerateUnion(ref);
       if (resolved) return generateToArrayValue(resolved, accessor, nullable);
+      // Polymorphic union of model variants: PHP dispatches to the concrete
+      // instance's toArray() at runtime, so a single ->toArray() call serializes
+      // any branch correctly without a match here.
+      if (ref.variants.every((v) => v.kind === 'model')) {
+        return `${accessor}${ns}->toArray()`;
+      }
+      // Heterogeneous unions involving models or enums have no uniform
+      // serialization strategy (->toArray() vs ->value vs raw scalar), so fail
+      // at codegen time rather than silently emitting a raw object that breaks
+      // the toArray contract. Pure scalar unions (e.g. string|int) fall
+      // through to the bare accessor below — that is correct.
+      if (ref.variants.some((v) => v.kind === 'model' || v.kind === 'enum')) {
+        const summary = ref.variants
+          .map((v) => (v.kind === 'model' ? `model:${v.name}` : v.kind === 'enum' ? `enum:${v.name}` : v.kind))
+          .join(' | ');
+        throw new Error(
+          `[php emitter] Cannot generate toArray for heterogeneous union: ${summary}. ` +
+            `Unions must be all-model or all-scalar; mixed and all-enum unions are not yet supported.`,
+        );
+      }
       return accessor;
     }
     case 'literal':

package/src/php/resources.ts

@@ -301,9 +301,10 @@ function generateMethod(
     const phpName = fieldName(q.name);
     if (seenDocParams.has(phpName)) continue;
     seenDocParams.add(phpName);
-    // order params with enum defaults are non-nullable (they default to Desc, not null)
-    const isNonNullableOrder = q.name === 'order' && q.type.kind === 'enum';
-    const nullSuffix = !q.required && !isNonNullableOrder && !docType.endsWith('|null') ? '|null' : '';
+    // Spec-defaulted enum params are non-nullable (the signature default is the
+    // enum case, never null). Without a spec default, the param is nullable.
+    const hasEnumDefault = q.default != null && q.type.kind === 'enum';
+    const nullSuffix = !q.required && !hasEnumDefault && !docType.endsWith('|null') ? '|null' : '';
     const prefix = q.deprecated ? '(deprecated) ' : '';
     let desc = q.description ? ` ${prefix}${q.description}` : q.deprecated ? ' (deprecated)' : '';
     if (q.default != null) desc += ` Defaults to ${JSON.stringify(q.default)}.`;
@@ -682,16 +683,14 @@ function buildMethodParams(
     usedNames.add(phpName);
     if (q.required) {
       required.push(`${phpType} $${phpName}`);
-    } else if (q.name === 'order') {
-      // Hardcode order default to desc for pagination consistency
-      if (q.type.kind === 'enum') {
-        const enumType = mapTypeRef(q.type, { qualified: true });
-        const caseName = toPascalCase('desc');
-        optional.push(`${enumType} $${phpName} = ${enumType}::${caseName}`);
-      } else {
-        const nullableType = phpType.startsWith('?') ? phpType : `?${phpType}`;
-        optional.push(`${nullableType} $${phpName} = 'desc'`);
-      }
+    } else if (q.default != null && q.type.kind === 'enum') {
+      // Spec-provided default for an enum-typed param: emit a non-nullable
+      // typed default (e.g. PaginationOrder $order = PaginationOrder::Desc).
+      // Only enums are safe to default this way — primitives stay nullable so
+      // callers can distinguish "unset" from "explicit value".
+      const enumType = mapTypeRef(q.type, { qualified: true });
+      const caseName = toPascalCase(String(q.default));
+      optional.push(`${enumType} $${phpName} = ${enumType}::${caseName}`);
     } else {
       const nullableType = phpType.startsWith('?') ? phpType : `?${phpType}`;
       optional.push(`${nullableType} $${phpName} = null`);
@@ -756,9 +755,10 @@ function buildQueryArray(op: Operation, hiddenParams?: Set<string>): string[] {
     .map((q) => {
       const phpName = fieldName(q.name);
       if (isEnumType(q.type)) {
-        // order params with enum defaults are non-nullable (default to Desc, not null)
-        const isNonNullableOrder = q.name === 'order' && q.type.kind === 'enum';
-        const nullsafe = q.required || isNonNullableOrder ? '' : '?';
+        // Mirrors the signature: enum params with a spec default are
+        // non-nullable, so we can dereference ->value without the nullsafe op.
+        const hasEnumDefault = q.default != null && q.type.kind === 'enum';
+        const nullsafe = q.required || hasEnumDefault ? '' : '?';
         return `'${q.name}' => $${phpName}${nullsafe}->value,`;
       }
       return `'${q.name}' => $${phpName},`;

package/src/plugin.ts

@@ -8,6 +8,7 @@ import { goEmitter } from './go/index.js';
 import { dotnetEmitter } from './dotnet/index.js';
 import { kotlinEmitter } from './kotlin/index.js';
 import { rubyEmitter } from './ruby/index.js';
+import { rustEmitter } from './rust/index.js';
 import { nodeExtractor } from './compat/extractors/node.js';
 import { rubyExtractor } from './compat/extractors/ruby.js';
 import { pythonExtractor } from './compat/extractors/python.js';
@@ -24,7 +25,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const smokeDir = path.resolve(__dirname, '..', 'smoke');
 
 export const workosEmittersPlugin: Pick<OagenConfig, 'emitters' | 'extractors' | 'smokeRunners'> = {
-  emitters: [nodeEmitter, pythonEmitter, phpEmitter, goEmitter, dotnetEmitter, kotlinEmitter, rubyEmitter],
+  emitters: [nodeEmitter, pythonEmitter, phpEmitter, goEmitter, dotnetEmitter, kotlinEmitter, rubyEmitter, rustEmitter],
   extractors: [
     nodeExtractor,
     rubyExtractor,

package/src/python/enums.ts

@@ -1,6 +1,7 @@
-import type { Enum, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
+import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
+import { toUpperSnakeCase } from '@workos/oagen';
 import { className, fileName, buildMountDirMap, dirToModule } from './naming.js';
+import { computeSchemaPlacement } from './shared-schemas.js';
 
 /**
  * Convert a PascalCase class name to a human-readable lowercase string,
@@ -21,14 +22,18 @@ function humanizeClassName(name: string): string {
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
   if (enums.length === 0) return [];
 
-  const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+  // Tests sometimes pass enums that aren't in ctx.spec.enums, so synthesize a
+  // spec view with the passed-in enums to keep the placement logic accurate.
+  const placementSpec = enums === ctx.spec.enums ? ctx.spec : { ...ctx.spec, enums };
+  const placement = computeSchemaPlacement(placementSpec, ctx);
+  const enumToService = placement.enumToService;
   const mountDirMap = buildMountDirMap(ctx);
   const resolveDir = (irService: string | undefined) =>
     irService ? (mountDirMap.get(irService) ?? 'common') : 'common';
   const files: GeneratedFile[] = [];
   const compatAliases = collectCompatEnumAliases(enums, ctx);
 
-  const aliasOf = collectEnumAliasOf(enums);
+  const aliasOf = placement.enumAliases;
 
   for (const enumDef of enums) {
     const service = enumToService.get(enumDef.name);
@@ -260,31 +265,9 @@ export function collectCompatEnumAliases(enums: Enum[], ctx: EmitterContext): Ma
   return aliases;
 }
 
-function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
-  const hashGroups = new Map<string, string[]>();
-  for (const enumDef of enums) {
-    const hash = [...enumDef.values]
-      .map((v) => String(v.value))
-      .sort()
-      .join('|');
-    if (!hashGroups.has(hash)) hashGroups.set(hash, []);
-    hashGroups.get(hash)!.push(enumDef.name);
-  }
-
-  const aliasOf = new Map<string, string>();
-  for (const [, names] of hashGroups) {
-    if (names.length <= 1) continue;
-    const sorted = [...names].sort();
-    const canonical = sorted[0];
-    for (let i = 1; i < sorted.length; i++) {
-      aliasOf.set(sorted[i], canonical);
-    }
-  }
-  return aliasOf;
-}
-
 export function collectGeneratedEnumSymbolsByDir(enums: Enum[], ctx: EmitterContext): Map<string, string[]> {
-  const enumToService = assignEnumsToServices(enums, ctx.spec.services);
+  const placementSpec = enums === ctx.spec.enums ? ctx.spec : { ...ctx.spec, enums };
+  const enumToService = computeSchemaPlacement(placementSpec, ctx).enumToService;
   const mountDirMap = buildMountDirMap(ctx);
   const resolveDir = (irService: string | undefined) =>
     irService ? (mountDirMap.get(irService) ?? 'common') : 'common';
@@ -310,29 +293,3 @@ function enumValueHash(enumDef: Enum): string {
     .sort()
     .join('|');
 }
-
-export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
-  const enumToService = new Map<string, string>();
-  const enumNames = new Set(enums.map((e) => e.name));
-
-  for (const service of services) {
-    for (const op of service.operations) {
-      const refs = new Set<string>();
-      const collect = (ref: any) => {
-        walkTypeRef(ref, { enum: (r: any) => refs.add(r.name) });
-      };
-      if (op.requestBody) collect(op.requestBody);
-      collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
-        collect(p.type);
-      }
-      for (const name of refs) {
-        if (enumNames.has(name) && !enumToService.has(name)) {
-          enumToService.set(name, service.name);
-        }
-      }
-    }
-  }
-
-  return enumToService;
-}