@workos/oagen 0.6.0 → 0.7.0

package/dist/scripts/smoke/baseline.mjs

@@ -550,7 +550,7 @@ function findSchemaByName(pascalName, schemas) {
 	for (const [k, v] of Object.entries(schemas)) if (resolveSchemaName(k) === pascalName) return v;
 	return null;
 }
-/** Walk into a schema to find a field's sub-schema, resolving allOf. */
+/** Walk into a schema to find a field's sub-schema, resolving allOf and oneOf/anyOf. */
 function findNestedFieldSchema(fieldName, parentSchema, schemas) {
 	if (parentSchema.properties?.[fieldName]) return parentSchema.properties[fieldName];
 	if (parentSchema.allOf) for (const sub of parentSchema.allOf) {
@@ -562,6 +562,15 @@ function findNestedFieldSchema(fieldName, parentSchema, schemas) {
 		}
 		if (resolved.properties?.[fieldName]) return resolved.properties[fieldName];
 	}
+	for (const variant of [...parentSchema.oneOf ?? [], ...parentSchema.anyOf ?? []]) {
+		let resolved = variant;
+		if (variant.$ref) {
+			const segments = variant.$ref.split("/");
+			const refName = segments[segments.length - 1];
+			if (refName && schemas[refName]) resolved = schemas[refName];
+		}
+		if (resolved.properties?.[fieldName]) return resolved.properties[fieldName];
+	}
 	return null;
 }
 /** Extract a model (and nested models) from an inline field schema. */
@@ -727,6 +736,19 @@ function extractModel(name, schema, schemas) {
 		if (!fieldSchema) continue;
 		fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
 	}
+	if (fields.length === 0 && (schema.oneOf || schema.anyOf)) {
+		const variants = schema.oneOf ?? schema.anyOf ?? [];
+		const emptyRequired = /* @__PURE__ */ new Set();
+		const seenFieldNames = /* @__PURE__ */ new Set();
+		for (const variant of variants) {
+			if (!variant.properties) continue;
+			for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+				if (!fieldSchema || seenFieldNames.has(fieldName)) continue;
+				seenFieldNames.add(fieldName);
+				fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+			}
+		}
+	}
 	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schema.properties) {
 		if (Object.keys(schema.additionalProperties).length > 0) {
 			const valueType = schemaToTypeRef(schema.additionalProperties, "additionalProperties", name);
@@ -766,6 +788,18 @@ function extractAllOfModel(name, schema, schemas) {
 				});
 				if (f.required) requiredSet.add(f.name);
 			}
