@workos/oagen-emitters 0.17.0 → 0.18.1

package/src/node/resources.ts

@@ -303,9 +303,26 @@ function optionsObjectInfo(
 
   if (!operationHasOptionsInput(op, plan, resolvedOp)) return undefined;
 
+  const resolvedService = resolveResourceClassName(service, ctx);
+  let optionsType = methodOptionsName(method, resolvedService);
+  // A bare `${Method}Options` name (e.g. `GetGroupOptions`) can collide with a
+  // same-named baseline type owned by a DIFFERENT service (for example the
+  // Groups module's `GetGroupOptions`, shaped `{ organizationId, groupId }`).
+  // Reusing it by name would import a foreign shape. When the existing
+  // declaration lives in another service directory, qualify the name with the
+  // service (mirroring the `list` -> `${Service}ListOptions` rule) so this
+  // service generates and imports its own options type.
+  if (method !== 'list') {
+    const baselineFile = baselineTypeSourceFile(ctx, optionsType);
+    const baselineDir = baselineFile?.match(/^src\/([^/]+)\//)?.[1];
+    if (baselineDir && baselineDir !== resolveResourceDir(service, ctx)) {
+      optionsType = `${toPascalCase(resolvedService)}${toPascalCase(method)}Options`;
+    }
+  }
+
   return {
     name: 'options',
-    type: methodOptionsName(method, resolveResourceClassName(service, ctx)),
+    type: optionsType,
     optional: optionsObjectShouldBeOptional(op, plan, resolvedOp),
     generated: true,
   };
@@ -327,6 +344,18 @@ function isValidTypeIdentifier(name: string): boolean {
   return /^[A-Za-z_$][\w$]*$/.test(name);
 }
 
+/**
+ * Extract candidate named type references from a compound type expression such
+ * as `GetAccessTokenOptions & { provider: string }`. PascalCase tokens are type
+ * names worth importing; lowercase tokens are property keys or primitives and
+ * are skipped. The caller only imports the ones that resolve to a known source
+ * file, so unrecognized PascalCase tokens (e.g. `Date`, `Record`) are harmless.
+ */
+function extractNamedTypeRefs(typeExpr: string): string[] {
+  const matches = typeExpr.match(/\b[A-Z][A-Za-z0-9_$]*\b/g) ?? [];
+  return [...new Set(matches)];
+}
+
 function autoPaginatableItemType(returnType: string | undefined): string | undefined {
   // Match both AutoPaginatable<T> and the legacy List<T> pattern so baseline
   // item types are extracted even when the hand-written code predates AutoPaginatable.
@@ -964,16 +993,28 @@ function generateResourceClass(service: Service, ctx: EmitterContext): Generated
 
   const importedTypeNames = new Set<string>();
   for (const optionType of optionObjectTypes) {
-    // Inline object-literal types from the baseline surface are rendered
-    // inline in the method signature — they have no importable name or file.
-    if (!isValidTypeIdentifier(optionType)) continue;
-    if (importedTypeNames.has(optionType)) continue;
-    importedTypeNames.add(optionType);
-    const sourceFile = baselineTypeSourceFile(ctx, optionType);
-    const relPath = sourceFile
-      ? relativeImport(resourcePath, sourceFile)
-      : `./interfaces/${fileName(optionType)}.interface`;
-    lines.push(`import type { ${optionType} } from '${relPath}';`);
+    if (isValidTypeIdentifier(optionType)) {
+      if (importedTypeNames.has(optionType)) continue;
+      importedTypeNames.add(optionType);
+      const sourceFile = baselineTypeSourceFile(ctx, optionType);
+      const relPath = sourceFile
+        ? relativeImport(resourcePath, sourceFile)
+        : `./interfaces/${fileName(optionType)}.interface`;
+      lines.push(`import type { ${optionType} } from '${relPath}';`);
+      continue;
+    }
+    // Compound option types (e.g. a baseline `GetAccessTokenOptions & { provider:
+    // string }`) keep their inline object literal inline, but the named type(s)
+    // they reference must still be imported. Only import names that resolve to a
+    // known source file — inline literals, primitives, and property keys have no
+    // importable source and are skipped.
+    for (const typeName of extractNamedTypeRefs(optionType)) {
+      if (importedTypeNames.has(typeName)) continue;
+      const sourceFile = baselineTypeSourceFile(ctx, typeName) ?? liveSurfaceInterfacePath(typeName);
+      if (!sourceFile) continue;
+      importedTypeNames.add(typeName);
+      lines.push(`import type { ${typeName} } from '${relativeImport(resourcePath, sourceFile)}';`);
+    }
   }
   for (const typeName of returnTypeImports) {
     if (importedTypeNames.has(typeName)) continue;
@@ -1170,7 +1211,10 @@ function generateResourceClass(service: Service, ctx: EmitterContext): Generated
     const baselineMethod = baselineMethodFor(service, method, ctx);
     const optionInfo = optionsObjectInfo(service, method, op, plan, ctx, baselineMethod, resolved);
     if (plan.isPaginated) {
-      const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
+      // Skip deprecated query params: the typed options interface omits them
+      // (the curated baseline drops deprecated params), so the wire serializer
+      // must not reference a field that does not exist on the options type.
+      const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name) && !p.deprecated);
       if (extraParams.length > 0) {
         const optionsName = optionInfo?.type ?? paginatedOptionsName(method, resolvedName);
 

package/src/node/tests.ts

@@ -670,9 +670,11 @@ function buildOptionsObjectTestArg(
   if (plan.isPaginated) {
     entries.push("order: 'desc'");
   }
-  const queryParams = plan.isPaginated
-    ? op.queryParams.filter((param) => !['limit', 'before', 'after', 'order'].includes(param.name))
-    : op.queryParams;
+  const queryParams = (
+    plan.isPaginated
+      ? op.queryParams.filter((param) => !['limit', 'before', 'after', 'order'].includes(param.name))
+      : op.queryParams
+  ).filter((param) => !param.deprecated);
   for (const param of queryParams) {
     const localName = fieldName(param.name);
     const value = queryParamTestValue(param, modelMap);

package/test/node/discriminated-pure-oneof.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+import {
+  detectDiscriminatedShape,
+  generateDiscriminatedFiles,
+  type DiscriminatedPlan,
+} from '../../src/node/discriminated-models.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 };
+
+// A pure `oneOf` discriminated by a boolean `active` const — the Pipes token
+// response shape that previously collapsed into a flat all-optional interface.
+// `RawSchema` is internal to the emitter; the loose typing mirrors the raw
+// `components.schemas` shape `detectDiscriminatedShape` consumes at runtime.
+const rawSchemas: Record<string, any> = {
+  DataIntegrationAccessTokenResponse: {
+    oneOf: [
+      {
+        type: 'object',
+        properties: {
+          active: { type: 'boolean', const: true },
+          access_token: {
+            type: 'object',
+            properties: {
+              object: { type: 'string', const: 'access_token' },
+              access_token: { type: 'string' },
+              expires_at: { type: ['string', 'null'], format: 'date-time' },
+              scopes: { type: 'array', items: { type: 'string' } },
+              missing_scopes: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['object', 'access_token', 'expires_at', 'scopes', 'missing_scopes'],
+          },
+        },
+        required: ['active', 'access_token'],
+      },
+      {
+        type: 'object',
+        properties: {
+          active: { type: 'boolean', const: false },
+          error: { type: 'string', enum: ['not_installed', 'needs_reauthorization'] },
+        },
+        required: ['active', 'error'],
+      },
+    ],
+  },
+};
+
+describe('detectDiscriminatedShape — pure oneOf with boolean discriminator', () => {
+  it('detects a two-variant inline union keyed on the boolean `active`', () => {
+    const shape = detectDiscriminatedShape('DataIntegrationAccessTokenResponse', rawSchemas);
+    expect(shape).not.toBeNull();
+    expect(shape!.inlineUnion).toBe(true);
+    expect(shape!.discriminatorProperty).toBe('active');
+    expect(shape!.variants).toHaveLength(2);
+    expect(shape!.variants.map((v) => v.discriminatorValue).sort()).toEqual(['false', 'true']);
+    expect(shape!.variants.every((v) => v.discriminatorIsBoolean)).toBe(true);
+  });
+
+  it('emits a discriminated union interface (not a flat optional bag)', () => {
+    const shape = detectDiscriminatedShape('DataIntegrationAccessTokenResponse', rawSchemas)!;
+    const plan: DiscriminatedPlan = { shape, modelDir: 'pipes', depDirMap: new Map() };
+    const files = generateDiscriminatedFiles(new Map([['DataIntegrationAccessTokenResponse', plan]]), ctx);
+
+    const iface = files.find((f) => f.path.endsWith('.interface.ts'))!;
+    expect(iface).toBeDefined();
+    // Union alias, two variants, boolean discriminator (unquoted), required fields.
+    expect(iface.content).toContain('export type DataIntegrationAccessTokenResponse =');
+    expect(iface.content).toContain('active: true');
+    expect(iface.content).toContain('active: false');
+    expect(iface.content).toContain('accessToken: DataIntegrationAccessTokenResponseAccessToken');
+    expect(iface.content).toContain("error: 'not_installed' | 'needs_reauthorization'");
+    // No optional discriminator — narrowing must work.
+    expect(iface.content).not.toContain('active?: true');
+
+    const ser = files.find((f) => f.path.endsWith('.serializer.ts'))!;
+    expect(ser.content).toContain('switch (response.active)');
+    expect(ser.content).toContain('case true:');
+    expect(ser.content).toContain('case false:');
+  });
+
+  it('resolves a cross-service inline-object dep to a relative import path', () => {
+    // The nested `access_token` object is a synthetic IR model. Its dep is
+    // carried in snake form (`Parent_field`) but keyed in depDirMap under the
+    // PascalCase IR name. When that model resolves to a different service dir,
+    // collectImports must emit a cross-service path rather than defaulting to
+    // a same-dir import.
+    const shape = detectDiscriminatedShape('DataIntegrationAccessTokenResponse', rawSchemas)!;
+    const depDirMap = new Map<string, string>([['DataIntegrationAccessTokenResponseAccessToken', 'connect']]);
+    const plan: DiscriminatedPlan = { shape, modelDir: 'pipes', depDirMap };
+    const files = generateDiscriminatedFiles(new Map([['DataIntegrationAccessTokenResponse', plan]]), ctx);
+
+    const iface = files.find((f) => f.path.endsWith('.interface.ts'))!;
+    expect(iface.content).toContain(
+      "from '../../connect/interfaces/data-integration-access-token-response-access-token.interface'",
+    );
+  });
+});