@workos/oagen-emitters 0.18.2 → 0.18.3

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",

package/src/dotnet/fixtures.ts

@@ -1,6 +1,7 @@
 import type { Model, TypeRef, Enum } from '@workos/oagen';
 import { fixtureFileName, fieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
+import { collectNonPaginatedResponseModelNames } from '../shared/model-utils.js';
 
 /**
  * Prefix mapping for generating realistic ID fixture values.
@@ -35,9 +36,19 @@ export function generateFixtures(spec: {
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
   const files: { path: string; content: string }[] = [];
 
+  // List-wrappers are normally represented only by the per-operation
+  // `list_<item>.json` fixtures generated from paginated operations below. But
+  // a wrapper returned by a NON-paginated operation (e.g.
+  // `PUT /authorization/groups/{id}/role_assignments` -> GroupRoleAssignmentList)
+  // is emitted as a real model (see models.ts) and its generated test references
+  // `testdata/<type>.json` (tests.ts). Emit that envelope fixture too, mirroring
+  // the non-wrapper `VersionListResponse` precedent — otherwise the test loads a
+  // file that was never written.
+  const nonPaginatedWrapperRefs = collectNonPaginatedResponseModelNames(spec.services);
+
   for (const model of spec.models) {
     if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedWrapperRefs.has(model.name)) continue;
 
     const fixture = model.fields.length === 0 ? {} : generateModelFixture(model, modelMap, enumMap);
 

package/src/node/resources.ts

@@ -279,6 +279,24 @@ function operationHasOptionsInput(op: Operation, plan: OperationPlan, resolvedOp
   );
 }
 
+// True only when the type is a SINGLE closed object literal (`{ ... }`), not
+// the head of a compound type such as `{ ... } & X` or `{ ... } | Y`. Counting
+// brace depth locates the literal's matching close brace (handling nesting like
+// `{ a: { b: string } }`); any non-whitespace after it means the type is not a
+// pure literal and must be preserved verbatim rather than replaced by a named
+// request interface.
+function isClosedObjectLiteral(type: string): boolean {
+  const t = type.trim();
+  if (!t.startsWith('{')) return false;
+  let depth = 0;
+  for (let i = 0; i < t.length; i++) {
+    const ch = t[i];
+    if (ch === '{') depth++;
+    else if (ch === '}' && --depth === 0) return i === t.length - 1;
+  }
+  return false;
+}
+
 function optionsObjectInfo(
   service: Service,
   method: string,
@@ -300,9 +318,10 @@ function optionsObjectInfo(
     // operation owns a named request-body model, adopt that interface so the
     // method signature, the serializer, and the request model all agree.
     // Named baseline types (`CreateOrganizationApiKeyOptions`) and compound
-    // intersections (`X & { ... }`) are still preserved verbatim.
+    // intersections (`X & { ... }` or `{ ... } & X`) are still preserved
+    // verbatim — only a single, closed object literal is eligible for adoption.
     if (
-      baseline.type.trimStart().startsWith('{') &&
+      isClosedObjectLiteral(baseline.type) &&
       isNodeOwnedService(ctx, service.name, resolveResourceClassName(service, ctx))
     ) {
       const body = extractRequestBodyType(op, ctx);

package/test/node/resources.test.ts

@@ -921,7 +921,7 @@ describe('inline object-literal baseline parameter types', () => {
     ],
   });
 
-  const baselineCtx = (service: Service, models: any[]): EmitterContext => ({
+  const baselineCtx = (service: Service, models: any[], paramType: string = literalType): EmitterContext => ({
     ...ctx,
     spec: { ...emptySpec, services: [service], models },
     emitterOptions: { ownedServices: ['AdminPortal'] },
@@ -933,7 +933,7 @@ describe('inline object-literal baseline parameter types', () => {
             generateLink: [
               {
                 name: 'generateLink',
-                params: [{ name: 'options', type: literalType, passingStyle: 'options_object' }],
+                params: [{ name: 'options', type: paramType, passingStyle: 'options_object' }],
                 returnType: 'Promise<{ link: string }>',
                 async: true,
               },
@@ -1007,6 +1007,35 @@ describe('inline object-literal baseline parameter types', () => {
     expect(content).toContain(`async generateLink(options: ${literalType})`);
     expect(content).not.toContain('import type { {');
   });
+
+  it('keeps a `{ ... } & X` compound intersection inline even with a named request model', () => {
+    // The adoption guard targets a PURE object literal. A baseline param that
+    // LEADS with a literal but is actually a compound intersection
+    // (`{ ... } & WithMetadata`) carries the hand-authored `& X` portion, which
+    // a named-interface swap would silently drop. It must be preserved verbatim
+    // even though the operation has a single named request-body model.
+    const compoundType = `${literalType} & WithMetadata`;
+    const service = adminPortalService({ kind: 'model', name: 'GenerateLinkBody' });
+    const models = [
+      {
+        name: 'GenerateLinkBody',
+        fields: [
+          { name: 'intent', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'organization', type: { kind: 'primitive', type: 'string' }, required: true },
+        ],
+      },
+      { name: 'PortalLink', fields: [{ name: 'link', type: { kind: 'primitive', type: 'string' }, required: true }] },
+    ];
+
+    const result = generateResources([service], baselineCtx(service, models, compoundType));
+    const content = result.find((f) => f.path === 'src/admin-portal/admin-portal.ts')!.content;
+
+    // The compound type (including the `& WithMetadata` tail) survives intact;
+    // it is NOT replaced by the named `GenerateLinkBody` interface.
+    expect(content).toContain(`async generateLink(options: ${compoundType})`);
+    expect(content).not.toContain('async generateLink(options: GenerateLinkBody)');
+    expect(content).not.toContain('import type { {');
+  });
 });
 
 describe('@oagen-ignore region method filtering', () => {