@workos/oagen 0.18.0 → 0.18.1

package/dist/{diff-DLqJSVYR.mjs → diff-JU1bdT5_.mjs}

@@ -2955,6 +2955,11 @@ function classifyFieldChange(kind, fieldName, isRequired) {
 			fieldName,
 			classification: "breaking"
 		};
+		case "field-format-changed": return {
+			kind,
+			fieldName,
+			classification: "additive"
+		};
 		case "field-required-changed": return {
 			kind,
 			fieldName,
@@ -2985,11 +2990,21 @@ function classifyParamChange(kind, paramName, isRequired) {
 			paramName,
 			classification: "breaking"
 		};
+		case "param-format-changed": return {
+			kind,
+			paramName,
+			classification: "additive"
+		};
 		case "param-required-changed": return {
 			kind,
 			paramName,
 			classification: isRequired ? "breaking" : "additive"
 		};
+		case "param-default-changed": return {
+			kind,
+			paramName,
+			classification: "breaking"
+		};
 	}
 }
 //#endregion
@@ -3033,7 +3048,11 @@ function diffFields(oldModel, newModel) {
 	for (const [name, newField] of newByName) {
 		const oldField = oldByName.get(name);
 		if (!oldField) continue;
-		if (!typeRefsEqual(oldField.type, newField.type)) changes.push({
+		if (!typeRefsEqual(oldField.type, newField.type)) if (primitivesDifferOnlyByFormat(oldField.type, newField.type)) changes.push({
+			...classifyFieldChange("field-format-changed", name),
+			details: formatChangeDetails(oldField.type, newField.type)
+		});
+		else changes.push({
 			kind: "field-type-changed",
 			fieldName: name,
 			classification: "breaking",
@@ -3044,6 +3063,23 @@ function diffFields(oldModel, newModel) {
 	}
 	return changes;
 }
+/**
+* True when both refs are primitives with the same base `type` but different
+* `format`. Used to downgrade format-only diffs from breaking type changes to
+* additive `field-format-changed` / `param-format-changed` events: the wire
+* base type is unchanged, so the diff is a hint to language emitters rather
+* than a source-level break.
+*/
+function primitivesDifferOnlyByFormat(a, b) {
+	if (a.kind !== "primitive" || b.kind !== "primitive") return false;
+	if (a.type !== b.type) return false;
+	return (a.format ?? "") !== (b.format ?? "");
+}
+function formatChangeDetails(a, b) {
+	const oldFmt = a.kind === "primitive" ? a.format : void 0;
+	const newFmt = b.kind === "primitive" ? b.format : void 0;
+	return `format ${oldFmt ?? "<unset>"} → ${newFmt ?? "<unset>"}`;
+}
 function typeRefsEqual(a, b) {
 	if (a.kind !== b.kind) return false;
 	switch (a.kind) {
@@ -3145,28 +3181,57 @@ function classifyErrorsChange(oldErrors, newErrors) {
 }
 function diffParams(oldOp, newOp) {
 	const changes = [];
+	const tagged = (loc, params) => params.map((p) => ({
+		p,
+		loc
+	}));
 	const allOldParams = [
-		...oldOp.pathParams,
-		...oldOp.queryParams,
-		...oldOp.headerParams
+		...tagged("path", oldOp.pathParams),
+		...tagged("query", oldOp.queryParams),
+		...tagged("header", oldOp.headerParams)
 	];
 	const allNewParams = [
-		...newOp.pathParams,
-		...newOp.queryParams,
-		...newOp.headerParams
+		...tagged("path", newOp.pathParams),
+		...tagged("query", newOp.queryParams),
+		...tagged("header", newOp.headerParams)
 	];
-	const oldByName = new Map(allOldParams.map((p) => [p.name, p]));
-	const newByName = new Map(allNewParams.map((p) => [p.name, p]));
-	for (const [name, param] of newByName) if (!oldByName.has(name)) changes.push(classifyParamChange("param-added", name, param.required));
+	const oldByName = new Map(allOldParams.map((e) => [e.p.name, e]));
+	const newByName = new Map(allNewParams.map((e) => [e.p.name, e]));
+	for (const [name, entry] of newByName) if (!oldByName.has(name)) changes.push(classifyParamChange("param-added", name, entry.p.required));
 	for (const [name] of oldByName) if (!newByName.has(name)) changes.push(classifyParamChange("param-removed", name));
-	for (const [name, newParam] of newByName) {
-		const oldParam = oldByName.get(name);
-		if (!oldParam) continue;
-		if (!typeRefsEqual(oldParam.type, newParam.type)) changes.push(classifyParamChange("param-type-changed", name));
-		if (oldParam.required !== newParam.required) changes.push(classifyParamChange("param-required-changed", name, newParam.required));
+	for (const [name, newEntry] of newByName) {
+		const oldEntry = oldByName.get(name);
+		if (!oldEntry) continue;
+		if (!typeRefsEqual(oldEntry.p.type, newEntry.p.type)) if (primitivesDifferOnlyByFormat(oldEntry.p.type, newEntry.p.type)) {
+			const change = classifyParamChange("param-format-changed", name);
+			change.details = formatChangeDetails(oldEntry.p.type, newEntry.p.type);
+			changes.push(change);
+		} else changes.push(classifyParamChange("param-type-changed", name));
+		if (oldEntry.p.required !== newEntry.p.required) changes.push(classifyParamChange("param-required-changed", name, newEntry.p.required));
+		const oldDefault = serializeDefault(oldEntry.p.default);
+		const newDefault = serializeDefault(newEntry.p.default);
+		if (oldDefault !== newDefault) {
+			const change = classifyParamChange("param-default-changed", name);
+			change.oldDefault = oldDefault;
+			change.newDefault = newDefault;
+			change.paramLocation = newEntry.loc;
+			change.details = `default ${oldDefault ?? "<unset>"} → ${newDefault ?? "<unset>"}`;
+			changes.push(change);
+		}
 	}
 	return changes;
 }
+function serializeDefault(value) {
+	if (value === void 0) return null;
+	if (value === null) return "null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
 //#endregion
 //#region src/differ/services.ts
 function diffServices(oldServices, newServices) {
@@ -3198,13 +3263,38 @@ function diffSpecs(oldSpec, newSpec) {
 		...diffEnums(oldSpec.enums, newSpec.enums),
 		...diffServices(oldSpec.services, newSpec.services)
 	];
+	const behaviorChanges = collectBehaviorChanges(changes);
 	return {
 		oldVersion: oldSpec.version,
 		newVersion: newSpec.version,
 		changes,
-		summary: summarize(changes)
+		behaviorChanges,
+		summary: {
+			...summarize(changes),
+			behaviorChanges: behaviorChanges.length
+		}
 	};
 }
+function collectBehaviorChanges(changes) {
+	const out = [];
+	for (const c of changes) {
+		if (c.kind !== "operation-modified") continue;
+		for (const pc of c.paramChanges) {
+			if (pc.kind !== "param-default-changed") continue;
+			out.push({
+				kind: "param-default-changed",
+				serviceName: c.serviceName,
+				operationName: c.operationName,
+				paramName: pc.paramName,
+				paramLocation: pc.paramLocation ?? "query",
+				oldDefault: pc.oldDefault ?? null,
+				newDefault: pc.newDefault ?? null,
+				classification: "breaking"
+			});
+		}
+	}
+	return out;
+}
 function diffEnums(oldEnums, newEnums) {
 	const changes = [];
 	const oldByName = new Map(oldEnums.map((e) => [e.name, e]));
@@ -3285,4 +3375,4 @@ function summarize(changes) {
 //#endregion
 export { MANIFEST_FILENAME as a, treeShakeFiles as c, collectReferencedNames as d, generateAllFiles as f, resolveOperations 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 };
 
-//# sourceMappingURL=diff-DLqJSVYR.mjs.map
+//# sourceMappingURL=diff-JU1bdT5_.mjs.map