@workos/oagen 0.28.0 → 0.29.0

package/dist/cli/index.mjs

@@ -2255,20 +2255,24 @@ function extractBodyParameterGroups(op, operationContext) {
 		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.`);
+			const 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
+				};
+			});
+			const rawOptionalFields = groupDef.optionalFields && typeof groupDef.optionalFields === "object" ? groupDef.optionalFields[variantName] : void 0;
+			const optionalParameters = Array.isArray(rawOptionalFields) ? rawOptionalFields.filter((name) => typeof name === "string" && paramNames.includes(name)) : [];
 			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
-					};
-				})
+				parameters,
+				...optionalParameters.length > 0 ? { optionalParameters } : {}
 			};
 		});
 		groups.push({
@@ -7360,14 +7364,107 @@ async function generateCommand(opts) {
 	}
 }
 //#endregion
+//#region src/differ/direction.ts
+/**
+* Classify every model in `specs` as request-facing, response-facing, both, or
+* unknown.
+*
+* Pass both the baseline and the candidate spec: a model that was request-facing
+* in either one keeps its request direction for the whole diff, so a schema that
+* moves request → response mid-release doesn't get that release's requiredness
+* changes silently downgraded.
+*
+* Models reachable from neither side (unreferenced schemas, or a spec whose
+* operations weren't supplied) stay `unknown`, which preserves the conservative
+* pre-direction classification.
+*/
+function buildDirectionIndex(...specs) {
+	const models = /* @__PURE__ */ new Map();
+	for (const spec of specs) for (const model of spec.models) if (!models.has(model.name)) models.set(model.name, model);
+	const requestSeeds = [];
+	const responseSeeds = [];
+	for (const spec of specs) for (const service of spec.services) for (const op of service.operations) {
+		if (op.requestBody) requestSeeds.push(op.requestBody);
+		for (const param of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) requestSeeds.push(param.type);
+		responseSeeds.push(op.response);
+		for (const success of op.successResponses ?? []) responseSeeds.push(success.type);
+		for (const error of op.errors) if (error.type) responseSeeds.push(error.type);
+	}
+	const request = reachableModels(requestSeeds, models);
+	const response = reachableModels(responseSeeds, models);
+	const index = /* @__PURE__ */ new Map();
+	for (const name of models.keys()) {
+		const inRequest = request.has(name);
+		const inResponse = response.has(name);
+		index.set(name, inRequest && inResponse ? "both" : inRequest ? "request" : inResponse ? "response" : "unknown");
+	}
+	return index;
+}
+function directionOf(index, modelName) {
+	return index?.get(modelName) ?? "unknown";
+}
+/**
+* Every model name reachable from `seeds`, following model fields (and
+* discriminated-union variants) transitively.
+*/
+function reachableModels(seeds, models) {
+	const found = /* @__PURE__ */ new Set();
+	const queue = [...seeds];
+	while (queue.length > 0) {
+		const ref = queue.pop();
+		switch (ref.kind) {
+			case "model": {
+				if (found.has(ref.name)) break;
+				found.add(ref.name);
+				const model = models.get(ref.name);
+				if (!model) break;
+				for (const field of model.fields) queue.push(field.type);
+				for (const variant of Object.values(model.discriminator?.mapping ?? {})) queue.push({
+					kind: "model",
+					name: variant
+				});
+				break;
+			}
+			case "array":
+				queue.push(ref.items);
+				break;
+			case "nullable":
+				queue.push(ref.inner);
+				break;
+			case "map":
+				queue.push(ref.valueType);
+				break;
+			case "union":
+				queue.push(...ref.variants);
+				break;
+			case "primitive":
+			case "enum":
+			case "literal": break;
+		}
+	}
+	return found;
+}
+//#endregion
 //#region src/differ/classify.ts
-function classifyFieldChange(kind, fieldName, isRequired) {
+function classifyFieldChange(kind, fieldName, isRequired, direction = "unknown") {
 	switch (kind) {
-		case "field-added": return {
-			kind,
-			fieldName,
-			classification: isRequired ? "breaking" : "additive"
-		};
+		case "field-added":
+			if (isRequired && direction === "response") return {
+				kind,
+				fieldName,
+				classification: "additive",
+				details: "required on a response-only model"
+			};
+			return {
+				kind,
+				fieldName,
+				classification: isRequired ? "breaking" : "additive"
+			};
 		case "field-removed": return {
 			kind,
 			fieldName,
@@ -7432,7 +7529,12 @@ function classifyParamChange(kind, paramName, isRequired) {
 }
 //#endregion
 //#region src/differ/models.ts
-function diffModels(oldModels, newModels) {
+/**
+* `directions` (from `buildDirectionIndex`) lets requiredness changes be judged
+* against the side of the wire each model is used on. Omit it and every model is
+* treated as unknown-direction, i.e. the conservative classification.
+*/
+function diffModels(oldModels, newModels, directions) {
 	const changes = [];
 	const oldByName = new Map(oldModels.map((m) => [m.name, m]));
 	const newByName = new Map(newModels.map((m) => [m.name, m]));
@@ -7449,7 +7551,7 @@ function diffModels(oldModels, newModels) {
 	for (const [name, newModel] of newByName) {
 		const oldModel = oldByName.get(name);
 		if (!oldModel) continue;
-		const fieldChanges = diffFields(oldModel, newModel);
+		const fieldChanges = diffFields(oldModel, newModel, directionOf(directions, name));
 		if (fieldChanges.length > 0) {
 			const hasBreaking = fieldChanges.some((fc) => fc.classification === "breaking");
 			changes.push({
@@ -7462,11 +7564,11 @@ function diffModels(oldModels, newModels) {
 	}
 	return changes;
 }
-function diffFields(oldModel, newModel) {
+function diffFields(oldModel, newModel, direction = "unknown") {
 	const changes = [];
 	const oldByName = new Map(oldModel.fields.map((f) => [f.name, f]));
 	const newByName = new Map(newModel.fields.map((f) => [f.name, f]));
-	for (const [name, field] of newByName) if (!oldByName.has(name)) changes.push(classifyFieldChange("field-added", name, field.required));
+	for (const [name, field] of newByName) if (!oldByName.has(name)) changes.push(classifyFieldChange("field-added", name, field.required, direction));
 	for (const [name] of oldByName) if (!newByName.has(name)) changes.push(classifyFieldChange("field-removed", name));
 	for (const [name, newField] of newByName) {
 		const oldField = oldByName.get(name);
@@ -7681,8 +7783,9 @@ function diffServices(oldServices, newServices) {
 //#endregion
 //#region src/differ/diff.ts
 function diffSpecs(oldSpec, newSpec) {
+	const directions = buildDirectionIndex(oldSpec, newSpec);
 	const changes = [
-		...diffModels(oldSpec.models, newSpec.models),
+		...diffModels(oldSpec.models, newSpec.models, directions),
 		...diffEnums(oldSpec.enums, newSpec.enums),
 		...diffServices(oldSpec.services, newSpec.services)
 	];