@workos/oagen-emitters 0.18.2 → 0.18.4

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', () => {

package/test/rust/models.test.ts

@@ -119,6 +119,55 @@ describe('rust/models', () => {
     expect(unions.content).toContain('pub enum EventPayloadOneOf {');
   });
 
+  it('relaxes the discriminator field on internally-tagged union variants', () => {
+    // Mirrors the ApiKey `owner` union: serde's `#[serde(tag = "type")]`
+    // consumes `type` as the enum tag and strips it from the variant body, so
+    // a *required* `type` field on the variant struct can never be satisfied
+    // ("missing field `type`"). The emitter must mark it default+skip_serializing.
+    const owner = (name: string, extra: Model['fields'] = []): Model => ({
+      name,
+      fields: [
+        { name: 'type', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        ...extra,
+      ],
+    });
+    const models: Model[] = [
+      {
+        name: 'ApiKey',
+        fields: [
+          {
+            name: 'owner',
+            type: {
+              kind: 'union',
+              variants: [
+                { kind: 'model', name: 'ApiKeyOwner' },
+                { kind: 'model', name: 'UserApiKeyOwner' },
+              ],
+              discriminator: {
+                property: 'type',
+                mapping: { organization: 'ApiKeyOwner', user: 'UserApiKeyOwner' },
+              },
+            },
+            required: true,
+          },
+        ],
+      },
+      owner('ApiKeyOwner'),
+      owner('UserApiKeyOwner', [
+        { name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true },
+      ]),
+    ];
+    const files = generateModels(models, ctx, new UnionRegistry());
+    for (const mod of ['api_key_owner', 'user_api_key_owner']) {
+      const f = files.find((x) => x.path === `src/models/${mod}.rs`)!;
+      expect(f.content).toContain('#[serde(rename = "type", default, skip_serializing)]');
+      expect(f.content).toContain('pub type_: String,');
+      // The non-discriminator field is untouched.
+      expect(f.content).toContain('pub id: String,');
+    }
+  });
+
   it('documents Field.default as a "Defaults to" doc comment', () => {
     const models: Model[] = [
       {