schemair 0.1.0 → 0.3.0

package/dist/{relations-By0bK3UK.js → relations-QtnCRW9x.js}

@@ -1,4 +1,5 @@
-import { t as validateSchemaNodeDefinition } from "./definition-BXj3T94L.js";
+import { f as validateSchemaNodeDefinition, l as validateOperationDefinition } from "./definition-BH_LzXGc.js";
+import { n as schemaRefKey, t as indexSchemaRefs } from "./schema-ref-key-DR__tPr-.js";
 
 //#region src/relations/validator.ts
 function equalLiteral(left, right) {
@@ -17,11 +18,13 @@ var RelationChecker = class {
 	activePairs = /* @__PURE__ */ new Set();
 	activeRefs = /* @__PURE__ */ new Set();
 	ids = /* @__PURE__ */ new WeakMap();
+	refIndex;
 	nextId = 1;
 	constructor(context, rootSourceSchema, rootTargetSchema) {
 		this.context = context;
 		this.rootSourceSchema = rootSourceSchema;
 		this.rootTargetSchema = rootTargetSchema;
+		this.refIndex = indexSchemaRefs(context.refs);
 	}
 	run() {
 		const result = this.compare(this.rootSourceSchema, this.rootTargetSchema, [], this.rootSourceSchema, this.rootTargetSchema);
@@ -251,8 +254,14 @@ var RelationChecker = class {
 		}
 	}
 	compareRef(ref, other, path, rootSource, rootTarget, side) {
-		if (!this.context.resolveRef) return this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver");
-		const key = `${side}:${ref.refPath.join("\0")}`;
+		const materialized = this.refIndex.get(schemaRefKey(ref.refPath));
+		if (materialized !== void 0) {
+			const definition$1 = validateSchemaNodeDefinition(materialized);
+			if (!definition$1.ok) return this.rejected(path, "ref.schema", "resolved ref environment contains an invalid schema");
+			return side === "source" ? this.compare(definition$1.node, other, path, rootSource, rootTarget) : this.compare(other, definition$1.node, path, rootSource, rootTarget);
+		}
+		if (!this.context.resolveRef) return this.context.refs === void 0 ? this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver") : this.unknown(path, "ref.unresolved", "refPath is not present in the resolved environment");
+		const key = `${side}:${schemaRefKey(ref.refPath)}`;
 		if (this.activeRefs.has(key)) return this.unknown(path, "ref.cycle", "refPath relation cycle could not be determined");
 		this.activeRefs.add(key);
 		let resolved;
@@ -349,10 +358,10 @@ function validateSchema(schema, side) {
 	if (definition.ok) return definition.node;
 	return {
 		status: "rejected",
-		issues: definition.issues.map((issue) => ({
-			code: `relation.rejected.schema.${side}.${issue.code}`,
-			path: issue.path,
-			message: issue.message
+		issues: definition.issues.map((issue$1) => ({
+			code: `relation.rejected.schema.${side}.${issue$1.code}`,
+			path: issue$1.path,
+			message: issue$1.message
 		}))
 	};
 }
@@ -364,210 +373,139 @@ function checkSchemaRelation(source, target, context = {}) {
 	return new RelationChecker(context, validSource, validTarget).run();
 }
 const checkSchemaAssignability = checkSchemaRelation;
-async function resolveAsyncSchema(schema, context, active, path, side, rootSourceSchema, rootTargetSchema) {
-	if (schema.kind === "ref" && context.resolveRef) {
-		const key = schema.refPath.join("\0");
-		if (active.has(key)) return schema;
-		active.add(key);
-		let resolved;
-		try {
-			resolved = await context.resolveRef(schema.refPath, {
-				path,
-				side,
-				sourceSchema: side === "source" ? schema : rootSourceSchema,
-				targetSchema: side === "source" ? rootTargetSchema : schema,
-				rootSourceSchema,
-				rootTargetSchema,
-				refPath: schema.refPath
-			});
-		} catch {
-			return schema;
-		} finally {
-			active.delete(key);
-		}
-		if (resolved && !(typeof resolved === "object" && "status" in resolved && resolved.status !== "resolved")) {
-			const definition = validateSchemaNodeDefinition(typeof resolved === "object" && "status" in resolved ? resolved.schema : resolved);
-			if (definition.ok) return resolveAsyncSchema(definition.node, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema);
-		}
-		return schema;
-	}
-	switch (schema.kind) {
-		case "record": return {
-			...schema,
-			fields: await Promise.all(schema.fields.map(async (field) => ({
-				...field,
-				schema: await resolveAsyncSchema(field.schema, context, new Set(active), [
-					...path,
-					"fields",
-					field.key
-				], side, rootSourceSchema, rootTargetSchema)
-			}))),
-			...schema.additionalFields && schema.additionalFields !== true ? { additionalFields: await resolveAsyncSchema(schema.additionalFields, context, new Set(active), [...path, "additionalFields"], side, rootSourceSchema, rootTargetSchema) } : {}
-		};
-		case "array": return {
-			...schema,
-			elementSchema: await resolveAsyncSchema(schema.elementSchema, context, new Set(active), [...path, "elementSchema"], side, rootSourceSchema, rootTargetSchema)
-		};
-		case "tuple": return {
-			...schema,
-			elementSchemas: await Promise.all(schema.elementSchemas.map((item, index) => resolveAsyncSchema(item, context, new Set(active), [
-				...path,
-				"elementSchemas",
-				index
-			], side, rootSourceSchema, rootTargetSchema)))
-		};
-		case "nullable": return {
-			...schema,
-			value: await resolveAsyncSchema(schema.value, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema)
-		};
-		case "taggedUnion": return {
-			...schema,
-			variants: await Promise.all(schema.variants.map(async (variant) => ({
-				...variant,
-				schema: await resolveAsyncSchema(variant.schema, context, new Set(active), [
-					...path,
-					"variants",
-					variant.key
-				], side, rootSourceSchema, rootTargetSchema)
-			})))
-		};
-		default: return schema;
+
+//#endregion
+//#region src/relations/operation.ts
+function issue(status, path, code, message, component, direction) {
+	return { result: {
+		status,
+		issues: [{
+			code: `operation.relation.${code}`,
+			path,
+			message,
+			...component === void 0 ? {} : { details: {
+				component,
+				...direction === void 0 ? {} : { direction }
+			} }
+		}]
+	} };
+}
+function payload(source, target, path) {
+	const component = path[0] === "input" ? "input" : path[0] === "output" ? "output" : "emission";
+	const direction = component === "input" ? "target-to-source" : "source-to-target";
+	if (source === void 0 && target === void 0) return [];
+	if (source === void 0 || target === void 0) return [issue("incompatible", path, "presence", "A value and absence are distinct contracts.", component, direction)];
+	if (source.kind !== target.kind) return [issue("incompatible", path, "payload-kind", "Structured and binary payloads are distinct.", component, direction)];
+	if (source.kind === "structured" && target.kind === "structured") return [{
+		source: source.schema,
+		target: target.schema,
+		path: [...path, "schema"]
+	}];
+	if (source.kind === "binary" && target.kind === "binary") {
+		if (target.meta === void 0 || source.meta?.value === target.meta.value) return [];
+		return [issue("unknown", [...path, "meta"], "binary-metadata", "The declared metadata does not prove the target MIME requirement.", component, direction)];
 	}
+	return [];
 }
-function collectRelationPairs(source, target, path = [], result = [], seen = /* @__PURE__ */ new Set()) {
-	const key = `${JSON.stringify(path)}:${JSON.stringify(source)}:${JSON.stringify(target)}`;
-	if (seen.has(key)) return result;
-	seen.add(key);
-	result.push({
-		source,
-		target,
-		path
-	});
-	if (source.kind === "record" && target.kind === "record") {
-		const targetFields = new Map(target.fields.map((field) => [field.key, field]));
-		for (const field of source.fields) {
-			const targetField = targetFields.get(field.key);
-			if (targetField) collectRelationPairs(field.schema, targetField.schema, [
-				...path,
-				"fields",
-				field.key
-			], result, seen);
+function errors(source, target, path) {
+	const comparisons$1 = [];
+	for (const [code, error] of Object.entries(source ?? {})) {
+		const at = [...path, code];
+		if (!target || !Object.hasOwn(target, code)) {
+			comparisons$1.push(issue("incompatible", at, "error-code", "The source may produce an error not declared by the target.", "error", "source-to-target"));
+			continue;
 		}
-	} else if (source.kind === "array" && target.kind === "array") collectRelationPairs(source.elementSchema, target.elementSchema, [...path, "elementSchema"], result, seen);
-	else if (source.kind === "tuple" && target.kind === "tuple") for (let index = 0; index < Math.min(source.elementSchemas.length, target.elementSchemas.length); index += 1) collectRelationPairs(source.elementSchemas[index], target.elementSchemas[index], [
-		...path,
-		"elementSchemas",
-		index
-	], result, seen);
-	else if (source.kind === "nullable" && target.kind === "nullable") collectRelationPairs(source.value, target.value, path, result, seen);
-	else if (source.kind === "taggedUnion" && target.kind === "taggedUnion" && source.discriminator === target.discriminator) {
-		const targetVariants = new Map(target.variants.map((variant) => [variant.key, variant]));
-		for (const variant of source.variants) {
-			const targetVariant = targetVariants.get(variant.key);
-			if (targetVariant) collectRelationPairs(variant.schema, targetVariant.schema, [
-				...path,
-				"variants",
-				variant.key
-			], result, seen);
+		const expected = target[code];
+		if (error.data !== void 0 && expected.data !== void 0) comparisons$1.push({
+			source: error.data,
+			target: expected.data,
+			path: [...at, "data"]
+		});
+		else if (error.data !== expected.data) comparisons$1.push(issue("incompatible", [...at, "data"], "presence", "Error details and absence are distinct contracts.", "error", "source-to-target"));
+	}
+	return comparisons$1;
+}
+function comparisons(source, target) {
+	const result = [
+		...payload(target.input, source.input, ["input"]),
+		...payload(source.output, target.output, ["output"]),
+		...errors(source.errors, target.errors, ["errors"])
+	];
+	for (const [name, channel] of Object.entries(source.emits ?? {})) {
+		const path = ["emits", name];
+		if (!target.emits || !Object.hasOwn(target.emits, name)) {
+			result.push(issue("incompatible", path, "channel", "The source may emit on a channel not declared by the target.", "emission", "source-to-target"));
+			continue;
 		}
+		const expected = target.emits[name];
+		result.push(...payload(channel.data, expected.data, [...path, "data"]));
+		result.push(...errors(channel.errors, expected.errors, [...path, "errors"]));
 	}
 	return result;
 }
-async function checkSchemaRelationAsync(source, target, context = {}) {
-	try {
-		const validSource = validateSchema(source, "source");
-		if ("status" in validSource) return validSource;
-		const validTarget = validateSchema(target, "target");
-		if ("status" in validTarget) return validTarget;
-		const resolvedSource = await resolveAsyncSchema(validSource, context, /* @__PURE__ */ new Set(), [], "source", validSource, validTarget);
-		const resolvedTarget = await resolveAsyncSchema(validTarget, context, /* @__PURE__ */ new Set(), [], "target", validSource, validTarget);
-		const pairs = collectRelationPairs(resolvedSource, resolvedTarget);
-		const semanticCache = /* @__PURE__ */ new Map();
-		const constraintCache = /* @__PURE__ */ new Map();
-		if (context.semanticProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			const sourceSemantic = left.kind === "primitive" && (left.name === "string" || left.name === "number") ? left.semanticPath : void 0;
-			const targetSemantic = right.kind === "primitive" && (right.name === "string" || right.name === "number") ? right.semanticPath : void 0;
-			if (right.kind !== "primitive" || right.name !== "string" && right.name !== "number" || sourceSemantic === void 0 && targetSemantic === void 0) continue;
-			const providerContext = {
-				path: pair.path,
-				side: "source",
-				sourceSchema: left,
-				targetSchema: right,
-				rootSourceSchema: resolvedSource,
-				rootTargetSchema: resolvedTarget
-			};
-			let decision;
-			try {
-				decision = await context.semanticProvider(sourceSemantic, targetSemantic, providerContext);
-			} catch (error) {
-				decision = {
-					status: "unknown",
-					message: `semantic provider failed: ${error instanceof Error ? error.message : String(error)}`
-				};
+function prepare(source, target) {
+	const left = validateOperationDefinition(source);
+	const right = validateOperationDefinition(target);
+	if (!left.ok || !right.ok) return {
+		status: "rejected",
+		issues: [...!left.ok ? left.issues.map((i) => ({
+			...i,
+			path: ["source", ...i.path],
+			code: `operation.relation.rejected.${i.code}`,
+			details: {
+				component: "definition",
+				side: "source"
 			}
-			semanticCache.set(JSON.stringify([
-				pair.path,
-				sourceSemantic,
-				targetSemantic
-			]), decision);
-		}
-		if (context.constraintProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			if (left.kind === "primitive" || left.kind === "array" || left.kind === "record" || left.kind === "literal" || left.kind === "literalUnion") {
-				const literalToPrimitive = (left.kind === "literal" || left.kind === "literalUnion") && right.kind === "primitive";
-				if (right.kind !== left.kind && !literalToPrimitive) continue;
-				const sourceConstraints = "constraints" in left ? left.constraints : void 0;
-				const targetConstraints = "constraints" in right ? right.constraints : void 0;
-				if (sourceConstraints === void 0 && targetConstraints === void 0) continue;
-				const providerContext = {
-					path: pair.path,
-					side: "source",
-					sourceSchema: left,
-					targetSchema: right,
-					rootSourceSchema: resolvedSource,
-					rootTargetSchema: resolvedTarget
-				};
-				let decision;
-				try {
-					decision = await context.constraintProvider(sourceConstraints, targetConstraints, providerContext);
-				} catch (error) {
-					decision = {
-						status: "unknown",
-						message: `constraint provider failed: ${error instanceof Error ? error.message : String(error)}`
-					};
-				}
-				constraintCache.set(JSON.stringify([
-					pair.path,
-					sourceConstraints,
-					targetConstraints
-				]), decision);
+		})) : [], ...!right.ok ? right.issues.map((i) => ({
+			...i,
+			path: ["target", ...i.path],
+			code: `operation.relation.rejected.${i.code}`,
+			details: {
+				component: "definition",
+				side: "target"
 			}
-		}
-		return checkSchemaRelation(resolvedSource, resolvedTarget, {
-			semanticProvider: (sourcePath, targetPath, providerContext) => semanticCache.get(JSON.stringify([
-				providerContext.path,
-				sourcePath,
-				targetPath
-			])) ?? { status: "unknown" },
-			constraintProvider: (sourceConstraints, targetConstraints, providerContext) => constraintCache.get(JSON.stringify([
-				providerContext.path,
-				sourceConstraints,
-				targetConstraints
-			])) ?? { status: "unknown" }
-		});
-	} catch (error) {
-		return {
-			status: "unknown",
-			issues: [{
-				code: "relation.unknown.async",
-				path: [],
-				message: `async relation provider failed: ${error instanceof Error ? error.message : String(error)}`
-			}]
-		};
-	}
+		})) : []]
+	};
+	return comparisons(left.operation, right.operation);
+}
+const priority = {
+	assignable: 0,
+	unknown: 1,
+	incompatible: 2,
+	rejected: 3
+};
+function combine(results) {
+	let status = "assignable";
+	for (const result of results) if (priority[result.status] > priority[status]) status = result.status;
+	return {
+		status,
+		issues: results.flatMap((result) => result.issues)
+	};
+}
+function prefix(result, path) {
+	const component = path[0] === "input" ? "input" : path[0] === "output" ? "output" : path[0] === "errors" ? "error" : path[0] === "emits" ? "emission" : "definition";
+	const direction = component === "input" ? "target-to-source" : "source-to-target";
+	return {
+		status: result.status,
+		issues: result.issues.map((issue$1) => ({
+			...issue$1,
+			path: [...path, ...issue$1.path],
+			details: {
+				...issue$1.details ?? {},
+				component,
+				direction
+			}
+		}))
+	};
+}
+/** Can source replace target for callers using the target contract?
+* Provider contexts describe each directed schema comparison; input reverses sides.
+*/
+function checkOperationRelation(source, target, context = {}) {
+	const work = prepare(source, target);
+	if (!Array.isArray(work)) return work;
+	return combine(work.map((item) => "result" in item ? item.result : prefix(checkSchemaRelation(item.source, item.target, context), item.path)));
 }
-const checkSchemaAssignabilityAsync = checkSchemaRelationAsync;
 
 //#endregion
-export { checkSchemaRelationAsync as i, checkSchemaAssignabilityAsync as n, checkSchemaRelation as r, checkSchemaAssignability as t };
+export { checkSchemaAssignability as n, checkSchemaRelation as r, checkOperationRelation as t };