@nhtio/validation 0.1.0-master-f8c72f13 → 0.1.0-master-649f9ed8

package/index.cjs

@@ -13870,7 +13870,7 @@ const knexMessages = {
 	"knex.internal": "Database validation error on {{#label}}"
 };
 const knexClientCache = new WeakMap();
-const isReference = (obj, root) => {
+const isReference$1 = (obj, root) => {
 	return root.isRef(obj);
 };
 const resolveKnex = (connection) => {
@@ -13917,9 +13917,26 @@ const getMergableMessages = (schema) => {
 	return {};
 };
 function setKnexConnection(connection) {
-	if ("keys" in this.$_terms) this.$_terms.keys.forEach((item, index) => {
-		this.$_terms.keys[index].schema = setKnexConnection.call(item.schema, connection);
-	});
+	if ("undefined" !== typeof this.$_terms) {
+		if ("keys" in this.$_terms && null !== this.$_terms.keys) this.$_terms.keys.forEach((item, index) => {
+			this.$_terms.keys[index].schema = setKnexConnection.call(item.schema, connection);
+		});
+		if ("matches" in this.$_terms && null !== this.$_terms.matches) this.$_terms.matches = this.$_terms.matches.map((match$2) => {
+			return {
+				...match$2,
+				schema: match$2.schema ? setKnexConnection.call(match$2.schema, connection) : void 0,
+				switch: match$2.switch ? match$2.switch.map((branch) => ({
+					is: branch.is ? setKnexConnection.call(branch.is, connection) : void 0,
+					then: branch.then ? setKnexConnection.call(branch.then, connection) : void 0,
+					else: branch.else ? setKnexConnection.call(branch.else, connection) : void 0
+				})) : void 0
+			};
+		});
+		if ("_exclusions" in this.$_terms && null !== this.$_terms._exclusions) this.$_terms._exclusions = this.$_terms._exclusions.map((exclusion) => setKnexConnection.call(exclusion, connection));
+		if ("_inclusions" in this.$_terms && null !== this.$_terms._inclusions) this.$_terms._inclusions = this.$_terms._inclusions.map((inclusion) => setKnexConnection.call(inclusion, connection));
+		if ("_requireds" in this.$_terms && null !== this.$_terms._requireds) this.$_terms._requireds = this.$_terms._requireds.map((required) => setKnexConnection.call(required, connection));
+		if ("items" in this.$_terms && null !== this.$_terms.items) this.$_terms.items = this.$_terms.items.map((item) => setKnexConnection.call(item, connection));
+	}
 	const toSet = this.$_knex || this.$_getFlag("knexConnection") || connection;
 	this.$_knex = toSet;
 	return this.$_setFlag("knexConnection", toSet);
@@ -13941,6 +13958,28 @@ const knex$1 = (schema, root, args$1) => {
 	const originalMessages = getMergableMessages(schema);
 	const mergedMessages = import_messages.merge(originalMessages, knexMessages);
 	prototype._definition.messages = mergedMessages;
+	prototype._definition.flags.knexConnection = {
+		default: void 0,
+		setter: "knex"
+	};
+	prototype._definition.flags.knexFunctionArgs = {
+		default: {},
+		setter: "setKnexFunctionArgs"
+	};
+	if (!prototype.setKnexFunctionArgs) prototype.setKnexFunctionArgs = function(knexFunctionArgs) {
+		return this.$_setFlag("knexFunctionArgs", knexFunctionArgs);
+	};
+	if (!prototype.setArgsForFnCall) prototype.setArgsForFnCall = function(id, knexFunctionArgs) {
+		const currentArgs = this.$_getFlag("knexFunctionArgs") || {};
+		knexFunctionArgs = {
+			...currentArgs,
+			[id]: knexFunctionArgs
+		};
+		return this.$_setFlag("knexFunctionArgs", knexFunctionArgs);
+	};
+	if (!prototype.getArgsForFnCall) prototype.getArgsForFnCall = function(id) {
+		return this.$_getFlag("knexFunctionArgs")[id];
+	};
 	if (!prototype.knex) prototype.knex = function(connection) {
 		return setKnexConnection.call(this, connection);
 	};
@@ -13953,13 +13992,19 @@ const knex$1 = (schema, root, args$1) => {
 			filter: () => {},
 			...options
 		};
-		let connection = findKnexConnection.call(this);
-		return this.external(async (value, helpers) => {
+		const returnable = this.setArgsForFnCall("uniqueInDb", {
+			table,
+			column,
+			options: opts
+		});
+		let connection = findKnexConnection.call(returnable);
+		return returnable.external(async (value, helpers) => {
 			const { prefs, state, error, schema: localSchema } = helpers;
 			if (!connection && localSchema._flags) connection = localSchema._flags.knexConnection;
 			if (!connection) return error("knex.missingConnection", { value });
-			const resolvedTable = isReference(table, root) ? table.resolve(value, state, prefs) : table;
-			const resolvedColumn = isReference(column, root) ? column.resolve(value, state, prefs) : column;
+			const { table: tableArg, column: columnArg, options: optsArg } = localSchema.getArgsForFnCall("uniqueInDb");
+			const resolvedTable = isReference$1(tableArg, localSchema.$_root) ? tableArg.resolve(value, state, prefs) : tableArg;
+			const resolvedColumn = isReference$1(columnArg, localSchema.$_root) ? columnArg.resolve(value, state, prefs) : columnArg;
 			if (!resolvedTable || typeof resolvedTable !== "string") return error("knex.invalidTable", {
 				value,
 				table: resolvedTable,
@@ -13971,14 +14016,14 @@ const knex$1 = (schema, root, args$1) => {
 				column: resolvedColumn
 			});
 			if (value === null || value === void 0) return value;
+			const { client, query } = resolveQueryBuilder(connection, resolvedTable);
 			try {
-				const { client, query } = resolveQueryBuilder(connection, resolvedTable);
 				query.select(resolvedColumn).limit(1);
-				if (opts.caseInsensitive) query.whereRaw(`lower(${resolvedColumn}) = ?`, [client.raw("lower(?)", [value])]);
+				if (optsArg.caseInsensitive) query.whereRaw(`lower(${resolvedColumn}) = ?`, [client.raw("lower(?)", [value])]);
 				else query.where(resolvedColumn, value);
-				if (opts.filter) {
+				if (optsArg.filter) {
 					const { error: errorFn, warn: warnFn, message: messageFn,...safeHelpers } = helpers;
-					await opts.filter(query, value, resolvedColumn, safeHelpers);
+					await optsArg.filter(query, value, resolvedColumn, safeHelpers);
 				}
 				const row = await query.first();
 				if (row) return error("knex.unique", {
@@ -14003,13 +14048,19 @@ const knex$1 = (schema, root, args$1) => {
 			filter: () => {},
 			...options
 		};
-		let connection = findKnexConnection.call(this);
-		return this.external(async (value, helpers) => {
+		const returnable = this.setArgsForFnCall("existsInDb", {
+			table,
+			column,
+			options: opts
+		});
+		let connection = findKnexConnection.call(returnable);
+		return returnable.external(async (value, helpers) => {
 			const { prefs, state, error, schema: localSchema } = helpers;
 			if (!connection && localSchema._flags) connection = localSchema._flags.knexConnection;
 			if (!connection) return error("knex.missingConnection", { value });
-			const resolvedTable = isReference(table, root) ? table.resolve(value, state, prefs) : table;
-			const resolvedColumn = isReference(column, root) ? column.resolve(value, state, prefs) : column;
+			const { table: tableArg, column: columnArg, options: optsArg } = localSchema.getArgsForFnCall("existsInDb");
+			const resolvedTable = isReference$1(tableArg, localSchema.$_root) ? tableArg.resolve(value, state, prefs) : tableArg;
+			const resolvedColumn = isReference$1(columnArg, localSchema.$_root) ? columnArg.resolve(value, state, prefs) : columnArg;
 			if (!resolvedTable || typeof resolvedTable !== "string") return error("knex.invalidTable", {
 				value,
 				table: resolvedTable,
@@ -14021,14 +14072,14 @@ const knex$1 = (schema, root, args$1) => {
 				column: resolvedColumn
 			});
 			if (value === null || value === void 0) return value;
+			const { client, query } = resolveQueryBuilder(connection, resolvedTable);
 			try {
-				const { client, query } = resolveQueryBuilder(connection, resolvedTable);
 				query.select(resolvedColumn).limit(1);
-				if (opts.caseInsensitive) query.whereRaw(`lower(${resolvedColumn}) = ?`, [client.raw("lower(?)", [value])]);
+				if (optsArg.caseInsensitive) query.whereRaw(`lower(${resolvedColumn}) = ?`, [client.raw("lower(?)", [value])]);
 				else query.where(resolvedColumn, value);
-				if (opts.filter) {
+				if (optsArg.filter) {
 					const { error: errorFn, warn: warnFn, message: messageFn,...safeHelpers } = helpers;
-					await opts.filter(query, value, resolvedColumn, safeHelpers);
+					await optsArg.filter(query, value, resolvedColumn, safeHelpers);
 				}
 				const row = await query.first();
 				if (!row) return error("knex.exists", {
@@ -110857,6 +110908,132 @@ function strFromU8(dat, latin1) {
 	}
 }
 var import_semver = __toESM(require_semver());
+var StringifiedFunctionParser = class StringifiedFunctionParser {
+	#namedBindings;
+	#argNames;
+	#functionBody;
+	#isExpressionBody = false;
+	#isAsync = false;
+	#isGenerator = false;
+	constructor(functionString, namedBindings) {
+		this.#namedBindings = new Map();
+		this.#argNames = [];
+		this.#functionBody = "";
+		if (isPlainObject(namedBindings)) Object.entries(namedBindings).forEach(([key, value]) => {
+			this.#namedBindings.set(key, value);
+		});
+		const trimmed = functionString.trim();
+		this.#parseArgNames(trimmed);
+		this.#parseFunctionBody(trimmed);
+	}
+	#parseArgNames(trimmed) {
+		const patterns = [
+			/^\s*(?:async\s+)?\(([^)]*)\)\s*=>/,
+			/^\s*(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/,
+			/^\s*(?:async\s+)?function\s*(?:\*\s*)?(?:[a-zA-Z_$][a-zA-Z0-9_$]*)?\s*\(([^)]*)\)/,
+			/^\s*(?:async\s+)?(?:\*\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(([^)]*)\)\s*\{/
+		];
+		let paramString = "";
+		for (const pattern of patterns) {
+			const match$2 = trimmed.match(pattern);
+			if (match$2) {
+				paramString = match$2[1] || match$2[2] || "";
+				break;
+			}
+		}
+		if (!paramString || !paramString.trim()) return;
+		const args$1 = [];
+		let current = "";
+		let depth = 0;
+		let inString = false;
+		let stringChar = "";
+		for (let i$4 = 0; i$4 < paramString.length; i$4++) {
+			const char = paramString[i$4];
+			const prevChar = i$4 > 0 ? paramString[i$4 - 1] : "";
+			if ((char === "\"" || char === "'" || char === "`") && prevChar !== "\\") {
+				if (!inString) {
+					inString = true;
+					stringChar = char;
+				} else if (char === stringChar) inString = false;
+			}
+			if (!inString) {
+				if (char === "{" || char === "[" || char === "(") depth++;
+				else if (char === "}" || char === "]" || char === ")") depth--;
+				if (char === "," && depth === 0) {
+					const processed = this.#processParameter(current.trim());
+					if (processed) args$1.push(processed);
+					current = "";
+					continue;
+				}
+			}
+			current += char;
+		}
+		if (current.trim()) {
+			const processed = this.#processParameter(current.trim());
+			if (processed) args$1.push(processed);
+		}
+		this.#argNames.push(...args$1);
+	}
+	#processParameter(param) {
+		if (!param) return "";
+		param = param.trim();
+		if (param.startsWith("...")) return param.slice(3).trim().split(/[\s=]/)[0];
+		if (param.startsWith("{") || param.startsWith("[")) return param.split(/[\s=:]/)[0];
+		const nameMatch = param.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+		return nameMatch ? nameMatch[1] : "";
+	}
+	#parseFunctionBody(trimmed) {
+		this.#isAsync = /^\s*async\s+/.test(trimmed);
+		const arrowExpressionMatch = trimmed.match(/^\s*(async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>\s*(.+)$/s);
+		if (arrowExpressionMatch && !arrowExpressionMatch[2].trimStart().startsWith("{")) {
+			this.#isExpressionBody = true;
+			this.#functionBody = arrowExpressionMatch[2].trim();
+			return;
+		}
+		const arrowBlockMatch = trimmed.match(/^\s*(async\s+)?(?:\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>\s*\{([\s\S]*)\}\s*$/);
+		if (arrowBlockMatch) {
+			this.#functionBody = arrowBlockMatch[2].trim();
+			return;
+		}
+		const functionMatch = trimmed.match(/^\s*(async\s+)?function\s*(\*\s*)?(?:[a-zA-Z_$][a-zA-Z0-9_$]*)?\s*\([^)]*\)\s*\{([\s\S]*)\}\s*$/);
+		if (functionMatch) {
+			this.#isGenerator = !!functionMatch[2];
+			this.#functionBody = functionMatch[3].trim();
+			return;
+		}
+		const methodMatch = trimmed.match(/^\s*(async\s+)?(\*\s*)?[a-zA-Z_$][a-zA-Z0-9_$]*\s*\([^)]*\)\s*\{([\s\S]*)\}\s*$/);
+		if (methodMatch) {
+			this.#isGenerator = !!methodMatch[2];
+			this.#functionBody = methodMatch[3].trim();
+			return;
+		}
+		const firstBrace = trimmed.indexOf("{");
+		const lastBrace = trimmed.lastIndexOf("}");
+		if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+			this.#functionBody = trimmed.substring(firstBrace + 1, lastBrace);
+			return;
+		}
+	}
+	asFunction() {
+		const functionBody = this.#isExpressionBody ? `return ${this.#functionBody}` : this.#functionBody;
+		const bindingNames = Array.from(this.#namedBindings.keys());
+		const allParams = [...bindingNames, ...this.#argNames];
+		const paramList = allParams.join(", ");
+		let functionCode = "";
+		if (this.#isAsync) functionCode = this.#isGenerator ? `async function*(${paramList}) { ${functionBody} }` : `async function(${paramList}) { ${functionBody} }`;
+		else functionCode = this.#isGenerator ? `function*(${paramList}) { ${functionBody} }` : `function(${paramList}) { ${functionBody} }`;
+		const callable = new Function(`return ${functionCode}`)();
+		const namedBindingValues = Array.from(this.#namedBindings.values());
+		function wrapper(...args$1) {
+			return callable.call(this, ...namedBindingValues, ...args$1);
+		}
+		return wrapper;
+	}
+	static parse(functionString, namedBindings) {
+		const parser = new StringifiedFunctionParser(functionString, namedBindings);
+		return parser.asFunction();
+	}
+};
 const utoa = (data) => {
 	const buffer$2 = strToU8(data);
 	const zipped = zlibSync(buffer$2, { level: 9 });
@@ -110872,7 +111049,74 @@ const atou = (base64) => {
 	}
 	return decodeURIComponent(escape(binary));
 };
-const encode = (schema) => {
+const defaultEncoderOptions = { withDatabase: false };
+const isDehydratedValue = (value) => {
+	return isPlainObject(value) && "_encodedType" in value && "_encodedValueType" in value && "_encodedValue" in value;
+};
+const dehydrateValue = (type, value) => {
+	if ("function" === typeof value) value = value.toString();
+	return {
+		_encodedType: type,
+		_encodedValueType: typeof value,
+		_encodedValue: value
+	};
+};
+const dehydrateKnexConnection = (connection) => {
+	if (isPlainObject(connection)) {
+		if ("getReadClient" in connection) return dehydrateValue("knexConnection", connection.getReadClient());
+		return dehydrateValue("knexConnection", connection);
+	} else if ("function" === typeof connection && "undefined" !== typeof connection.client && isPlainObject(connection.client.config)) return dehydrateValue("knexConnection", connection.client.config);
+	throw new TypeError("Cannot dehydrate unexpected type of Knex connection");
+};
+const rehydrateKnexConnection = (dehydrated) => {
+	const db = knex.default;
+	return db(dehydrated._encodedValue);
+};
+const rehydrateFunction = (functionString, namedBindings) => {
+	return StringifiedFunctionParser.parse(functionString, namedBindings);
+};
+const isReference = (obj, root) => {
+	return root.isRef(obj);
+};
+const rehydrateDatabaseFunction = (dehydrated) => {
+	const { _encodedValue: encodedValue } = dehydrated;
+	const { connection: dehydratedConnection, external } = encodedValue;
+	const connection = "function" === typeof dehydratedConnection && "knex" === dehydratedConnection.name ? dehydratedConnection : rehydrateKnexConnection(dehydratedConnection);
+	const rehydratedMethod = rehydrateFunction(external.method, {
+		connection,
+		isReference,
+		resolveQueryBuilder
+	});
+	return {
+		...external,
+		method: rehydratedMethod
+	};
+};
+const rehydrateValue = (dehydrated) => {
+	const { _encodedType: encodedType, _encodedValue: encodedValue } = dehydrated;
+	if (encodedType === "function") {
+		const returnable = rehydrateFunction(encodedValue);
+		if (typeof returnable !== "function") throw new TypeError("Rehydrated value is not a function");
+		return returnable;
+	} else if (encodedType === "knexConnection") return rehydrateKnexConnection(dehydrated);
+	else if (encodedType === "databaseFunction") return rehydrateDatabaseFunction(dehydrated);
+	return encodedValue;
+};
+const isDatabaseRelatedFunction = (fn$1) => {
+	const functionString = fn$1.toString();
+	return functionString.includes("connection =") && functionString.includes(".knexConnection");
+};
+const isExternalsWithDatabaseRelatedFunctionality = (obj) => {
+	return Array.isArray(obj) && obj.some((item) => isPlainObject(item) && "method" in item && "function" === typeof item.method && isDatabaseRelatedFunction(item.method));
+};
+const hasExternalsWithDatabaseRelatedFunctionality = (obj) => {
+	return isPlainObject(obj) && "externals" in obj && isExternalsWithDatabaseRelatedFunctionality(obj.externals);
+};
+const encode = (schema, options = {}) => {
+	const opts = {
+		...defaultEncoderOptions,
+		...options
+	};
 	const description$1 = schema.describe();
 	for (const key in description$1.keys) {
 		if ("undefined" === typeof description$1.keys[key] || "undefined" === typeof description$1.keys[key].rules) continue;
@@ -110885,25 +111129,57 @@ const encode = (schema) => {
 		});
 	}
 	const json$1 = JSON.stringify({
-		version: "0.1.0-master-f8c72f13",
+		version: "0.1.0-master-649f9ed8",
 		schema: description$1
-	}, (_, value) => {
+	}, (key, value) => {
 		if (typeof value === "bigint") return value.toString();
 		if (typeof value === "undefined") return null;
 		if (value instanceof DateTime) return value.toObject();
 		else if (value instanceof Date) return DateTime.fromJSDate(value).toObject();
+		if (hasExternalsWithDatabaseRelatedFunctionality(value)) {
+			const connection = value.flags.knexConnection;
+			value.externals = value.externals.filter((external) => {
+				if (isDatabaseRelatedFunction(external.method) && !opts.withDatabase) return false;
+				return true;
+			}).map((external) => {
+				if (isDatabaseRelatedFunction(external.method)) return dehydrateValue("databaseFunction", {
+					external: {
+						...external,
+						method: external.method.toString()
+					},
+					connection: dehydrateKnexConnection(connection)
+				});
+			});
+		}
+		if (key === "knexConnection") if (!opts.withDatabase) return void 0;
+		else return dehydrateKnexConnection(value);
+		else if (typeof value === "function") if (isDatabaseRelatedFunction(value) && !opts.withDatabase) return dehydrateValue("function", () => {});
+		else return dehydrateValue("function", value);
 		return value;
 	});
 	return utoa(json$1);
 };
-const decode = (base64) => {
+const decode = (base64, options = {}) => {
+	const opts = {
+		...defaultEncoderOptions,
+		...options
+	};
 	const json$1 = atou(base64);
-	const description$1 = JSON.parse(json$1);
+	const description$1 = JSON.parse(json$1, (_, value) => {
+		if (!opts.withDatabase) {
+			if (isPlainObject(value) && "knexConnection" in value) {
+				delete value["knexConnection"];
+				return value;
+			}
+		}
+		if (isDehydratedValue(value)) return rehydrateValue(value);
+		return value;
+	});
 	if (!isPlainObject(description$1) || !("version" in description$1) || !("schema" in description$1) || typeof description$1.version !== "string" || !isPlainObject(description$1.schema)) throw new TypeError("Not a valid encoded schema");
 	const { version: schemaVersion, schema } = description$1;
-	if (import_semver.valid("0.1.0-master-f8c72f13")) {
+	if (import_semver.valid("0.1.0-master-649f9ed8")) {
 		if (!import_semver.valid(import_semver.coerce(schemaVersion))) throw new TypeError(`Invalid schema version: ${schemaVersion}`);
-		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-f8c72f13")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-f8c72f13`);
+		if (import_semver.gt(import_semver.coerce(schemaVersion), "0.1.0-master-649f9ed8")) throw new TypeError(`Schema version ${schemaVersion} is not compatible with current version 0.1.0-master-649f9ed8`);
 	}
 	return validator.build(schema);
 };
@@ -112357,7 +112633,7 @@ init_esm();
 var import_lib = __toESM(require_lib$3());
 var import_lib$1 = __toESM(require_lib$2());
 var import_lib$2 = __toESM(require_lib());
-const version = "0.1.0-master-f8c72f13";
+const version = "0.1.0-master-649f9ed8";
 Object.defineProperty(exports, "ValidationError", {
 	enumerable: true,
 	get: function() {