@workos/oagen-emitters 0.14.4 → 0.15.0

package/src/node/index.ts

@@ -23,6 +23,7 @@ import {
   setBaselineSerializedNames,
   setBaselineInterfaceNames,
   setAdoptedModelNames,
+  setDiscriminatedModelNames,
   setStructurallyRenamedDomainNames,
   resolveInterfaceName,
 } from './naming.js';
@@ -341,14 +342,66 @@ function isOwnedPath(relPath: string, policy: LiveSurfacePolicy): boolean {
   return dir !== undefined && policy.ownedServiceDirs.has(dir);
 }
 
+function extractRelativeImportPaths(content: string, fromPath: string): string[] {
+  const dir = path.dirname(fromPath);
+  const paths: string[] = [];
+  const re = /from\s+['"](\.[^'"]+)['"]/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(content)) !== null) {
+    paths.push(path.normalize(path.join(dir, match[1])) + '.ts');
+  }
+  return paths;
+}
+
 function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface: LiveSurface): GeneratedFile[] {
   const out: GeneratedFile[] = [];
   const policy = buildLiveSurfacePolicy(ctx, surface);
+  const filesByPath = new Map(files.map((f) => [f.path, f]));
+  const dependencyAllowedPaths = new Set<string>();
+  const queue: string[] = [];
+
+  for (const f of files) {
+    if (f.integrateTarget === false) continue;
+    if (!canCreateNewPath(f.path, policy)) continue;
+    for (const importPath of extractRelativeImportPaths(f.content, f.path)) {
+      if (
+        filesByPath.has(importPath) &&
+        !canCreateNewPath(importPath, policy) &&
+        !dependencyAllowedPaths.has(importPath)
+      ) {
+        dependencyAllowedPaths.add(importPath);
+        queue.push(importPath);
+      }
+    }
+  }
+
+  while (queue.length > 0) {
+    const relPath = queue.pop()!;
+    const file = filesByPath.get(relPath);
+    if (!file) continue;
+    for (const importPath of extractRelativeImportPaths(file.content, relPath)) {
+      if (
+        filesByPath.has(importPath) &&
+        !canCreateNewPath(importPath, policy) &&
+        !dependencyAllowedPaths.has(importPath)
+      ) {
+        dependencyAllowedPaths.add(importPath);
+        queue.push(importPath);
+      }
+    }
+  }
+
   for (const f of files) {
     const ownedPath = isOwnedPath(f.path, policy);
     if (f.integrateTarget === false) continue;
     if (surface.protectedFiles.has(f.path)) continue;
-    if (policy.hasExistingSdk && !policy.managedPaths.has(f.path) && !canCreateNewPath(f.path, policy)) continue;
+    if (
+      policy.hasExistingSdk &&
+      !policy.managedPaths.has(f.path) &&
+      !canCreateNewPath(f.path, policy) &&
+      !dependencyAllowedPaths.has(f.path)
+    )
+      continue;
 
     // Hand-written files (on disk, no `auto-generated by oagen` header) →
     // drop. The engine would otherwise prepend the header on
@@ -372,7 +425,8 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
       const dir = topLevelDir(f.path);
       const isAdoptedDir = dir !== undefined && policy.adoptedServiceDirs.has(dir);
       const isManagedDir = ownedPath || isAdoptedDir;
-      if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path)) continue;
+      if (surface.files.has(f.path) && !surface.autogenFiles.has(f.path) && !(ownedPath && policy.regenerateOwnedTests))
+        continue;
       if (!isManagedDir && !surface.autogenFiles.has(f.path)) continue;
       if (isManagedDir && !policy.regenerateOwnedTests) continue;
     }
@@ -487,7 +541,9 @@ export const nodeEmitter: Emitter = {
     // name set on ctx so models.ts skips emitting an interface/serializer —
     // the discriminated module owns those paths instead.
     const discPlans = planDiscriminatedModels(enriched, nodeCtx);
-    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = new Set(discPlans.keys());
+    const discriminatedNames = new Set(discPlans.keys());
+    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = discriminatedNames;
+    setDiscriminatedModelNames(discriminatedNames);
     const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
     const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
     return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);

