@workos/oagen 0.23.0 → 0.24.0

package/dist/smoke.mjs

@@ -2302,6 +2302,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 = [];
@@ -2367,6 +2371,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) {