@workos/oagen 0.23.0 → 0.24.1

package/dist/cli/index.mjs

@@ -2353,6 +2353,10 @@ function extractRequestBody(body, op, inlineModels) {
 		return {};
 	}
 	const contextName = cleanSchemaName(op?.operationId ? toPascalCase(normalizeOperationIdForNaming(op.operationId)) + "Request" : "RequestBody");
+	if (schema.oneOf && schema.discriminator) {
+		const merged = flattenDiscriminatedUnionBody(schema);
+		if (merged) schema = merged;
+	}
 	if (schema.properties && (schema.type === "object" || !schema.type)) {
 		const requiredSet = new Set(schema.required ?? []);
 		const fields = [];
@@ -2418,6 +2422,67 @@ function extractRequestBody(body, op, inlineModels) {
 		encoding
 	};
 }
+/**
+* Fold a discriminated-union request body into the equivalent single object so
+* its fields can be spread into method arguments instead of forcing callers to
+* construct an opaque union.
+*
+* The result is the union of every variant's properties: the discriminator is
+* collapsed to an enum of the pinned const values, and any field that isn't
+* present-and-required in *every* variant becomes optional (it varies by
+* branch, so it can't be unconditionally required). The discriminator itself is
+* always required. This mirrors what a spec author would write by hand to model
+* the same shape as a flat object.
+*
+* Returns null — leaving the union intact — unless the body is a clean
+* inline-object discriminated union: a variant that is a `$ref`, a non-object,
+* or that doesn't pin the discriminator to a string const can't be safely
+* merged. Gating on an *explicit* `discriminator` keeps undiscriminated `oneOf`
+* bodies untouched.
+*/
+function flattenDiscriminatedUnionBody(schema) {
+	const discProp = schema.discriminator?.propertyName;
+	if (!discProp || !Array.isArray(schema.oneOf) || schema.oneOf.length === 0) return null;
+	const variants = schema.oneOf;
+	const discValues = [];
+	let discPropSchema;
+	for (const variant of variants) {
+		if (variant.$ref || !variant.properties || !(variant.type === "object" || variant.type === void 0)) return null;
+		const dp = variant.properties[discProp];
+		const constVal = typeof dp?.const === "string" ? dp.const : Array.isArray(dp?.enum) && dp.enum.length === 1 && typeof dp.enum[0] === "string" ? dp.enum[0] : void 0;
+		if (constVal === void 0) return null;
+		if (!discValues.includes(constVal)) discValues.push(constVal);
+		if (!discPropSchema) discPropSchema = dp;
+	}
+	const variantCount = variants.length;
+	const mergedProps = {};
+	const requiredCounts = {};
+	const order = [discProp];
+	for (const variant of variants) {
+		const required = new Set(variant.required ?? []);
+		for (const [name, propSchema] of Object.entries(variant.properties)) {
+			if (name === discProp || !propSchema) continue;
+			if (!(name in mergedProps)) {
+				mergedProps[name] = propSchema;
+				order.push(name);
+			}
+			if (required.has(name)) requiredCounts[name] = (requiredCounts[name] ?? 0) + 1;
+		}
+	}
+	mergedProps[discProp] = {
+		type: "string",
+		enum: discValues,
+		...discPropSchema?.description ? { description: discPropSchema.description } : {}
+	};
+	const properties = {};
+	for (const name of order) properties[name] = mergedProps[name];
+	return {
+		type: "object",
+		properties,
+		required: order.filter((name) => name === discProp || requiredCounts[name] === variantCount),
+		...schema.description ? { description: schema.description } : {}
+	};
+}
 /** Derive a unique variant name for a oneOf inline model. */
 function deriveOneOfVariantName(variant, baseName, existingModels) {
 	if (variant.properties) {
@@ -5714,6 +5779,58 @@ function resolveResponseModelName(op) {
 	return null;
 }
 //#endregion
+//#region src/engine/scoped-services.ts
+/**
+* Validate a `--services` selection and return it as a set of POST-MOUNT service
+* names for emitters to scope on.
+*
+* Scoped generation does NOT filter the IR: model placement, dedup/aliasing, and
+* shared-schema decisions are global computations over the full service/model set
+* (filtering them churns shared `common/` files). Instead the full spec flows to
+* the emitters unchanged and this set is passed as `ctx.scopedServices`; each
+* emitter gates only its per-service resource/test emission on it.
+*
+* Matching is on the POST-MOUNT name. Mount resolution never mutates
+* `spec.services` — the post-mount target lives on `ResolvedOperation.mountOn`
+* (`mountOn = hint?.mountOn ?? mountRules[service.name] ?? service.name`) — so the
+* post-mount name of a source service is derived here as
+* `mountRules[service.name] ?? service.name`. Selecting a target (e.g.
+* `DirectorySync`) is valid because every source tag that mounts into it
+* (`DirectoryUsers`, `DirectoryGroups`, …) shares that post-mount name, and the
+* emitters group resources by mount, so all siblings emit together.
+*
+* @param spec - The parsed API spec (never mutated; never filtered).
+* @param selected - Post-mount service names from `--services` (normalized/trimmed).
+* @param mountRules - Source-service-name → post-mount-target mappings.
+* @returns The validated selection as a `Set` of post-mount names.
+* @throws A `ConfigError` listing valid post-mount names when a selection is
+*   unknown — scoped generation never silently emits the wrong set.
+*/
+/**
+* Canonicalize a service name to a casing/separator-insensitive key so that
+* `MultiFactorAuth` (post-mount IR name), `multi_factor_auth` (snake-cased
+* manifest record), and `multiFactorAuth` (camel-cased manifest record) all
+* collapse to `multifactorauth`. Used to match a spec service against the
+* services a prior manifest recorded as already on disk, where the casing of
+* the recorded `service` field varies per emitter.
+*/
+function canonicalServiceKey(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function resolveScopedServices(spec, selected, mountRules) {
+	const mounts = mountRules ?? {};
+	const postMountName = (name) => mounts[name] ?? name;
+	const validPostMount = new Set(spec.services.map((s) => postMountName(s.name)));
+	const selectedSet = new Set(selected);
+	const unknown = [...selectedSet].filter((s) => !validPostMount.has(s));
+	if (unknown.length > 0) {
+		const err = /* @__PURE__ */ new Error(`Unknown --services: ${unknown.sort().join(", ")}. Valid post-mount services: ${[...validPostMount].sort().join(", ")}`);
+		err.name = "ConfigError";
+		throw err;
+	}
+	return selectedSet;
+}
+//#endregion
 //#region src/engine/generate-files.ts
 function buildEmitterContext(spec, options) {
 	const resolvedOperations = resolveOperations(spec, options.operationHints, options.mountRules);
@@ -5738,11 +5855,32 @@ function buildEmitterContext(spec, options) {
 		targetDir: options.target,
 		priorTargetManifestPaths: options.priorTargetManifestPaths,
 		scopedServices: options.scopedServices,
+		presentServiceKeys: options.presentServiceKeys,
 		scopedModelNames,
 		scopedEnumNames
 	};
 }
 /**
+* The services an aggregate (barrel/client/test) generator may reference in a
+* scoped run: the selected services plus every service the prior manifest
+* recorded as already on disk. A service the spec just added that is neither
+* selected nor already generated is excluded — otherwise the client/barrels
+* would import a resource/model whose file this run does not emit (the orphaned
+* `agents/__init__.py → ._resource` class of build break).
+*
+* Outside a scoped run (full generation), every service is in surface.
+*/
+function aggregateSurfaceServices(spec, ctx) {
+	const scope = ctx.scopedServices;
+	if (!scope || scope.size === 0) return spec.services;
+	const present = ctx.presentServiceKeys ?? /* @__PURE__ */ new Set();
+	const postMountOf = (service) => ctx.resolvedOperations?.find((r) => r.service.name === service.name)?.mountOn ?? service.name;
+	return spec.services.filter((s) => {
+		const postMount = postMountOf(s);
+		return scope.has(postMount) || present.has(canonicalServiceKey(postMount));
+	});
+}
+/**
 * Collect model and enum names transitively referenced by service operations.
 * Walks operation parameters, request bodies, responses, and pagination item
 * types, then chases model field references until the set stabilizes.
@@ -5807,27 +5945,38 @@ function isDiscriminatedModel(model) {
 /**
 * Collect all generated files from an emitter (no headers, no path prefixes).
 *
-* In a scoped (`--services`) run the spec is NOT filtered: every generator runs
-* over the full spec so model placement, dedup, the root client, and all
-* aggregate/barrel files are byte-identical to a full run (and a brand-new
-* selected service is wired into the client automatically). The emitters
-* themselves consult `ctx.scopedServices` to emit only the selected services'
-* per-service resource/test files.
+* A full run emits over the whole spec. A scoped (`--services`) run still emits
+* model placement, dedup, the root client, and aggregate/barrel files
+* byte-identically for every service ALREADY on disk (plus the brand-new
+* selected service, which is wired into the client automatically) — but it
+* narrows that surface to `selected ∪ already-on-disk` services
+* (`aggregateSurfaceServices`). A service the spec just added that is neither
+* selected nor already generated is dropped from the surface entirely, so its
+* models/discriminators are not pulled into reachability and barrels/the client
+* never import a resource this run does not emit. The emitters additionally
+* consult `ctx.scopedServices` to emit only the selected services' per-service
+* resource/test files.
 */
 function generateAllFiles(spec, emitter, ctx) {
-	const referenced = collectReferencedNames(spec.services, spec.models);
+	const scoped = !!ctx.scopedServices && ctx.scopedServices.size > 0;
+	const surfaceServices = aggregateSurfaceServices(spec, ctx);
+	const referenced = collectReferencedNames(surfaceServices, spec.models, { preserveAllDiscriminated: !scoped });
 	const reachableModels = spec.models.filter((m) => referenced.models.has(m.name));
 	const reachableEnums = spec.enums.filter((e) => referenced.enums.has(e.name));
-	const reachableSpec = {
+	const surfaceSpec = {
 		...spec,
+		services: surfaceServices
+	};
+	const reachableSpec = {
+		...surfaceSpec,
 		models: reachableModels,
 		enums: reachableEnums
 	};
 	return [
 		...emitter.generateModels(reachableModels, ctx),
 		...emitter.generateEnums(reachableEnums, ctx),
-		...emitter.generateResources(spec.services, ctx),
-		...emitter.generateClient(spec, ctx),
+		...emitter.generateResources(surfaceServices, ctx),
+		...emitter.generateClient(surfaceSpec, ctx),
 		...emitter.generateErrors(ctx),
 		...emitter.generateTypeSignatures?.(reachableSpec, ctx) ?? [],
 		...emitter.generateTests(reachableSpec, ctx)
@@ -5844,7 +5993,11 @@ function applyFileHeaders(files, header) {
 function generateFiles(spec, emitter, options) {
 	const ctx = buildEmitterContext(spec, options);
 	const files = generateAllFiles(spec, emitter, ctx);
-	const operations = emitter.buildOperationsMap?.(spec, ctx);
+	const surfaceSpec = {
+		...spec,
+		services: aggregateSurfaceServices(spec, ctx)
+	};
+	const operations = emitter.buildOperationsMap?.(surfaceSpec, ctx);
 	const header = emitter.fileHeader();
 	return {
 		files: applyFileHeaders(files, header),
@@ -5854,47 +6007,6 @@ function generateFiles(spec, emitter, options) {
 	};
 }
 //#endregion
-//#region src/engine/scoped-services.ts
-/**
-* Validate a `--services` selection and return it as a set of POST-MOUNT service
-* names for emitters to scope on.
-*
-* Scoped generation does NOT filter the IR: model placement, dedup/aliasing, and
-* shared-schema decisions are global computations over the full service/model set
-* (filtering them churns shared `common/` files). Instead the full spec flows to
-* the emitters unchanged and this set is passed as `ctx.scopedServices`; each
-* emitter gates only its per-service resource/test emission on it.
-*
-* Matching is on the POST-MOUNT name. Mount resolution never mutates
-* `spec.services` — the post-mount target lives on `ResolvedOperation.mountOn`
-* (`mountOn = hint?.mountOn ?? mountRules[service.name] ?? service.name`) — so the
-* post-mount name of a source service is derived here as
-* `mountRules[service.name] ?? service.name`. Selecting a target (e.g.
-* `DirectorySync`) is valid because every source tag that mounts into it
-* (`DirectoryUsers`, `DirectoryGroups`, …) shares that post-mount name, and the
-* emitters group resources by mount, so all siblings emit together.
-*
-* @param spec - The parsed API spec (never mutated; never filtered).
-* @param selected - Post-mount service names from `--services` (normalized/trimmed).
-* @param mountRules - Source-service-name → post-mount-target mappings.
-* @returns The validated selection as a `Set` of post-mount names.
-* @throws A `ConfigError` listing valid post-mount names when a selection is
-*   unknown — scoped generation never silently emits the wrong set.
-*/
-function resolveScopedServices(spec, selected, mountRules) {
-	const mounts = mountRules ?? {};
-	const postMountName = (name) => mounts[name] ?? name;
-	const validPostMount = new Set(spec.services.map((s) => postMountName(s.name)));
-	const selectedSet = new Set(selected);
-	const unknown = [...selectedSet].filter((s) => !validPostMount.has(s));
-	if (unknown.length > 0) {
-		const err = /* @__PURE__ */ new Error(`Unknown --services: ${unknown.sort().join(", ")}. Valid post-mount services: ${[...validPostMount].sort().join(", ")}`);
-		err.name = "ConfigError";
-		throw err;
-	}
-	return selectedSet;
-}
-//#endregion
 //#region src/engine/integrate.ts
 /**
 * Resolve a relative import path against a source file path to get the
@@ -6206,6 +6318,35 @@ function mergeScopedManifestRecords(prev, scopedFiles, scopedOperations) {
 	};
 }
 /**
+* Extract the set of services a prior manifest records as already generated on
+* disk, as canonical (casing/separator-insensitive) keys.
+*
+* The manifest's `operations` map carries each operation's owning `service`
+* (snake_case for most emitters, camelCase for Kotlin). A scoped (`--services`)
+* run uses this to tell "service in the spec that is already on disk" apart from
+* "service the spec just added that this SDK has never generated" — only the
+* former may be wired into aggregate/barrel/client files alongside the
+* selection, so a brand-new out-of-scope service is never referenced by files
+* whose implementation this run does not emit.
+*
+* Returns an empty set when the manifest is null or carries no operations
+* (a legacy manifest with no operations data); callers treat that as "present
+* set unknown" and fall back to not narrowing the surface.
+*/
+function manifestServiceKeys(manifest) {
+	const keys = /* @__PURE__ */ new Set();
+	const ops = manifest?.operations;
+	if (!ops) return keys;
+	for (const value of Object.values(ops)) {
+		const entries = Array.isArray(value) ? value : [value];
+		for (const entry of entries) {
+			const service = entry?.service;
+			if (typeof service === "string" && service.length > 0) keys.add(canonicalServiceKey(service));
+		}
+	}
+	return keys;
+}
+/**
 * Delete stale files from `dir`.
 *
 * When `header` is provided, a file is only deleted if its contents start with
@@ -6280,11 +6421,14 @@ async function generate(spec, emitter, options) {
 	const skipManifestRead = options.noPrune === true && !scoped;
 	const outputPrevManifestForCtx = skipManifestRead ? null : await readManifest(options.outputDir);
 	const targetManifestForCtx = options.target && !skipManifestRead ? await readManifest(options.target) : null;
-	const priorTargetManifestPaths = targetManifestForCtx ? new Set(targetManifestForCtx.files) : outputPrevManifestForCtx ? new Set(outputPrevManifestForCtx.files) : void 0;
+	const priorManifestForCtx = targetManifestForCtx ?? outputPrevManifestForCtx;
+	const priorTargetManifestPaths = priorManifestForCtx ? new Set(priorManifestForCtx.files) : void 0;
+	const presentServiceKeys = scoped ? manifestServiceKeys(priorManifestForCtx) : void 0;
 	const { files: withHeaders, header, operations } = generateFiles(spec, emitter, {
 		...options,
 		priorTargetManifestPaths,
-		scopedServices
+		scopedServices,
+		presentServiceKeys
 	});
 	if (options.dryRun) {
 		if (options.target) {