package/src/node/models.ts

@@ -223,6 +223,20 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   // wrapper's interface importing from a file that was never written.
   const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
 
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
+    if (!reachableModels.has(model.name)) continue;
+    if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
+    const canonicalName = dedup.get(model.name);
+    if (canonicalName) {
+      forceGenerate.add(canonicalName);
+      if (interfaceEligibleModels) interfaceEligibleModels.add(canonicalName);
+    }
+  }
+
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
@@ -392,6 +406,7 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       const depName = resolveInterfaceName(dep, ctx);
       const depService = modelToService.get(dep);
       const depDir = resolveDir(depService);
+      const depIsOwned = isNodeOwnedService(ctx, depService);
 
       // When the resolver maps the IR name to a different baseline interface
       // (via `overlayLookup.modelNameByIR` structural match), the import
@@ -400,7 +415,9 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
       // emitter never generates — the canonical baseline file is at a
       // different stem (e.g. `create-audit-log-event-options.interface`).
       const currentFilePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
-      const baselineSrc = (ctx.apiSurface?.interfaces?.[depName] as { sourceFile?: string } | undefined)?.sourceFile;
+      const baselineSrc = depIsOwned
+        ? undefined
+        : (ctx.apiSurface?.interfaces?.[depName] as { sourceFile?: string } | undefined)?.sourceFile;
 
       // Self-reference: the dependency lives in the file we're currently
       // emitting. Skip the import — it's already in scope.
