@party-stack/ontology 0.19.1 → 0.21.0

package/lib/ir/validate.js

@@ -1,623 +0,0 @@
-import { isLinkHopFromForeignKeySource, resolveLinkHop } from "../utils/links.js";
-import { unwrapType } from "../utils/types.js";
-import { ImageMediaTypeOptions } from "./generated/constants.js";
-//#region src/ir/validate.ts
-function validateNonNegativeRange(range, path) {
-	if (!range) return [];
-	const errors = [];
-	for (const bound of ["min", "max"]) {
-		const value = range[bound];
-		if (value !== void 0 && (!Number.isFinite(value) || value < 0)) errors.push({
-			message: `Range ${bound} must be a finite, non-negative number.`,
-			path: [...path, bound]
-		});
-	}
-	if (range.min !== void 0 && range.max !== void 0 && range.min > range.max) errors.push({
-		message: "Range min must be less than or equal to max.",
-		path
-	});
-	return errors;
-}
-function validateAttachmentConstraints(type) {
-	const constraint = type.value.constraint;
-	if (!constraint) return [];
-	const errors = validateNonNegativeRange(constraint.size, ["constraint", "size"]);
-	const content = constraint.content;
-	if (content?.kind !== "image") return errors;
-	for (const [index, mediaType] of (content.value.mediaTypes ?? []).entries()) if (!ImageMediaTypeOptions.some((option) => option.value === mediaType)) errors.push({
-		message: `Unsupported image media type: "${mediaType}".`,
-		path: [
-			"constraint",
-			"content",
-			"value",
-			"mediaTypes",
-			index
-		]
-	});
-	errors.push(...validateNonNegativeRange(content.value.dimensions?.width, [
-		"constraint",
-		"content",
-		"value",
-		"dimensions",
-		"width"
-	]), ...validateNonNegativeRange(content.value.dimensions?.height, [
-		"constraint",
-		"content",
-		"value",
-		"dimensions",
-		"height"
-	]));
-	return errors;
-}
-function validateTypeDef(type, path, valueTypeNames, objectTypeNames) {
-	switch (type.kind) {
-		case "string":
-		case "boolean":
-		case "integer":
-		case "float":
-		case "double":
-		case "date":
-		case "timestamp":
-		case "geopoint":
-		case "unknown": return [];
-		case "attachment": return validateAttachmentConstraints(type).map((error) => ({
-			...error,
-			path: [...path, ...error.path ?? []]
-		}));
-		case "objectReference": return objectTypeNames.has(type.value.objectType) ? [] : [{
-			message: `Unknown object type reference: "${type.value.objectType}".`,
-			path: [...path, "objectType"]
-		}];
-		case "list": return validateTypeDef(type.value.elementType, [...path, "elementType"], valueTypeNames, objectTypeNames);
-		case "map": {
-			const errors = [];
-			if (type.value.keyType.kind !== "string") errors.push({
-				message: "Map key types must be string.",
-				path: [...path, "keyType"]
-			});
-			return [
-				...errors,
-				...validateTypeDef(type.value.keyType, [...path, "keyType"], valueTypeNames, objectTypeNames),
-				...validateTypeDef(type.value.valueType, [...path, "valueType"], valueTypeNames, objectTypeNames)
-			];
-		}
-		case "struct": return validateStructFields(type.value.fields, [...path, "fields"], valueTypeNames, objectTypeNames);
-		case "union": return validateUnionVariants(type.value.variants, [...path, "variants"], valueTypeNames, objectTypeNames);
-		case "optional": return validateTypeDef(type.value.type, [...path, "type"], valueTypeNames, objectTypeNames);
-		case "result": return [...validateTypeDef(type.value.okType, [...path, "okType"], valueTypeNames, objectTypeNames), ...validateTypeDef(type.value.errType, [...path, "errType"], valueTypeNames, objectTypeNames)];
-		case "ref": return valueTypeNames.has(type.value.name) ? [] : [{
-			message: `Unknown value type reference: "${type.value.name}".`,
-			path: [...path, "name"]
-		}];
-	}
-}
-function validateStructFields(fields, path, valueTypeNames, objectTypeNames) {
-	const fieldNames = /* @__PURE__ */ new Set();
-	const errors = [];
-	for (let i = 0; i < fields.length; i++) {
-		const field = fields[i];
-		const fieldPath = [...path, i];
-		if (fieldNames.has(field.name)) errors.push({
-			message: `Duplicate field name: "${field.name}".`,
-			path: [...fieldPath, "name"]
-		});
-		fieldNames.add(field.name);
-		errors.push(...validateTypeDef(field.type, [...fieldPath, "type"], valueTypeNames, objectTypeNames));
-	}
-	return errors;
-}
-function validateUnionVariants(variants, path, valueTypeNames, objectTypeNames) {
-	const seen = /* @__PURE__ */ new Set();
-	const errors = [];
-	for (let i = 0; i < variants.length; i++) {
-		const variant = variants[i];
-		const variantPath = [...path, i];
-		if (seen.has(variant.name)) errors.push({
-			message: `Duplicate variant name: "${variant.name}".`,
-			path: [...variantPath, "name"]
-		});
-		seen.add(variant.name);
-		errors.push(...validateTypeDef(variant.type, [...variantPath, "type"], valueTypeNames, objectTypeNames));
-	}
-	return errors;
-}
-function validateProperties(properties, path, valueTypeNames, objectTypeNames) {
-	const names = /* @__PURE__ */ new Set();
-	const errors = [];
-	for (let i = 0; i < properties.length; i++) {
-		const prop = properties[i];
-		const propPath = [...path, i];
-		if (names.has(prop.name)) errors.push({
-			message: `Duplicate property name: "${prop.name}".`,
-			path: [...propPath, "name"]
-		});
-		names.add(prop.name);
-		errors.push(...validateTypeDef(prop.type, [...propPath, "type"], valueTypeNames, objectTypeNames));
-	}
-	return errors;
-}
-function resolveType(type, valueTypes, seen = /* @__PURE__ */ new Set()) {
-	if (type.kind !== "ref") return type;
-	const name = type.value.name;
-	if (seen.has(name)) return;
-	const resolved = valueTypes.get(name);
-	if (!resolved) return;
-	return resolveType(resolved, valueTypes, /* @__PURE__ */ new Set([...seen, name]));
-}
-function resolveFieldType(type, path, valueTypes) {
-	const resolvedType = resolveType(type, valueTypes);
-	if (!resolvedType) return;
-	if (path.length === 0) return resolvedType;
-	const [segment, ...rest] = path;
-	switch (resolvedType.kind) {
-		case "optional": return resolveFieldType(resolvedType.value.type, path, valueTypes);
-		case "struct": {
-			const field = resolvedType.value.fields.find((candidate) => candidate.name === segment);
-			return field ? resolveFieldType(field.type, rest, valueTypes) : void 0;
-		}
-		default: return;
-	}
-}
-function resolveExpressionType(expression, parameters, valueTypes, objectTypes, linkTypes, contextType, locals) {
-	switch (expression.kind) {
-		case "inputReference": return parameters.get(expression.value.name)?.type;
-		case "contextReference": return contextType ? resolveFieldType(contextType, [expression.value.name], valueTypes) : void 0;
-		case "localReference": return locals.get(expression.value.name);
-		case "getAt": {
-			const sourceType = resolveExpressionType(expression.value.source, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-			if (!sourceType || expression.value.path.length === 0) return;
-			if (sourceType.kind === "ontologyObject") {
-				const [propertyName, ...rest] = expression.value.path;
-				const property = objectTypes.get(sourceType.objectType)?.properties.find((candidate) => candidate.name === propertyName);
-				return property ? resolveFieldType(property.type, rest, valueTypes) : void 0;
-			}
-			return resolveFieldType(sourceType, expression.value.path, valueTypes);
-		}
-		case "objectLookup": {
-			const referenceType = resolveExpressionType(expression.value.reference, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-			const resolved = referenceType?.kind === "ontologyObject" ? void 0 : referenceType ? unwrapOptionalType(referenceType, valueTypes) : void 0;
-			return resolved?.kind === "objectReference" ? {
-				kind: "ontologyObject",
-				objectType: resolved.value.objectType
-			} : void 0;
-		}
-		case "linkHop": {
-			const sourceType = resolveExpressionType(expression.value.source, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-			if (sourceType?.kind !== "ontologyObject") return;
-			const link = resolveLinkHop({
-				objectTypes: [...objectTypes.values()],
-				linkTypes: [...linkTypes]
-			}, sourceType.objectType, expression.value.link);
-			if (!link) return void 0;
-			const foreignKeyOnSource = isLinkHopFromForeignKeySource(link, sourceType.objectType, expression.value.link);
-			if (!foreignKeyOnSource && link.cardinality === "many") return;
-			return {
-				kind: "ontologyObject",
-				objectType: foreignKeyOnSource ? link.target.objectType : link.source.objectType
-			};
-		}
-		case "struct": return {
-			kind: "struct",
-			value: { fields: expression.value.fields.map((field) => ({
-				name: field.name,
-				displayName: field.name,
-				type: (() => {
-					const resolved = resolveExpressionType(field.value, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-					return resolved && resolved.kind !== "ontologyObject" ? resolved : {
-						kind: "unknown",
-						value: {}
-					};
-				})()
-			})) }
-		};
-		case "map": {
-			const sourceType = resolveExpressionType(expression.value.source, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-			const listType = sourceType && sourceType.kind !== "ontologyObject" ? unwrapOptionalType(sourceType, valueTypes) : void 0;
-			if (listType?.kind !== "list") return;
-			const bodyLocals = new Map(locals);
-			bodyLocals.set(expression.value.binding, listType.value.elementType);
-			const bodyType = resolveExpressionType(expression.value.body, parameters, valueTypes, objectTypes, linkTypes, contextType, bodyLocals);
-			return bodyType && bodyType.kind !== "ontologyObject" ? {
-				kind: "list",
-				value: { elementType: bodyType }
-			} : void 0;
-		}
-		case "literal": return {
-			kind: "unknown",
-			value: {}
-		};
-		case "uuid": return {
-			kind: "string",
-			value: {}
-		};
-		case "now": return {
-			kind: "timestamp",
-			value: {}
-		};
-	}
-}
-function validateExpression(expression, parameters, path, valueTypes, objectTypes, linkTypes, contextType, locals = /* @__PURE__ */ new Map()) {
-	switch (expression.kind) {
-		case "inputReference":
-			if (!parameters.get(expression.value.name)) return [{
-				message: `Unknown action parameter: "${expression.value.name}".`,
-				path: [...path, "name"]
-			}];
-			return [];
-		case "contextReference":
-			if (!contextType) return [];
-			return resolveFieldType(contextType, [expression.value.name], valueTypes) ? [] : [{
-				message: `Unknown context value: "${expression.value.name}".`,
-				path: [...path, "name"]
-			}];
-		case "localReference":
-			if (!locals.get(expression.value.name)) return [{
-				message: `Unknown expression binding: "${expression.value.name}".`,
-				path: [...path, "name"]
-			}];
-			return [];
-		case "getAt":
-		case "objectLookup":
-		case "linkHop": {
-			const childKey = expression.kind === "objectLookup" ? "reference" : "source";
-			const errors = validateExpression(expression.kind === "objectLookup" ? expression.value.reference : expression.value.source, parameters, [...path, childKey], valueTypes, objectTypes, linkTypes, contextType, locals);
-			if (expression.kind === "getAt" && expression.value.path.length === 0) errors.push({
-				message: "Get-at expression paths must not be empty.",
-				path: [...path, "path"]
-			});
-			if (!resolveExpressionType(expression, parameters, valueTypes, objectTypes, linkTypes, contextType, locals)) errors.push({
-				message: expression.kind === "getAt" ? "Get-at expression source and path must resolve structurally." : expression.kind === "objectLookup" ? "Object lookup references must resolve to an object reference." : "Link hop must resolve to a named to-one link.",
-				path
-			});
-			return errors;
-		}
-		case "struct": {
-			const errors = [];
-			const names = /* @__PURE__ */ new Set();
-			for (let index = 0; index < expression.value.fields.length; index++) {
-				const field = expression.value.fields[index];
-				if (names.has(field.name)) errors.push({
-					message: `Duplicate struct expression field: "${field.name}".`,
-					path: [
-						...path,
-						"fields",
-						index,
-						"name"
-					]
-				});
-				names.add(field.name);
-				errors.push(...validateExpression(field.value, parameters, [
-					...path,
-					"fields",
-					index,
-					"value"
-				], valueTypes, objectTypes, linkTypes, contextType, locals));
-			}
-			return errors;
-		}
-		case "map": {
-			const errors = validateExpression(expression.value.source, parameters, [...path, "source"], valueTypes, objectTypes, linkTypes, contextType, locals);
-			const sourceType = resolveExpressionType(expression.value.source, parameters, valueTypes, objectTypes, linkTypes, contextType, locals);
-			const listType = sourceType && sourceType.kind !== "ontologyObject" ? unwrapOptionalType(sourceType, valueTypes) : void 0;
-			if (sourceType && listType?.kind !== "list") errors.push({
-				message: "Map expression source must resolve to a list.",
-				path: [...path, "source"]
-			});
-			if (!expression.value.binding) errors.push({
-				message: "Map expression binding must not be empty.",
-				path: [...path, "binding"]
-			});
-			const bodyLocals = new Map(locals);
-			bodyLocals.set(expression.value.binding, listType?.kind === "list" ? listType.value.elementType : {
-				kind: "unknown",
-				value: {}
-			});
-			errors.push(...validateExpression(expression.value.body, parameters, [...path, "body"], valueTypes, objectTypes, linkTypes, contextType, bodyLocals));
-			return errors;
-		}
-		case "uuid":
-		case "now":
-		case "literal": return [];
-	}
-}
-function unwrapOptionalType(type, valueTypes) {
-	const resolved = resolveType(type, valueTypes);
-	return resolved?.kind === "optional" ? unwrapOptionalType(resolved.value.type, valueTypes) : resolved;
-}
-function areDefaultTypesCompatible(target, source, valueTypes) {
-	const targetType = unwrapOptionalType(target, valueTypes);
-	const sourceType = unwrapOptionalType(source, valueTypes);
-	if (!targetType || !sourceType) return false;
-	if (targetType.kind === "unknown" || sourceType.kind === "unknown") return true;
-	if (targetType.kind !== sourceType.kind) return false;
-	if (targetType.kind === "objectReference" && sourceType.kind === "objectReference") return targetType.value.objectType === sourceType.value.objectType;
-	if (targetType.kind === "list" && sourceType.kind === "list") return areDefaultTypesCompatible(targetType.value.elementType, sourceType.value.elementType, valueTypes);
-	return true;
-}
-function validateActionObjectReference(reference, parameters, path, valueTypes, objectTypes) {
-	const parameterName = reference.name;
-	const parameter = parameters.get(parameterName);
-	if (!parameter) return { errors: [{
-		message: `Unknown action parameter: "${parameterName}".`,
-		path: [...path, "name"]
-	}] };
-	const resolved = resolveType(parameter.type, valueTypes);
-	if (!resolved || resolved.kind !== "objectReference") return { errors: [{
-		message: `Action target parameter "${parameterName}" must be an object reference.`,
-		path: [...path, "name"]
-	}] };
-	const targetObjectType = objectTypes.get(resolved.value.objectType);
-	return targetObjectType ? {
-		errors: [],
-		objectType: targetObjectType
-	} : { errors: [{
-		message: `Unknown object type reference: "${resolved.value.objectType}".`,
-		path: [...path, "name"]
-	}] };
-}
-function validateActionPropertyAssignment(assignment, target, parameters, path, valueTypes, objectTypes, linkTypes, contextType) {
-	if (assignment.property.length === 0) return [{
-		message: "Action property assignments must specify a property.",
-		path: [...path, "property"]
-	}];
-	const [propertyName, ...rest] = assignment.property;
-	const property = target.properties.find((candidate) => candidate.name === propertyName);
-	if (!property) return [{
-		message: `Unknown property "${propertyName}" on object type "${target.name}".`,
-		path: [...path, "property"]
-	}];
-	const resolved = resolveFieldType(property.type, rest, valueTypes);
-	const errors = validateExpression(assignment.value, parameters, [...path, "value"], valueTypes, objectTypes, linkTypes, contextType);
-	return resolved ? errors : [...errors, {
-		message: `Invalid property "${assignment.property.join(".")}" on object type "${target.name}".`,
-		path: [...path, "property"]
-	}];
-}
-function validateAction(action, path, valueTypes, objectTypes, linkTypes, contextType) {
-	const errors = [];
-	const parameters = new Map(action.parameters.map((parameter) => [parameter.name, parameter]));
-	const seenParameters = /* @__PURE__ */ new Set();
-	for (let index = 0; index < action.parameters.length; index++) {
-		const parameter = action.parameters[index];
-		const parameterPath = [
-			...path,
-			"parameters",
-			index
-		];
-		if (seenParameters.has(parameter.name)) errors.push({
-			message: `Duplicate action parameter name: "${parameter.name}".`,
-			path: [...parameterPath, "name"]
-		});
-		seenParameters.add(parameter.name);
-		errors.push(...validateTypeDef(parameter.type, [...parameterPath, "type"], new Set(valueTypes.keys()), new Set(objectTypes.keys())));
-		if (parameter.defaultValue) {
-			errors.push(...validateExpression(parameter.defaultValue, parameters, [...parameterPath, "defaultValue"], valueTypes, objectTypes, linkTypes, contextType));
-			const sourceType = resolveExpressionType(parameter.defaultValue, parameters, valueTypes, objectTypes, linkTypes, contextType, /* @__PURE__ */ new Map());
-			if (sourceType && sourceType.kind !== "ontologyObject" && !areDefaultTypesCompatible(parameter.type, sourceType, valueTypes)) errors.push({
-				message: `Default value for "${parameter.name}" has an incompatible type.`,
-				path: [...parameterPath, "defaultValue"]
-			});
-		}
-	}
-	for (let index = 0; index < action.logic.length; index++) {
-		const step = action.logic[index];
-		const stepPath = [
-			...path,
-			"logic",
-			index
-		];
-		switch (step.kind) {
-			case "createObject": {
-				const objectType = objectTypes.get(step.value.objectType);
-				if (!objectType) {
-					errors.push({
-						message: `Unknown object type "${step.value.objectType}" in action "${action.name}".`,
-						path: [
-							...stepPath,
-							"value",
-							"objectType"
-						]
-					});
-					continue;
-				}
-				for (let valueIndex = 0; valueIndex < step.value.values.length; valueIndex++) errors.push(...validateActionPropertyAssignment(step.value.values[valueIndex], objectType, parameters, [
-					...stepPath,
-					"value",
-					"values",
-					valueIndex
-				], valueTypes, objectTypes, linkTypes, contextType));
-				break;
-			}
-			case "updateObject": {
-				const target = validateActionObjectReference(step.value.object, parameters, [
-					...stepPath,
-					"value",
-					"object"
-				], valueTypes, objectTypes);
-				errors.push(...target.errors);
-				if (!target.objectType) continue;
-				for (let valueIndex = 0; valueIndex < step.value.values.length; valueIndex++) errors.push(...validateActionPropertyAssignment(step.value.values[valueIndex], target.objectType, parameters, [
-					...stepPath,
-					"value",
-					"values",
-					valueIndex
-				], valueTypes, objectTypes, linkTypes, contextType));
-				break;
-			}
-			case "deleteObject": errors.push(...validateActionObjectReference(step.value.object, parameters, [
-				...stepPath,
-				"value",
-				"object"
-			], valueTypes, objectTypes).errors);
-		}
-	}
-	return errors;
-}
-function validateQueryFunctionType(queryFunctionType, path, valueTypeNames, objectTypeNames) {
-	const errors = [];
-	const seenParameters = /* @__PURE__ */ new Set();
-	for (let index = 0; index < queryFunctionType.parameters.length; index++) {
-		const parameter = queryFunctionType.parameters[index];
-		const parameterPath = [
-			...path,
-			"parameters",
-			index
-		];
-		if (seenParameters.has(parameter.name)) errors.push({
-			message: `Duplicate query function parameter name: "${parameter.name}".`,
-			path: [...parameterPath, "name"]
-		});
-		seenParameters.add(parameter.name);
-		errors.push(...validateTypeDef(parameter.type, [...parameterPath, "type"], valueTypeNames, objectTypeNames));
-	}
-	errors.push(...validateTypeDef(queryFunctionType.returnType, [...path, "returnType"], valueTypeNames, objectTypeNames));
-	return errors;
-}
-function validate(ontology) {
-	const errors = [];
-	const valueTypeNames = /* @__PURE__ */ new Set();
-	for (let i = 0; i < ontology.types.length; i++) {
-		const vt = ontology.types[i];
-		if (valueTypeNames.has(vt.name)) errors.push({
-			message: `Duplicate value type name: "${vt.name}".`,
-			path: [
-				"types",
-				i,
-				"name"
-			]
-		});
-		valueTypeNames.add(vt.name);
-	}
-	const objectTypeNames = /* @__PURE__ */ new Set();
-	for (let i = 0; i < ontology.objectTypes.length; i++) {
-		const ot = ontology.objectTypes[i];
-		if (objectTypeNames.has(ot.name)) errors.push({
-			message: `Duplicate object type name: "${ot.name}".`,
-			path: [
-				"objectTypes",
-				i,
-				"name"
-			]
-		});
-		objectTypeNames.add(ot.name);
-	}
-	const valueTypes = new Map(ontology.types.map((type) => [type.name, type.type]));
-	const objectTypes = new Map(ontology.objectTypes.map((objectType) => [objectType.name, objectType]));
-	if (ontology.contextType) {
-		errors.push(...validateTypeDef(ontology.contextType, ["contextType"], valueTypeNames, objectTypeNames));
-		const resolvedContextType = resolveType(ontology.contextType, valueTypes);
-		if (resolvedContextType?.kind === "struct") {
-			const userField = resolvedContextType.value.fields.find((field) => field.name === "user");
-			const unwrappedUserType = userField ? unwrapType(userField.type).type : void 0;
-			const resolvedUserType = unwrappedUserType ? resolveType(unwrappedUserType, valueTypes) : void 0;
-			if (userField && resolvedUserType?.kind !== "objectReference") errors.push({
-				message: "Reserved context field \"user\" must be an object reference.",
-				path: [
-					"contextType",
-					"fields",
-					resolvedContextType.value.fields.indexOf(userField),
-					"type"
-				]
-			});
-		}
-	}
-	for (let i = 0; i < ontology.types.length; i++) {
-		const vt = ontology.types[i];
-		errors.push(...validateTypeDef(vt.type, [
-			"types",
-			i,
-			"type"
-		], valueTypeNames, objectTypeNames));
-	}
-	for (let i = 0; i < ontology.objectTypes.length; i++) {
-		const ot = ontology.objectTypes[i];
-		const otPath = ["objectTypes", i];
-		errors.push(...validateProperties(ot.properties, [...otPath, "properties"], valueTypeNames, objectTypeNames));
-		const propertyNames = new Set(ot.properties.map((p) => p.name));
-		if (!propertyNames.has(ot.primaryKey)) errors.push({
-			message: `Primary key "${ot.primaryKey}" does not reference a valid property.`,
-			path: [...otPath, "primaryKey"]
-		});
-		if (ot.title && !propertyNames.has(ot.title)) errors.push({
-			message: `Title "${ot.title}" does not reference a valid property.`,
-			path: [...otPath, "title"]
-		});
-	}
-	const linkIds = /* @__PURE__ */ new Set();
-	const linkNames = /* @__PURE__ */ new Set();
-	for (let i = 0; i < ontology.linkTypes.length; i++) {
-		const lt = ontology.linkTypes[i];
-		const ltPath = ["linkTypes", i];
-		if (linkIds.has(lt.id)) errors.push({
-			message: `Duplicate link type id: "${lt.id}".`,
-			path: [...ltPath, "id"]
-		});
-		linkIds.add(lt.id);
-		const linkName = `${lt.source.objectType}:${lt.target.name}`;
-		if (linkNames.has(linkName)) errors.push({
-			message: `Duplicate link type target name: "${lt.target.name}" on "${lt.source.objectType}".`,
-			path: [
-				...ltPath,
-				"target",
-				"name"
-			]
-		});
-		linkNames.add(linkName);
-		if (!objectTypeNames.has(lt.source.objectType)) errors.push({
-			message: `Source object type "${lt.source.objectType}" does not exist.`,
-			path: [
-				...ltPath,
-				"source",
-				"objectType"
-			]
-		});
-		if (!objectTypeNames.has(lt.target.objectType)) errors.push({
-			message: `Target object type "${lt.target.objectType}" does not exist.`,
-			path: [
-				...ltPath,
-				"target",
-				"objectType"
-			]
-		});
-		const foreignKeyRoot = lt.foreignKey.split(".")[0];
-		const sourceType = ontology.objectTypes.find((candidate) => candidate.name === lt.source.objectType);
-		const sourceHasFk = sourceType?.properties.some((property) => property.name === foreignKeyRoot) ?? false;
-		if (sourceType && !sourceHasFk) errors.push({
-			message: `Foreign key "${lt.foreignKey}" does not exist on source object type "${lt.source.objectType}" for link "${lt.id}".`,
-			path: [...ltPath, "foreignKey"]
-		});
-	}
-	const actionNames = /* @__PURE__ */ new Set();
-	for (let i = 0; i < ontology.actionTypes.length; i++) {
-		const action = ontology.actionTypes[i];
-		const actionPath = ["actionTypes", i];
-		if (actionNames.has(action.name)) errors.push({
-			message: `Duplicate action type name: "${action.name}".`,
-			path: [...actionPath, "name"]
-		});
-		actionNames.add(action.name);
-		errors.push(...validateAction(action, actionPath, valueTypes, objectTypes, ontology.linkTypes, ontology.contextType));
-	}
-	const queryFunctionTypeNames = /* @__PURE__ */ new Set();
-	for (let i = 0; i < ontology.queryFunctionTypes.length; i++) {
-		const queryFunctionType = ontology.queryFunctionTypes[i];
-		const queryFunctionTypePath = ["queryFunctionTypes", i];
-		if (queryFunctionTypeNames.has(queryFunctionType.name)) errors.push({
-			message: `Duplicate query function type name: "${queryFunctionType.name}".`,
-			path: [...queryFunctionTypePath, "name"]
-		});
-		queryFunctionTypeNames.add(queryFunctionType.name);
-		errors.push(...validateQueryFunctionType(queryFunctionType, queryFunctionTypePath, valueTypeNames, objectTypeNames));
-	}
-	return errors.length === 0 ? {
-		kind: "ok",
-		value: void 0
-	} : {
-		kind: "err",
-		value: errors
-	};
-}
-//#endregion
-export { validate };
-
-//# sourceMappingURL=validate.js.map