+		} else if (resolved.oneOf || resolved.anyOf) {
+			const variants = resolved.oneOf ?? resolved.anyOf ?? [];
+			const emptyRequired = /* @__PURE__ */ new Set();
+			const seenFieldNames = new Set(fields.map((f) => f.name));
+			for (const variant of variants) {
+				if (!variant.properties) continue;
+				for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+					if (!fieldSchema || seenFieldNames.has(fieldName)) continue;
+					seenFieldNames.add(fieldName);
+					fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+				}
+			}
 		} else {
 			if (resolved.required) for (const r of resolved.required) requiredSet.add(r);
 			if (resolved.properties) {
@@ -1622,6 +1656,94 @@ function inferDeeperContext(path) {
 	if (nonParams.length >= 3) return toPascalCase(nonParams.slice(1, -1).join("_"));
 	return null;
 }
+/**
+* Extract mutually-exclusive parameter groups from the `x-mutually-exclusive-parameter-groups`
+* operation extension. Cross-references grouped parameter names against the already-extracted
+* IR parameter arrays so emitters get object-identity references.
+*/
+function extractParameterGroups(op, allIRParams, operationContext) {
+	const raw = op["x-mutually-exclusive-parameter-groups"];
+	if (!raw || typeof raw !== "object") return void 0;
+	const paramByName = /* @__PURE__ */ new Map();
+	for (const p of allIRParams) paramByName.set(p.name, p);
+	const groups = [];
+	for (const [groupName, groupDef] of Object.entries(raw)) {
+		if (!groupDef || typeof groupDef !== "object") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName} in ${operationContext}: expected an object with "optional" and "variants".`);
+		if (typeof groupDef.optional !== "boolean") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.optional in ${operationContext}: expected a boolean.`);
+		if (!groupDef.variants || typeof groupDef.variants !== "object") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.variants in ${operationContext}: expected an object mapping variant names to parameter name arrays.`);
+		if (Object.keys(groupDef.variants).length === 0) throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName} in ${operationContext}: group has zero variants.`);
+		const variants = Object.entries(groupDef.variants).map(([variantName, paramNames]) => {
+			if (!Array.isArray(paramNames) || paramNames.length === 0) throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.variants.${variantName} in ${operationContext}: expected a non-empty array of parameter names.`);
+			return {
+				name: variantName,
+				parameters: paramNames.map((pName) => {
+					const irParam = paramByName.get(pName);
+					if (!irParam) throw new Error(`x-mutually-exclusive-parameter-groups.${groupName}.variants.${variantName} references parameter "${pName}" which does not exist in the operation's parameters[] (${operationContext}).`);
+					return irParam;
+				})
+			};
+		});
+		groups.push({
+			name: groupName,
+			optional: groupDef.optional,
+			variants
+		});
+	}
+	return groups.length > 0 ? groups : void 0;
+}
+/**
+* Extract mutually-exclusive body parameter groups from the
+* `x-mutually-exclusive-body-groups` operation extension. Unlike query
+* parameter groups (whose parameters live in operation.queryParams), body
+* group parameters are synthetic — built from the oneOf variant schemas in
+* the request body. Emitters use the group's presence to generate sum-type
+* interfaces and custom JSON marshalling instead of flat optional fields.
+*/
+function extractBodyParameterGroups(op, operationContext) {
+	const raw = op["x-mutually-exclusive-body-groups"];
+	if (!raw || typeof raw !== "object") return void 0;
+	const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+	const variantFieldSchemas = /* @__PURE__ */ new Map();
+	if (bodySchema) {
+		for (const sub of bodySchema.allOf ?? []) for (const variant of sub.oneOf ?? []) if (variant.properties) {
+			for (const [name, fieldSchema] of Object.entries(variant.properties)) if (fieldSchema) variantFieldSchemas.set(name, fieldSchema);
+		}
+		for (const variant of bodySchema.oneOf ?? []) if (variant.properties) {
+			for (const [name, fieldSchema] of Object.entries(variant.properties)) if (fieldSchema) variantFieldSchemas.set(name, fieldSchema);
+		}
+	}
+	const groups = [];
+	for (const [groupName, groupDef] of Object.entries(raw)) {
+		if (!groupDef || typeof groupDef !== "object") continue;
+		if (typeof groupDef.optional !== "boolean") continue;
+		if (!groupDef.variants || typeof groupDef.variants !== "object") continue;
+		if (Object.keys(groupDef.variants).length === 0) continue;
+		const variants = Object.entries(groupDef.variants).map(([variantName, paramNames]) => {
+			if (!Array.isArray(paramNames) || paramNames.length === 0) throw new Error(`Malformed x-mutually-exclusive-body-groups.${groupName}.variants.${variantName} in ${operationContext}: expected a non-empty array of parameter names.`);
+			return {
+				name: variantName,
+				parameters: paramNames.map((pName) => {
+					const fieldSchema = variantFieldSchemas.get(pName);
+					return {
+						name: pName,
+						type: fieldSchema ? schemaToTypeRef(fieldSchema, toPascalCase(pName)) : {
+							kind: "primitive",
+							type: "string"
+						},
+						required: false,
+						description: fieldSchema?.description
+					};
+				})
+			};
+		});
+		groups.push({
+			name: groupName,
+			optional: groupDef.optional,
+			variants
+		});
+	}
+	return groups.length > 0 ? groups : void 0;
+}
 function buildOperation(method, path, op, pathLevelParams, operationIdTransform, serviceName) {
 	const allParams = [...pathLevelParams, ...op.parameters ?? []];
 	const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
@@ -1647,6 +1769,16 @@ function buildOperation(method, path, op, pathLevelParams, operationIdTransform,
 		};
 	} else if (paginationFromParams) pagination = paginationFromParams;
 	const security = extractOperationSecurity(op.security);
+	const allIRParams = [
+		...pathParams,
+		...queryParams,
+		...headerParams,
+		...cookieParams
+	];
+	const opLabel = op.operationId ?? `${method.toUpperCase()} ${path}`;
+	const queryParamGroups = extractParameterGroups(op, allIRParams, opLabel);
+	const bodyParamGroups = extractBodyParameterGroups(op, opLabel);
+	const parameterGroups = queryParamGroups || bodyParamGroups ? [...queryParamGroups ?? [], ...bodyParamGroups ?? []] : void 0;
 	return {
 		operation: {
 			name: inferOperationName(method, path, op.operationId, operationIdTransform),
@@ -1666,7 +1798,8 @@ function buildOperation(method, path, op, pathLevelParams, operationIdTransform,
 			injectIdempotencyKey: hasIdempotencyHeader,
 			deprecated: op.deprecated || void 0,
 			async: op["x-oagen-async"],
-			security
+			security,
+			parameterGroups
 		},
 		inlineModels
 	};