@@ -697,6 +714,13 @@ export function generateSerializers(
   const responseReachableModels = resourceUsage
     ? expandModelRoots(resourceUsage.responseRoots, projectedByName)
     : undefined;
+  // Models reachable from any request — only these need a `serialize<X>`.
+  // A model used solely as a response body can safely be deserialize-only;
+  // emitting its serialize half is both unused and brittle when it contains
+  // legacy nested response models that intentionally have no serialize helper.
+  const requestReachableModels = resourceUsage
+    ? expandModelRoots(resourceUsage.requestRoots, projectedByName)
+    : undefined;
 
   const serializerReachable = computeNonEventReachable(ctx.spec.services, models);
 
@@ -759,6 +783,20 @@ export function generateSerializers(
   // Mirror the interface-emission gate (see `generateModels`).
   const serializerListMetadataNeeded = collectReferencedListMetadataModels(models, serializerNonPaginatedRefs);
 
+  for (const originalModel of models) {
+    const model = projectedByName.get(originalModel.name) ?? originalModel;
+    if (!serializerReachable.has(model.name)) continue;
+    if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
+    const service = modelToService.get(model.name);
+    const isOwnedModel = isNodeOwnedService(ctx, service);
+    if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
+    const canonicalName = dedup.get(model.name);
+    if (canonicalName) {
+      forceGenerateSerializer.add(canonicalName);
+      if (serializerEligibleModels) serializerEligibleModels.add(canonicalName);
+    }
+  }
+
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -781,14 +819,9 @@ export function generateSerializers(
     const responseName = wireInterfaceName(domainName);
     const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
     const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
-    const shouldSkip = shouldSkipSerializeForModel(
-      model,
-      baselineResponse,
-      baselineDomain,
-      dedup,
-      skippedSerializeModels,
-      ctx,
-    );
+    const shouldSkip =
+      (requestReachableModels !== undefined && !requestReachableModels.has(model.name)) ||
+      shouldSkipSerializeForModel(model, baselineResponse, baselineDomain, dedup, skippedSerializeModels, ctx);
     if (shouldSkip) {
       skippedSerializeModels.add(model.name);
     }
@@ -812,27 +845,37 @@ export function generateSerializers(
 
       if (serializerPath === canonSerializerPath) continue;
       if (domainName === canonDomainName) continue;
-      const rel = relativeImport(serializerPath, canonSerializerPath);
-      const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
-      const canonSkipDeserialize =
-        responseReachableModels !== undefined &&
-        !responseReachableModels.has(canonicalName) &&
-        !responseReachableModels.has(model.name);
-      if (canonSkipSerialize && canonSkipDeserialize) continue;
-      const parts: string[] = [];
-      if (!canonSkipDeserialize) {
-        parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
-      }
-      if (!canonSkipSerialize) {
-        parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+
+      const aliasNeedsDeserialize = responseReachableModels === undefined || responseReachableModels.has(model.name);
+      const canonicalHasDeserialize =
+        responseReachableModels === undefined || responseReachableModels.has(canonicalName);
+      const canAliasToCanonical = !aliasNeedsDeserialize || canonicalHasDeserialize;
+      if (canAliasToCanonical) {
+        const rel = relativeImport(serializerPath, canonSerializerPath);
+        const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
+        const canonSkipDeserialize =
+          responseReachableModels !== undefined &&
+          !responseReachableModels.has(canonicalName) &&
+          !responseReachableModels.has(model.name);
+        if (canonSkipSerialize && canonSkipDeserialize) continue;
+        const parts: string[] = [];
+        if (!canonSkipDeserialize) {
+          parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
+        }
+        if (!canonSkipSerialize) {
+          parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+        }
+        const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
+        files.push({
+          path: serializerPath,
+          content: reexportContent,
+          overwriteExisting: true,
+        });
+        continue;
       }
-      const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
-      files.push({
-        path: serializerPath,
-        content: reexportContent,
-        overwriteExisting: true,
-      });
-      continue;
+      // The alias is response-reachable, but the canonical model is
+      // request-only. Generate a local serializer instead of re-exporting a
+      // deserialize helper that the canonical serializer intentionally omits.
     }
 
     const dirName = resolveDir(service);
@@ -906,7 +949,7 @@ export function generateSerializers(
   }
   const liveRootForBarrel = ctx.outputDir ?? ctx.targetDir;
   for (const [dir, stems] of serializersByDir) {
-    if (liveRootForBarrel) {
+    if (liveRootForBarrel && !isNodeOwnedService(ctx, dir)) {
       const serializersDir = path.join(liveRootForBarrel, 'src', dir, 'serializers');
       try {
         for (const entry of fs.readdirSync(serializersDir)) {

package/src/node/naming.ts

@@ -73,6 +73,16 @@ export function isAdoptedModelName(name: string): boolean {
   return adoptedModelNames.has(name);
 }
 
+/**
+ * IR model names handled by the discriminated-models module. These must not
+ * be remapped by the structural matcher because that module emits files and
+ * helpers under the original IR names.
+ */
+let discriminatedModelNames: Set<string> = new Set();
+export function setDiscriminatedModelNames(names: Set<string>): void {
+  discriminatedModelNames = names;
+}
+
 /**
  * Domain names that `resolveInterfaceName` reached via a structural rename
  * — the resolved name differs from the IR model's own name. `wireInterfaceName`
@@ -226,7 +236,10 @@ export function resolveInterfaceName(name: string, ctx: EmitterContext, opts?: {
   const existing = ctx.overlayLookup?.interfaceByName?.get(name);
   if (existing) return existing;
 
-  let inferred = adoptedModelNames.has(name) ? undefined : ctx.overlayLookup?.modelNameByIR?.get(name);
+  let inferred =
+    adoptedModelNames.has(name) || discriminatedModelNames.has(name)
+      ? undefined
+      : ctx.overlayLookup?.modelNameByIR?.get(name);
   if (inferred) {
     if (inferred.startsWith('Serialized')) {
       const stripped = inferred.slice('Serialized'.length);

package/src/node/node-overrides.ts

@@ -1,41 +1,6 @@
 import type { EmitterContext, Model, ResolvedOperation } from '@workos/oagen';
 import { enrichModelsFromSpec } from '../shared/model-utils.js';
-
-type OperationOverride = {
-  methodName?: string;
-  mountOn?: string;
-};
-
-const OPERATION_OVERRIDES: Record<string, OperationOverride> = {
-  'POST /organizations/{organizationId}/groups': {
-    methodName: 'create_group',
-  },
-  'GET /organizations/{organizationId}/groups': {
-    methodName: 'list_groups',
-  },
-  'GET /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'get_group',
-  },
-  'PATCH /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'update_group',
-  },
-  'DELETE /organizations/{organizationId}/groups/{groupId}': {
-    methodName: 'delete_group',
-  },
-  'POST /organizations/{organizationId}/groups/{groupId}/organization-memberships': {
-    methodName: 'add_organization_membership',
-  },
-  'GET /organizations/{organizationId}/groups/{groupId}/organization-memberships': {
-    methodName: 'list_organization_memberships',
-  },
-  'DELETE /organizations/{organizationId}/groups/{groupId}/organization-memberships/{omId}': {
-    methodName: 'remove_organization_membership',
-  },
-  'GET /user_management/organization_memberships/{omId}/groups': {
-    methodName: 'list_groups_for_organization_membership',
-    mountOn: 'UserManagement',
-  },
-};
+import { nodeOptions } from './options.js';
 
 const contextCache = new WeakMap<EmitterContext, EmitterContext>();
 
@@ -88,9 +53,11 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
     return next;
   }
 
+  const configOverrides = nodeOptions(ctx).operationOverrides ?? {};
+
   let opsChanged = false;
   const nextResolved = resolvedOperations.map((resolved) => {
-    const override = OPERATION_OVERRIDES[operationKey(resolved)];
+    const override = configOverrides[operationKey(resolved)];
     if (!override) return resolved;
 
     const methodName = override.methodName ?? resolved.methodName;

package/src/node/options.ts

@@ -1,5 +1,16 @@
 import type { EmitterContext } from '@workos/oagen';
 
+export interface OperationOverride {
+  methodName?: string;
+  mountOn?: string;
+  optionsType?: string;
+  bodyFieldMap?: Record<string, string>;
+  returnType?: string;
+  returnDataProperty?: string;
+  returnTypeImports?: string[];
+  returnExpression?: string;
+}
+
 export interface NodeEmitterOptions {
   /**
    * Existing SDK mode normally drops brand-new paths to avoid large accidental
@@ -21,6 +32,12 @@ export interface NodeEmitterOptions {
    * and fixtures remain hand-owned.
    */
   regenerateOwnedTests?: boolean;
+  /**
+   * Node-specific operation overrides keyed by "METHOD /path".
+   * Allows renaming methods or remounting operations for the Node SDK
+   * without affecting other languages.
+   */
+  operationOverrides?: Record<string, OperationOverride>;
 }
 
 export function nodeOptions(ctx: EmitterContext): NodeEmitterOptions {
@@ -32,10 +49,21 @@ function normalizeServiceName(name: string): string {
   return name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
 }
 
+function ownedLookupNames(name: string): string[] {
+  const names = [name];
+  const baselineDirPrefix = '__baseline_dir__:';
+  if (name.startsWith(baselineDirPrefix)) {
+    names.push(name.slice(baselineDirPrefix.length));
+  }
+  return names;
+}
+
 export function isNodeOwnedService(ctx: EmitterContext, ...names: Array<string | undefined>): boolean {
   const configured = nodeOptions(ctx).ownedServices ?? [];
   if (configured.length === 0) return false;
 
   const owned = new Set(configured.map(normalizeServiceName));
-  return names.some((name) => name !== undefined && owned.has(normalizeServiceName(name)));
+  return names.some((name) =>
+    name !== undefined ? ownedLookupNames(name).some((candidate) => owned.has(normalizeServiceName(candidate))) : false,
+  );
 }