@workos/oagen 0.27.0 → 0.28.1

package/dist/{diff-B9wlNAVX.mjs → diff-DqnHHXvr.mjs}

@@ -3747,14 +3747,107 @@ function getEmitter(language) {
 	return emitter;
 }
 //#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,
@@ -3819,7 +3912,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]));
@@ -3836,7 +3934,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({
@@ -3849,11 +3947,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);
@@ -4068,8 +4166,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)
 	];
@@ -4183,6 +4282,6 @@ function summarize(changes) {
 	};
 }
 //#endregion
-export { MANIFEST_FILENAME as a, treeShakeFiles as c, collectReferencedNames as d, generateAllFiles as f, resolveOperations as g, resolveMountTarget as h, generate as i, applyFileHeaders as l, deriveMethodName as m, getEmitter as n, integrateGeneratedFiles as o, generateFiles as p, registerEmitter as r, mapFilesForTargetIntegration as s, diffSpecs as t, buildEmitterContext as u };
+export { resolveMountTarget as _, registerEmitter as a, integrateGeneratedFiles as c, applyFileHeaders as d, buildEmitterContext as f, deriveMethodName as g, generateFiles as h, getEmitter as i, mapFilesForTargetIntegration as l, generateAllFiles as m, buildDirectionIndex as n, generate as o, collectReferencedNames as p, directionOf as r, MANIFEST_FILENAME as s, diffSpecs as t, treeShakeFiles as u, resolveOperations as v };
 
-//# sourceMappingURL=diff-B9wlNAVX.mjs.map
+//# sourceMappingURL=diff-DqnHHXvr.mjs.map