@atscript/db 0.1.38

package/dist/nested-writer-NEN51mnR.mjs

@@ -0,0 +1,576 @@
+import { resolveRelationTargetTable } from "./relation-helpers-DyBIlQnB.mjs";
+import { ValidatorError } from "@atscript/typescript/utils";
+
+//#region packages/db/src/db-error.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var DbError = class extends Error {
+	constructor(code, errors, message) {
+		super(message ?? errors[0]?.message ?? "Database error"), _define_property(this, "code", void 0), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.code = code, this.errors = errors, this.name = "DbError";
+		this.stack = undefined;
+	}
+};
+
+//#endregion
+//#region packages/db/src/table/error-utils.ts
+function prefixErrorPaths(errors, prefix) {
+	return errors.map((err) => ({
+		...err,
+		path: err.path ? `${prefix}.${err.path}` : prefix
+	}));
+}
+async function wrapNestedError(navField, fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof ValidatorError) throw new ValidatorError(prefixErrorPaths(error.errors, navField));
+		if (error instanceof DbError) throw new DbError(error.code, prefixErrorPaths(error.errors, navField));
+		throw error;
+	}
+}
+async function enrichFkViolation(meta, fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof DbError && error.code === "FK_VIOLATION" && error.errors.every((err) => !err.path)) {
+			const msg = error.errors[0]?.message ?? error.message;
+			const errors = [];
+			for (const [, fk] of meta.foreignKeys) for (const field of fk.fields) errors.push({
+				path: field,
+				message: msg
+			});
+			throw new DbError("FK_VIOLATION", errors.length > 0 ? errors : error.errors);
+		}
+		throw error;
+	}
+}
+async function remapDeleteFkViolation(tableName, fn) {
+	try {
+		return await fn();
+	} catch (error) {
+		if (error instanceof DbError && error.code === "FK_VIOLATION") throw new DbError("CONFLICT", [{
+			path: tableName,
+			message: `Cannot delete from "${tableName}": referenced by child records (RESTRICT)`
+		}]);
+		throw error;
+	}
+}
+
+//#endregion
+//#region packages/db/src/rel/nested-writer.ts
+function checkDepthOverflow(payloads, maxDepth, meta) {
+	if (meta.navFields.size === 0) return;
+	for (const payload of payloads) for (const navField of meta.navFields) if (payload[navField] !== undefined) throw new Error(`Nested data in '${navField}' exceeds maxDepth (${maxDepth}). ` + `Increase maxDepth or strip nested data before writing.`);
+}
+function validateBatch(validator, items, ctx) {
+	for (let i = 0; i < items.length; i++) try {
+		validator.validate(items[i], false, ctx);
+	} catch (error) {
+		if (error instanceof ValidatorError && items.length > 1) throw new ValidatorError(error.errors.map((err) => ({
+			...err,
+			path: `[${i}].${err.path}`
+		})));
+		throw error;
+	}
+}
+async function preValidateNestedFrom(host, originals) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "from") continue;
+		if (!host._writeTableResolver) continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const remoteFK = host._findRemoteFK(targetTable, host.tableName, relation.alias);
+		const allChildren = [];
+		for (const orig of originals) {
+			const children = orig[navField];
+			if (!Array.isArray(children)) continue;
+			for (const child of children) {
+				const childData = { ...child };
+				if (remoteFK) {
+					for (const field of remoteFK.fields) if (!(field in childData)) childData[field] = 0;
+				}
+				allChildren.push(childData);
+			}
+		}
+		if (allChildren.length === 0) continue;
+		await wrapNestedError(navField, () => targetTable.preValidateItems(allChildren, { excludeFkTargetTable: host.tableName }));
+	}
+}
+async function batchInsertNestedTo(host, items, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "to") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const fk = host._findFKForRelation(relation);
+		if (!fk) continue;
+		const parents = [];
+		const sourceIndices = [];
+		for (let i = 0; i < items.length; i++) {
+			const nested = items[i][navField];
+			if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+				parents.push(nested);
+				sourceIndices.push(i);
+			}
+		}
+		if (parents.length === 0) continue;
+		const result = await targetTable.insertMany(parents, {
+			maxDepth,
+			_depth: depth + 1
+		});
+		for (let j = 0; j < sourceIndices.length; j++) if (fk.localFields.length === 1) items[sourceIndices[j]][fk.localFields[0]] = result.insertedIds[j];
+	}
+}
+async function batchInsertNestedFrom(host, originals, parentIds, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "from") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const remoteFK = host._findRemoteFK(targetTable, host.tableName, relation.alias);
+		if (!remoteFK) continue;
+		const allChildren = [];
+		for (let i = 0; i < originals.length; i++) {
+			const children = originals[i][navField];
+			if (!Array.isArray(children)) continue;
+			for (const child of children) {
+				const childData = { ...child };
+				if (remoteFK.fields.length === 1) childData[remoteFK.fields[0]] = parentIds[i];
+				allChildren.push(childData);
+			}
+		}
+		if (allChildren.length === 0) continue;
+		await wrapNestedError(navField, () => targetTable.insertMany(allChildren, {
+			maxDepth,
+			_depth: depth + 1
+		}));
+	}
+}
+async function batchInsertNestedVia(host, originals, parentIds, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "via" || !relation.viaType) continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const junctionTable = host._writeTableResolver(relation.viaType());
+		if (!junctionTable) continue;
+		const targetTableName = resolveRelationTargetTable(relation);
+		const fkToThis = host._findRemoteFK(junctionTable, host.tableName);
+		if (!fkToThis) continue;
+		const fkToTarget = host._findRemoteFK(junctionTable, targetTableName);
+		if (!fkToTarget) continue;
+		const targetPKField = targetTable.primaryKeys[0];
+		if (!targetPKField || fkToTarget.fields.length !== 1 || fkToThis.fields.length !== 1) continue;
+		for (let i = 0; i < originals.length; i++) {
+			const targets = originals[i][navField];
+			if (!Array.isArray(targets) || targets.length === 0) continue;
+			const parentPK = parentIds[i];
+			if (parentPK === undefined) continue;
+			const newTargets = [];
+			const existingIds = [];
+			for (const t of targets) {
+				const rec = t;
+				const pk = rec[targetPKField];
+				if (pk !== undefined && pk !== null) existingIds.push(pk);
+else newTargets.push({ ...rec });
+			}
+			const allTargetIds = [...existingIds];
+			if (newTargets.length > 0) {
+				const targetResult = await targetTable.insertMany(newTargets, {
+					maxDepth,
+					_depth: depth + 1
+				});
+				allTargetIds.push(...targetResult.insertedIds);
+			}
+			if (allTargetIds.length > 0) {
+				const junctionRows = allTargetIds.map((targetId) => ({
+					[fkToThis.fields[0]]: parentPK,
+					[fkToTarget.fields[0]]: targetId
+				}));
+				await junctionTable.insertMany(junctionRows, { maxDepth: 0 });
+			}
+		}
+	}
+}
+async function batchReplaceNestedTo(host, items, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "to") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const fk = host._findFKForRelation(relation);
+		if (!fk) continue;
+		const parents = [];
+		const sourceIndices = [];
+		for (let i = 0; i < items.length; i++) {
+			const nested = items[i][navField];
+			if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+				parents.push(nested);
+				sourceIndices.push(i);
+			}
+		}
+		if (parents.length === 0) continue;
+		await targetTable.bulkReplace(parents, {
+			maxDepth,
+			_depth: depth + 1
+		});
+		for (let j = 0; j < sourceIndices.length; j++) if (fk.localFields.length === 1 && fk.targetFields.length === 1) items[sourceIndices[j]][fk.localFields[0]] = parents[j][fk.targetFields[0]];
+	}
+}
+async function batchReplaceNestedFrom(host, originals, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "from") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const remoteFK = host._findRemoteFK(targetTable, host.tableName, relation.alias);
+		if (!remoteFK) continue;
+		const childPKs = [...targetTable.primaryKeys];
+		for (const original of originals) {
+			const children = original[navField];
+			if (!Array.isArray(children)) continue;
+			const parentPK = host._meta.primaryKeys.length === 1 ? original[host._meta.primaryKeys[0]] : undefined;
+			if (parentPK === undefined || remoteFK.fields.length !== 1) continue;
+			await fromReplace(targetTable, children, parentPK, remoteFK.fields[0], childPKs, navField, maxDepth, depth);
+		}
+	}
+}
+async function batchReplaceNestedVia(host, originals, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "via" || !relation.viaType) continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const junctionTable = host._writeTableResolver(relation.viaType());
+		if (!junctionTable) continue;
+		const targetTableName = resolveRelationTargetTable(relation);
+		const fkToThis = host._findRemoteFK(junctionTable, host.tableName);
+		if (!fkToThis) continue;
+		const fkToTarget = host._findRemoteFK(junctionTable, targetTableName);
+		if (!fkToTarget) continue;
+		const targetPKField = targetTable.primaryKeys[0];
+		if (!targetPKField || fkToTarget.fields.length !== 1 || fkToThis.fields.length !== 1) continue;
+		for (const original of originals) {
+			const targets = original[navField];
+			if (!Array.isArray(targets)) continue;
+			const parentPK = host._meta.primaryKeys.length === 1 ? original[host._meta.primaryKeys[0]] : undefined;
+			if (parentPK === undefined) continue;
+			await viaReplace(targetTable, junctionTable, targets, parentPK, targetPKField, fkToThis.fields[0], fkToTarget.fields[0], maxDepth, depth);
+		}
+	}
+}
+async function batchPatchNestedTo(host, items, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "to") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const fk = host._findFKForRelation(relation);
+		if (!fk) continue;
+		const patches = [];
+		for (const item of items) {
+			const nested = item[navField];
+			if (!nested || typeof nested !== "object" || Array.isArray(nested)) continue;
+			const patch = { ...nested };
+			let fkValue = fk.localFields.length === 1 ? item[fk.localFields[0]] : undefined;
+			if (fkValue === undefined) {
+				const pkFilter = host._extractPrimaryKeyFilter(item);
+				const current = await host.findOne({
+					filter: pkFilter,
+					controls: {}
+				});
+				if (!current) throw new DbError("NOT_FOUND", [{
+					path: navField,
+					message: `Cannot patch relation '${navField}' — source record not found`
+				}]);
+				fkValue = fk.localFields.length === 1 ? current[fk.localFields[0]] : undefined;
+			}
+			if (fkValue === null || fkValue === undefined) throw new DbError("FK_VIOLATION", [{
+				path: fk.localFields[0],
+				message: `Cannot patch relation '${navField}' — foreign key '${fk.localFields[0]}' is null`
+			}]);
+			if (fk.targetFields.length === 1) patch[fk.targetFields[0]] = fkValue;
+			patches.push(patch);
+		}
+		if (patches.length === 0) continue;
+		await targetTable.bulkUpdate(patches, {
+			maxDepth,
+			_depth: depth + 1
+		});
+	}
+}
+async function batchPatchNestedFrom(host, originals, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "from") continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const remoteFK = host._findRemoteFK(targetTable, host.tableName, relation.alias);
+		if (!remoteFK) continue;
+		const childPKs = [...targetTable.primaryKeys];
+		for (const original of originals) {
+			const navValue = original[navField];
+			if (navValue === undefined || navValue === null) continue;
+			const parentPK = host._meta.primaryKeys.length === 1 ? original[host._meta.primaryKeys[0]] : undefined;
+			if (parentPK === undefined || remoteFK.fields.length !== 1) continue;
+			const fkField = remoteFK.fields[0];
+			const ops = extractNavPatchOps(navValue);
+			if (ops.replace) await fromReplace(targetTable, ops.replace, parentPK, fkField, childPKs, navField, maxDepth, depth);
+			if (ops.remove && ops.remove.length > 0) {
+				const removeFilters = ops.remove.map((child) => {
+					const rec = child;
+					const f = {};
+					for (const pk of childPKs) f[pk] = rec[pk];
+					f[fkField] = parentPK;
+					return f;
+				});
+				if (removeFilters.length === 1) await targetTable.deleteMany(removeFilters[0]);
+else await targetTable.deleteMany({ $or: removeFilters });
+			}
+			if (ops.update && ops.update.length > 0) {
+				const items = ops.update.map((child) => {
+					const rec = { ...child };
+					rec[fkField] = parentPK;
+					return rec;
+				});
+				await wrapNestedError(navField, () => targetTable.bulkUpdate(items, {
+					maxDepth,
+					_depth: depth + 1
+				}));
+			}
+			if (ops.upsert) {
+				const toUpdate = [];
+				const toInsert = [];
+				for (const child of ops.upsert) {
+					const rec = { ...child };
+					rec[fkField] = parentPK;
+					const hasPK = childPKs.length > 0 && childPKs.every((pk) => rec[pk] !== undefined);
+					if (hasPK) toUpdate.push(rec);
+else toInsert.push(rec);
+				}
+				if (toUpdate.length > 0) await wrapNestedError(navField, () => targetTable.bulkUpdate(toUpdate, {
+					maxDepth,
+					_depth: depth + 1
+				}));
+				if (toInsert.length > 0) await wrapNestedError(navField, () => targetTable.insertMany(toInsert, {
+					maxDepth,
+					_depth: depth + 1
+				}));
+			}
+			if (ops.insert && ops.insert.length > 0) {
+				const items = ops.insert.map((child) => {
+					const rec = { ...child };
+					rec[fkField] = parentPK;
+					return rec;
+				});
+				await wrapNestedError(navField, () => targetTable.insertMany(items, {
+					maxDepth,
+					_depth: depth + 1
+				}));
+			}
+		}
+	}
+}
+async function batchPatchNestedVia(host, originals, maxDepth, depth) {
+	for (const [navField, relation] of host._meta.relations) {
+		if (relation.direction !== "via" || !relation.viaType) continue;
+		const targetTable = host._writeTableResolver(relation.targetType());
+		if (!targetTable) continue;
+		const junctionTable = host._writeTableResolver(relation.viaType());
+		if (!junctionTable) continue;
+		const targetTableName = resolveRelationTargetTable(relation);
+		const fkToThis = host._findRemoteFK(junctionTable, host.tableName);
+		if (!fkToThis) continue;
+		const fkToTarget = host._findRemoteFK(junctionTable, targetTableName);
+		if (!fkToTarget) continue;
+		const targetPKField = targetTable.primaryKeys[0];
+		if (!targetPKField || fkToTarget.fields.length !== 1 || fkToThis.fields.length !== 1) continue;
+		for (const original of originals) {
+			const navValue = original[navField];
+			if (navValue === undefined || navValue === null) continue;
+			const parentPK = host._meta.primaryKeys.length === 1 ? original[host._meta.primaryKeys[0]] : undefined;
+			if (parentPK === undefined) continue;
+			const ops = extractNavPatchOps(navValue);
+			if (ops.replace) await viaReplace(targetTable, junctionTable, ops.replace, parentPK, targetPKField, fkToThis.fields[0], fkToTarget.fields[0], maxDepth, depth);
+			if (ops.remove && ops.remove.length > 0) {
+				const targetPKs = ops.remove.map((t) => t[targetPKField]).filter((pk) => pk !== undefined && pk !== null);
+				if (targetPKs.length === 1) await junctionTable.deleteMany({
+					[fkToThis.fields[0]]: parentPK,
+					[fkToTarget.fields[0]]: targetPKs[0]
+				});
+else if (targetPKs.length > 1) await junctionTable.deleteMany({
+					[fkToThis.fields[0]]: parentPK,
+					[fkToTarget.fields[0]]: { $in: targetPKs }
+				});
+			}
+			if (ops.update && ops.update.length > 0) await targetTable.bulkUpdate(ops.update.map((t) => ({ ...t })), {
+				maxDepth,
+				_depth: depth + 1
+			});
+			if (ops.upsert && ops.upsert.length > 0) {
+				const toUpdate = [];
+				const toInsert = [];
+				const existingPKs = [];
+				for (const target of ops.upsert) {
+					const rec = { ...target };
+					const pk = rec[targetPKField];
+					if (pk !== undefined && pk !== null) {
+						toUpdate.push(rec);
+						existingPKs.push(pk);
+					} else toInsert.push(rec);
+				}
+				if (toUpdate.length > 0) await targetTable.bulkUpdate(toUpdate, {
+					maxDepth,
+					_depth: depth + 1
+				});
+				if (existingPKs.length > 0) {
+					const existingJunctions = await junctionTable.findMany({
+						filter: {
+							[fkToThis.fields[0]]: parentPK,
+							[fkToTarget.fields[0]]: existingPKs.length === 1 ? existingPKs[0] : { $in: existingPKs }
+						},
+						controls: { $select: [fkToTarget.fields[0]] }
+					});
+					const existingSet = new Set(existingJunctions.map((j) => String(j[fkToTarget.fields[0]])));
+					const missingPKs = existingPKs.filter((pk) => !existingSet.has(String(pk)));
+					if (missingPKs.length > 0) {
+						const junctionRows = missingPKs.map((pk) => ({
+							[fkToThis.fields[0]]: parentPK,
+							[fkToTarget.fields[0]]: pk
+						}));
+						await junctionTable.insertMany(junctionRows, { maxDepth: 0 });
+					}
+				}
+				if (toInsert.length > 0) {
+					const insertResult = await targetTable.insertMany(toInsert, {
+						maxDepth,
+						_depth: depth + 1
+					});
+					const junctionRows = insertResult.insertedIds.map((newId) => ({
+						[fkToThis.fields[0]]: parentPK,
+						[fkToTarget.fields[0]]: newId
+					}));
+					await junctionTable.insertMany(junctionRows, { maxDepth: 0 });
+				}
+			}
+			if (ops.insert && ops.insert.length > 0) {
+				const toInsert = [];
+				const existingIds = [];
+				for (const target of ops.insert) {
+					const rec = { ...target };
+					const pk = rec[targetPKField];
+					if (pk !== undefined && pk !== null) existingIds.push(pk);
+else toInsert.push(rec);
+				}
+				const allIds = [...existingIds];
+				if (toInsert.length > 0) {
+					const insertResult = await targetTable.insertMany(toInsert, {
+						maxDepth,
+						_depth: depth + 1
+					});
+					allIds.push(...insertResult.insertedIds);
+				}
+				if (allIds.length > 0) {
+					const junctionRows = allIds.map((targetId) => ({
+						[fkToThis.fields[0]]: parentPK,
+						[fkToTarget.fields[0]]: targetId
+					}));
+					await junctionTable.insertMany(junctionRows, { maxDepth: 0 });
+				}
+			}
+		}
+	}
+}
+/**
+* Extracts patch operations from a nav field value.
+* Plain array → $replace. Object with $insert, $remove, etc. → individual ops.
+*/ function extractNavPatchOps(navValue) {
+	if (Array.isArray(navValue)) return { replace: navValue };
+	if (typeof navValue !== "object" || navValue === null) return {};
+	const obj = navValue;
+	return {
+		replace: obj.$replace !== undefined ? obj.$replace : undefined,
+		insert: obj.$insert !== undefined ? obj.$insert : undefined,
+		remove: obj.$remove !== undefined ? obj.$remove : undefined,
+		update: obj.$update !== undefined ? obj.$update : undefined,
+		upsert: obj.$upsert !== undefined ? obj.$upsert : undefined
+	};
+}
+/**
+* FROM $replace helper: delete orphans, replace existing, insert new.
+*/ async function fromReplace(targetTable, children, parentPK, fkField, childPKs, navField, maxDepth, depth) {
+	const toReplace = [];
+	const toInsert = [];
+	const newPKSet = new Set();
+	for (const child of children) {
+		const childData = { ...child };
+		childData[fkField] = parentPK;
+		const hasPK = childPKs.length > 0 && childPKs.every((pk) => childData[pk] !== undefined);
+		if (hasPK) {
+			newPKSet.add(childPKs.map((pk) => String(childData[pk])).join("\0"));
+			toReplace.push(childData);
+		} else toInsert.push(childData);
+	}
+	const existing = await targetTable.findMany({
+		filter: { [fkField]: parentPK },
+		controls: childPKs.length > 0 ? { $select: [...childPKs] } : {}
+	});
+	const orphanFilters = [];
+	for (const row of existing) {
+		const pkKey = childPKs.map((pk) => String(row[pk])).join("\0");
+		if (!newPKSet.has(pkKey)) {
+			const f = {};
+			for (const pk of childPKs) f[pk] = row[pk];
+			orphanFilters.push(f);
+		}
+	}
+	if (orphanFilters.length === 1) await targetTable.deleteMany(orphanFilters[0]);
+else if (orphanFilters.length > 1) await targetTable.deleteMany({ $or: orphanFilters });
+	if (toReplace.length > 0) await wrapNestedError(navField, () => targetTable.bulkReplace(toReplace, {
+		maxDepth,
+		_depth: depth + 1
+	}));
+	if (toInsert.length > 0) await wrapNestedError(navField, () => targetTable.insertMany(toInsert, {
+		maxDepth,
+		_depth: depth + 1
+	}));
+}
+/**
+* VIA $replace helper: clear junctions, replace/insert targets, rebuild junctions.
+*/ async function viaReplace(targetTable, junctionTable, targets, parentPK, targetPKField, fkToThisField, fkToTargetField, maxDepth, depth) {
+	await junctionTable.deleteMany({ [fkToThisField]: parentPK });
+	const toReplace = [];
+	const toInsert = [];
+	const existingIds = [];
+	for (const t of targets) {
+		const rec = t;
+		const pk = rec[targetPKField];
+		if (pk !== undefined && pk !== null) {
+			const keys = Object.keys(rec).filter((k) => k !== targetPKField);
+			if (keys.length > 0) toReplace.push({ ...rec });
+			existingIds.push(pk);
+		} else toInsert.push({ ...rec });
+	}
+	if (toReplace.length > 0) await targetTable.bulkReplace(toReplace, {
+		maxDepth,
+		_depth: depth + 1
+	});
+	const allTargetIds = [...existingIds];
+	if (toInsert.length > 0) {
+		const insertResult = await targetTable.insertMany(toInsert, {
+			maxDepth,
+			_depth: depth + 1
+		});
+		allTargetIds.push(...insertResult.insertedIds);
+	}
+	if (allTargetIds.length > 0) {
+		const junctionRows = allTargetIds.map((targetId) => ({
+			[fkToThisField]: parentPK,
+			[fkToTargetField]: targetId
+		}));
+		await junctionTable.insertMany(junctionRows, { maxDepth: 0 });
+	}
+}
+
+//#endregion
+export { DbError, batchInsertNestedFrom, batchInsertNestedTo, batchInsertNestedVia, batchPatchNestedFrom, batchPatchNestedTo, batchPatchNestedVia, batchReplaceNestedFrom, batchReplaceNestedTo, batchReplaceNestedVia, checkDepthOverflow, enrichFkViolation, preValidateNestedFrom, remapDeleteFkViolation, validateBatch };