@workos/oagen-emitters 0.13.0 → 0.14.1

package/src/rust/models.ts

@@ -140,7 +140,11 @@ function renderField(field: Field, rustField: string, modelName: string, registr
 function renderModelsBarrel(modules: string[]): string {
   const sorted = [...new Set(modules)].sort();
   const lines: string[] = [];
-  for (const m of sorted) lines.push(`pub mod ${m};`);
+  // Declare the modules privately so `pub use crate::models::*` in lib.rs only
+  // re-exports the struct names, not the module names themselves. Otherwise a
+  // module like `models::organization_membership` collides with the same-named
+  // `resources::organization_membership` when both barrels are glob-re-exported.
+  for (const m of sorted) lines.push(`mod ${m};`);
   lines.push('');
   for (const m of sorted) lines.push(`pub use ${m}::*;`);
   return lines.join('\n') + '\n';

package/src/rust/resources.ts

@@ -1317,7 +1317,10 @@ function renderResourcesBarrel(exports: { module: string; struct: string }[]): s
   unique.sort((a, b) => a.module.localeCompare(b.module));
 
   const lines: string[] = [];
-  for (const { module } of unique) lines.push(`pub mod ${module};`);
+  // Declare modules privately — see the matching comment in `models.ts`.
+  // `pub mod resources::organization_membership` would collide with the
+  // same-named module re-exported via `pub use models::*` in lib.rs.
+  for (const { module } of unique) lines.push(`mod ${module};`);
   lines.push('');
   for (const { module, struct } of unique) lines.push(`pub use ${module}::${struct};`);
   return lines.join('\n') + '\n';

package/src/shared/model-utils.ts

@@ -1,10 +1,31 @@
-import type { Model, Field, TypeRef, Enum } from '@workos/oagen';
-import { toSnakeCase } from '@workos/oagen';
+import type { Model, Field, TypeRef, Enum, Service } from '@workos/oagen';
+import { toSnakeCase, toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 // @ts-ignore -- js-yaml has no type declarations in this project
 import { load as yamlLoad } from 'js-yaml';
 
+/**
+ * Collect model names referenced as the return type of any non-paginated
+ * operation. The list-wrapper skip rule below assumes a wrapper is always
+ * replaced by the SDK's pagination machinery — but a few endpoints
+ * (e.g. `GET /vault/v1/kv/{id}/versions`) have a list-envelope response
+ * shape with no pagination params, so the parser leaves them as a plain
+ * model reference. We must still emit those wrappers as regular models;
+ * otherwise the generated resource code references an undefined name.
+ */
+export function collectNonPaginatedResponseModelNames(services: Service[]): Set<string> {
+  const names = new Set<string>();
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (op.pagination) continue;
+      walkTypeRef(op.response, { model: (r) => names.add(r.name) });
+      for (const sr of op.successResponses ?? []) walkTypeRef(sr.type, { model: (r) => names.add(r.name) });
+    }
+  }
+  return names;
+}
+
 /**
  * Detect whether a model is a list wrapper -- the standard paginated
  * list envelope with `data` (array), `list_metadata`, and optionally `object: 'list'`.
@@ -83,7 +104,7 @@ function discoverSpecPath(): string | null {
 let _rawSpecCache: Record<string, any> | null = null;
 let _rawSpecLoaded = false;
 
-function loadRawSpec(): Record<string, any> | null {
+export function loadRawSpec(): Record<string, any> | null {
   if (_rawSpecLoaded) return _rawSpecCache;
   _rawSpecLoaded = true;
   const specPath = discoverSpecPath();
@@ -114,7 +135,10 @@ function lookupRawSchema(name: string): Record<string, any> | null {
  */
 interface SyntheticCollector {
   models: Model[];
-  enums: Array<{ name: string; values: Array<{ value: string; description?: string }> }>;
+  enums: Array<{
+    name: string;
+    values: Array<{ value: string; description?: string }>;
+  }>;
   /** Track names already used to avoid duplicates. */
   usedNames: Set<string>;
 }
@@ -500,7 +524,7 @@ export function detectDiscriminators(models: Model[]): Model[] {
  * Returns a new array of enriched models (original models are not mutated).
  * Synthetic enums are stored internally; retrieve them via `getSyntheticEnums()`.
  */
-export function enrichModelsFromSpec(models: Model[]): Model[] {
+export function enrichModelsFromSpec(models: Model[], enums: Enum[] = []): Model[] {
   const spec = loadRawSpec();
   if (!spec) {
     _lastSyntheticEnums = [];
@@ -515,6 +539,17 @@ export function enrichModelsFromSpec(models: Model[]): Model[] {
     collector.usedNames.add(m.name);
     collector.usedNames.add(toSnakeCase(m.name));
   }
+  // Seed existing IR enum names too. The parser already emits inline enums
+  // like `DataIntegrationAccessTokenResponseError` (PascalCase); without this
+  // seed, the synthetic path would emit a sibling enum named
+  // `DataIntegrationAccessTokenResponse_error`, and language emitters that
+  // PascalCase-normalize identifiers (Ruby, Go, PHP, Python) would collapse
+  // both onto the same class/file path — the second overwrites the first
+  // with a `X = X` self-alias.
+  for (const e of enums) {
+    collector.usedNames.add(e.name);
+    collector.usedNames.add(toSnakeCase(e.name));
+  }
 
   const enriched = models.map((model) => {
     const rawSchema = lookupRawSchema(model.name);
@@ -582,10 +617,17 @@ export function enrichModelsFromSpec(models: Model[]): Model[] {
     return modified ? { ...model, fields: newFields } : model;
   });
 
-  // Convert synthetic enum collector entries to proper Enum objects
+  // Convert synthetic enum collector entries to proper Enum objects. PHP's
+  // emitter (and others built on top of `EnumValue.name`) crash when this
+  // field is missing, so derive it from the value via the same upper-snake
+  // transform the parser uses for declared enums.
   _lastSyntheticEnums = collector.enums.map((e) => ({
     name: e.name,
-    values: e.values.map((v) => ({ value: v.value, description: v.description })),
+    values: e.values.map((v) => ({
+      name: toUpperSnakeCase(String(v.value)),
+      value: v.value,
+      description: v.description,
+    })),
   })) as Enum[];
 
   // Append synthetic models, skipping those whose snake_case name collides

package/test/rust/models.test.ts

@@ -110,7 +110,7 @@ describe('rust/models', () => {
     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;');
+    expect(barrel.content).toContain('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);
@@ -170,8 +170,8 @@ describe('rust/models', () => {
     ];
     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('mod alpha;');
+    expect(barrel.content).toContain('mod beta;');
     expect(barrel.content).toContain('pub use alpha::*;');
   });
 });