orchid-orm 1.67.1 → 1.68.0

package/dist/index.js

@@ -1,2395 +1,1489 @@
-'use strict';
-
-var internal = require('pqb/internal');
-var pqb = require('pqb');
-var node_async_hooks = require('node:async_hooks');
-
-function createBaseTable({
-  schemaConfig = internal.defaultSchemaConfig,
-  columnTypes: columnTypesArg,
-  snakeCase,
-  filePath: filePathArg,
-  nowSQL,
-  exportAs = "BaseTable",
-  language,
-  autoForeignKeys
-} = {}) {
-  var _a;
-  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(internal.makeColumnTypes(schemaConfig)) : columnTypesArg || internal.makeColumnTypes(schemaConfig);
-  const filePathOrStack = filePathArg || internal.getStackTrace();
-  let filePath;
-  const defaultColumns = {
-    shape: internal.emptyObject,
-    data: internal.emptyArray
-  };
-  const instances = /* @__PURE__ */ new WeakMap();
-  const base = (_a = class {
-    constructor() {
-      this.columns = defaultColumns;
-      this.snakeCase = snakeCase;
-      this.types = columnTypes;
-      this.q = {};
-      this.language = language;
-    }
-    static inputSchema() {
-      this.instance();
-      return this._inputSchema === void 0 ? this._inputSchema = schemaConfig.inputSchema.call(this) : this._inputSchema;
-    }
-    static outputSchema() {
-      this.instance();
-      return this._outputSchema === void 0 ? this._outputSchema = schemaConfig.outputSchema.call(this) : this._outputSchema;
-    }
-    static querySchema() {
-      this.instance();
-      return this._querySchema === void 0 ? this._querySchema = schemaConfig.querySchema.call(this) : this._querySchema;
-    }
-    static createSchema() {
-      this.instance();
-      return this._createSchema === void 0 ? this._createSchema = schemaConfig.createSchema.call(this) : this._createSchema;
-    }
-    static updateSchema() {
-      this.instance();
-      return this._updateSchema === void 0 ? this._updateSchema = schemaConfig.updateSchema.call(this) : this._updateSchema;
-    }
-    static pkeySchema() {
-      this.instance();
-      return this._pkeySchema === void 0 ? this._pkeySchema = schemaConfig.pkeySchema.call(this) : this._pkeySchema;
-    }
-    static getFilePath() {
-      if (filePath) return filePath;
-      if (typeof filePathOrStack === "string") {
-        return filePath = filePathOrStack;
-      }
-      filePath = internal.getCallerFilePath(filePathOrStack);
-      if (filePath) return filePath;
-      throw new Error(
-        `Failed to determine file path of a base table. Please set the \`filePath\` option of \`createBaseTable\` manually.`
-      );
-    }
-    static instance() {
-      let instance = instances.get(this);
-      if (!instance) {
-        instance = new this();
-        instances.set(this, instance);
-      }
-      return instance;
-    }
-    clone() {
-      return this;
-    }
-    getFilePath() {
-      if (this.filePath) return this.filePath;
-      if (typeof filePathOrStack === "string")
-        return this.filePath = filePathOrStack;
-      const filePath2 = internal.getCallerFilePath(filePathOrStack);
-      if (filePath2) return this.filePath = filePath2;
-      throw new Error(
-        `Failed to determine file path for table ${this.constructor.name}. Please set \`filePath\` property manually`
-      );
-    }
-    setColumns(fn, dataFn) {
-      columnTypes[internal.snakeCaseKey] = this.snakeCase;
-      const shape = internal.getColumnTypes(columnTypes, fn, nowSQL, this.language);
-      const tableData = internal.parseTableData(dataFn);
-      if (this.snakeCase) {
-        for (const key in shape) {
-          const column = shape[key];
-          if (column.data.name) continue;
-          const snakeName = internal.toSnakeCase(key);
-          if (snakeName !== key) {
-            column.data.name = snakeName;
-          }
-        }
-      }
-      return this.constructor.prototype.columns = {
-        shape,
-        data: tableData
-      };
-    }
-    setComputed(computed) {
-      return computed;
-    }
-    setScopes(scopes) {
-      return scopes;
-    }
-    belongsTo(fn, options) {
-      return {
-        type: "belongsTo",
-        fn,
-        options
-      };
-    }
-    hasOne(fn, options) {
-      return {
-        type: "hasOne",
-        fn,
-        options
-      };
-    }
-    hasMany(fn, options) {
-      return {
-        type: "hasMany",
-        fn,
-        options
-      };
-    }
-    hasAndBelongsToMany(fn, options) {
-      return {
-        type: "hasAndBelongsToMany",
-        fn,
-        options
-      };
-    }
-  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a.columnTypes = columnTypes, _a.sql = internal._createDbSqlMethod(columnTypes), _a);
-  internal.applyMixins(base, [internal.QueryHooks]);
-  base.prototype.types = columnTypes;
-  base.prototype.snakeCase = snakeCase;
-  base.prototype.language = language;
-  base.prototype.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
-  return base;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let pqb_internal = require("pqb/internal");
+let pqb = require("pqb");
+let node_async_hooks = require("node:async_hooks");
+function createBaseTable({ schemaConfig = pqb_internal.defaultSchemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs = "BaseTable", language, autoForeignKeys } = {}) {
+	const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg((0, pqb_internal.makeColumnTypes)(schemaConfig)) : columnTypesArg || (0, pqb_internal.makeColumnTypes)(schemaConfig);
+	const filePathOrStack = filePathArg || (0, pqb_internal.getStackTrace)();
+	let filePath;
+	const defaultColumns = {
+		shape: pqb_internal.emptyObject,
+		data: pqb_internal.emptyArray
+	};
+	const instances = /* @__PURE__ */ new WeakMap();
+	const base = class BaseTable {
+		constructor() {
+			this.columns = defaultColumns;
+			this.snakeCase = snakeCase;
+			this.types = columnTypes;
+			this.q = {};
+			this.language = language;
+		}
+		static {
+			this.nowSQL = nowSQL;
+		}
+		static {
+			this.exportAs = exportAs;
+		}
+		static {
+			this.columnTypes = columnTypes;
+		}
+		static {
+			this.sql = (0, pqb_internal._createDbSqlMethod)(columnTypes);
+		}
+		static inputSchema() {
+			this.instance();
+			return this._inputSchema === void 0 ? this._inputSchema = schemaConfig.inputSchema.call(this) : this._inputSchema;
+		}
+		static outputSchema() {
+			this.instance();
+			return this._outputSchema === void 0 ? this._outputSchema = schemaConfig.outputSchema.call(this) : this._outputSchema;
+		}
+		static querySchema() {
+			this.instance();
+			return this._querySchema === void 0 ? this._querySchema = schemaConfig.querySchema.call(this) : this._querySchema;
+		}
+		static createSchema() {
+			this.instance();
+			return this._createSchema === void 0 ? this._createSchema = schemaConfig.createSchema.call(this) : this._createSchema;
+		}
+		static updateSchema() {
+			this.instance();
+			return this._updateSchema === void 0 ? this._updateSchema = schemaConfig.updateSchema.call(this) : this._updateSchema;
+		}
+		static pkeySchema() {
+			this.instance();
+			return this._pkeySchema === void 0 ? this._pkeySchema = schemaConfig.pkeySchema.call(this) : this._pkeySchema;
+		}
+		static getFilePath() {
+			if (filePath) return filePath;
+			if (typeof filePathOrStack === "string") return filePath = filePathOrStack;
+			filePath = (0, pqb_internal.getCallerFilePath)(filePathOrStack);
+			if (filePath) return filePath;
+			throw new Error(`Failed to determine file path of a base table. Please set the \`filePath\` option of \`createBaseTable\` manually.`);
+		}
+		static instance() {
+			let instance = instances.get(this);
+			if (!instance) {
+				instance = new this();
+				instances.set(this, instance);
+			}
+			return instance;
+		}
+		clone() {
+			return this;
+		}
+		getFilePath() {
+			if (this.filePath) return this.filePath;
+			if (typeof filePathOrStack === "string") return this.filePath = filePathOrStack;
+			const filePath = (0, pqb_internal.getCallerFilePath)(filePathOrStack);
+			if (filePath) return this.filePath = filePath;
+			throw new Error(`Failed to determine file path for table ${this.constructor.name}. Please set \`filePath\` property manually`);
+		}
+		setColumns(fn, dataFn) {
+			columnTypes[pqb_internal.snakeCaseKey] = this.snakeCase;
+			const shape = (0, pqb_internal.getColumnTypes)(columnTypes, fn, nowSQL, this.language);
+			const tableData = (0, pqb_internal.parseTableData)(dataFn);
+			if (this.snakeCase) for (const key in shape) {
+				const column = shape[key];
+				if (column.data.name) continue;
+				const snakeName = (0, pqb_internal.toSnakeCase)(key);
+				if (snakeName !== key) column.data.name = snakeName;
+			}
+			return this.constructor.prototype.columns = {
+				shape,
+				data: tableData
+			};
+		}
+		setComputed(computed) {
+			return computed;
+		}
+		setScopes(scopes) {
+			return scopes;
+		}
+		belongsTo(fn, options) {
+			return {
+				type: "belongsTo",
+				fn,
+				options
+			};
+		}
+		hasOne(fn, options) {
+			return {
+				type: "hasOne",
+				fn,
+				options
+			};
+		}
+		hasMany(fn, options) {
+			return {
+				type: "hasMany",
+				fn,
+				options
+			};
+		}
+		hasAndBelongsToMany(fn, options) {
+			return {
+				type: "hasAndBelongsToMany",
+				fn,
+				options
+			};
+		}
+	};
+	(0, pqb_internal.applyMixins)(base, [pqb_internal.QueryHooks]);
+	base.prototype.types = columnTypes;
+	base.prototype.snakeCase = snakeCase;
+	base.prototype.language = language;
+	base.prototype.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
+	return base;
 }
-
 const getThroughRelation = (table, through) => {
-  return table.relations[through];
+	return table.relations[through];
 };
 const getSourceRelation = (throughRelation, source) => {
-  return throughRelation.query.relations[source];
+	return throughRelation.query.relations[source];
 };
 const hasRelationHandleCreate = (q, ctx, items, rowIndexes, key, primaryKeys, nestedInsert) => {
-  q.q.wrapInTransaction = true;
-  items.forEach((item, i) => {
-    const value = item[key];
-    if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0))
-      return;
-    const store = ctx;
-    if (!store.hasRelation) store.hasRelation = {};
-    const values = [rowIndexes[i], value];
-    if (store.hasRelation[key]) {
-      store.hasRelation[key].push(values);
-      return;
-    }
-    const relationData = [values];
-    store.hasRelation[key] = relationData;
-    internal._queryHookAfterCreate(
-      q,
-      primaryKeys,
-      (rows, q2) => nestedInsert(
-        q2,
-        relationData.map(([rowIndex, data]) => [
-          rows[rowIndex],
-          data
-        ])
-      )
-    );
-  });
+	q.q.wrapInTransaction = true;
+	items.forEach((item, i) => {
+		const value = item[key];
+		if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0)) return;
+		const store = ctx;
+		if (!store.hasRelation) store.hasRelation = {};
+		const values = [rowIndexes[i], value];
+		if (store.hasRelation[key]) {
+			store.hasRelation[key].push(values);
+			return;
+		}
+		const relationData = [values];
+		store.hasRelation[key] = relationData;
+		(0, pqb_internal._queryHookAfterCreate)(q, primaryKeys, (rows, q) => nestedInsert(q, relationData.map(([rowIndex, data]) => [rows[rowIndex], data])));
+	});
 };
 const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
-  const value = set[key];
-  if (!value.set && !("upsert" in value) && (!value.add || Array.isArray(value.add) && value.add.length === 0) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
-    return;
-  q.q.wrapInTransaction = true;
-  internal._queryHookAfterUpdate(q, primaryKeys, (rows, q2) => {
-    return nestedUpdate(
-      q2,
-      rows,
-      value
-    );
-  });
+	const value = set[key];
+	if (!value.set && !("upsert" in value) && (!value.add || Array.isArray(value.add) && value.add.length === 0) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0)) return;
+	q.q.wrapInTransaction = true;
+	(0, pqb_internal._queryHookAfterUpdate)(q, primaryKeys, (rows, q) => {
+		return nestedUpdate(q, rows, value);
+	});
 };
 function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelation) {
-  return q.whereExists(
-    throughRelation.joinQuery(
-      throughRelation.query,
-      baseQuery
-    ),
-    () => {
-      const as = internal.getQueryAs(joiningQuery);
-      return sourceRelation.joinQuery(
-        sourceRelation.query.as(as),
-        throughRelation.query
-      );
-    }
-  );
+	return q.whereExists(throughRelation.joinQuery(throughRelation.query, baseQuery), (() => {
+		const as = (0, pqb_internal.getQueryAs)(joiningQuery);
+		return sourceRelation.joinQuery(sourceRelation.query.as(as), throughRelation.query);
+	}));
 }
 function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len) {
-  const baseAs = internal.getQueryAs(baseQuery);
-  const q = joiningQuery.clone();
-  internal.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
-  for (let i = 0; i < len; i++) {
-    internal.pushQueryOnForOuter(
-      q,
-      baseQuery,
-      joiningQuery,
-      foreignKeys[i],
-      `${baseAs}.${primaryKeys[i]}`
-    );
-  }
-  return q;
+	const baseAs = (0, pqb_internal.getQueryAs)(baseQuery);
+	const q = joiningQuery.clone();
+	(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.shape);
+	for (let i = 0; i < len; i++) (0, pqb_internal.pushQueryOnForOuter)(q, baseQuery, joiningQuery, foreignKeys[i], `${baseAs}.${primaryKeys[i]}`);
+	return q;
 }
 const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, options, originalForeignKeys) => {
-  var _a;
-  const toTable = to.table;
-  let fkeyOptions = options.foreignKey !== void 0 ? options.foreignKey : tableConfig.autoForeignKeys;
-  if (!fkeyOptions) return;
-  if (fkeyOptions === true) {
-    fkeyOptions = tableConfig.autoForeignKeys || internal.emptyObject;
-  }
-  if (foreignKeys.length === 1) {
-    const column = from.shape[foreignKeys[0]];
-    if (column.data.foreignKeys) {
-      const pkey = primaryKeys[0];
-      for (const fkey of column.data.foreignKeys) {
-        let fkeyTable;
-        let fkeyColumn = fkey.foreignColumns[0];
-        if (typeof fkey.fnOrTable === "string") {
-          fkeyTable = fkey.fnOrTable;
-          fkeyColumn = getColumnKeyFromDbName(to, fkeyColumn);
-        } else {
-          fkeyTable = fkey.fnOrTable().instance().table;
-        }
-        if (toTable === fkeyTable && pkey === fkeyColumn) return;
-      }
-    }
-  }
-  const { constraints } = from.internal.tableData;
-  if (constraints) {
-    const sortedPkeys = [...primaryKeys].sort();
-    const sortedFkeys = [...foreignKeys].sort();
-    for (const { references: refs } of constraints) {
-      if (!refs) continue;
-      if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && (typeof refs.fnOrTable === "string" ? refs.fnOrTable === toTable && refs.foreignColumns.every(
-        (column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]
-      ) : refs.fnOrTable().instance().table === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i])))
-        return;
-    }
-  }
-  ((_a = from.internal.tableData).constraints ?? (_a.constraints = [])).push({
-    references: {
-      columns: originalForeignKeys || foreignKeys,
-      fnOrTable: toTable,
-      foreignColumns: primaryKeys,
-      options: fkeyOptions
-    },
-    dropMode: fkeyOptions.dropMode
-  });
+	const toTable = to.table;
+	let fkeyOptions = options.foreignKey !== void 0 ? options.foreignKey : tableConfig.autoForeignKeys;
+	if (!fkeyOptions) return;
+	if (fkeyOptions === true) fkeyOptions = tableConfig.autoForeignKeys || pqb_internal.emptyObject;
+	if (foreignKeys.length === 1) {
+		const column = from.shape[foreignKeys[0]];
+		if (column.data.foreignKeys) {
+			const pkey = primaryKeys[0];
+			for (const fkey of column.data.foreignKeys) {
+				let fkeyTable;
+				let fkeyColumn = fkey.foreignColumns[0];
+				if (typeof fkey.fnOrTable === "string") {
+					fkeyTable = fkey.fnOrTable;
+					fkeyColumn = getColumnKeyFromDbName(to, fkeyColumn);
+				} else fkeyTable = fkey.fnOrTable().instance().table;
+				if (toTable === fkeyTable && pkey === fkeyColumn) return;
+			}
+		}
+	}
+	const { constraints } = from.internal.tableData;
+	if (constraints) {
+		const sortedPkeys = [...primaryKeys].sort();
+		const sortedFkeys = [...foreignKeys].sort();
+		for (const { references: refs } of constraints) {
+			if (!refs) continue;
+			if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && (typeof refs.fnOrTable === "string" ? refs.fnOrTable === toTable && refs.foreignColumns.every((column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]) : refs.fnOrTable().instance().table === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i]))) return;
+		}
+	}
+	(from.internal.tableData.constraints ??= []).push({
+		references: {
+			columns: originalForeignKeys || foreignKeys,
+			fnOrTable: toTable,
+			foreignColumns: primaryKeys,
+			options: fkeyOptions
+		},
+		dropMode: fkeyOptions.dropMode
+	});
 };
 const getColumnKeyFromDbName = (query, name) => {
-  for (const k in query.shape) {
-    if (query.shape[k].data.name === name) {
-      return k;
-    }
-  }
-  return name;
+	for (const k in query.shape) if (query.shape[k].data.name === name) return k;
+	return name;
 };
 const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
 const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
 const selectCteColumnFromManySql = (cteAs, column, rowIndex, count) => {
-  let sql = `(SELECT "${cteAs}"."${column}" FROM "${cteAs}"`;
-  if (count > 1) {
-    sql += ` LIMIT 1`;
-    if (rowIndex) sql += ` OFFSET ${rowIndex}`;
-  }
-  return sql + ")";
+	let sql = `(SELECT "${cteAs}"."${column}" FROM "${cteAs}"`;
+	if (count > 1) {
+		sql += ` LIMIT 1`;
+		if (rowIndex) sql += ` OFFSET ${rowIndex}`;
+	}
+	return sql + ")";
 };
-
 const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, baseQuery) => {
-  const jq = joiningQuery;
-  const chain = jq.q.relChain;
-  if (!chain || chain.length === 1) {
-    return joinQuery(jq, baseQuery);
-  }
-  const last = chain[chain.length - 1];
-  const prev = chain[chain.length - 2];
-  const query = prev.rel.joinQuery(last.query, baseQuery);
-  let useWhereExist = true;
-  if (jq.q.returnType !== "value" && jq.q.returnType !== "valueOrThrow") {
-    let tablePrefix;
-    if (jq.q.order) {
-      const prefix = tablePrefix = internal.getQueryAs(jq) + ".";
-      useWhereExist = jq.q.order.every((o) => {
-        if (typeof o === "string") {
-          return isOwnColumn(prefix, o);
-        } else if (internal.isExpression(o)) {
-          return false;
-        } else {
-          for (const key in o) {
-            if (!isOwnColumn(prefix, key)) {
-              return false;
-            }
-          }
-          return true;
-        }
-      });
-    }
-    if (useWhereExist && jq.q.select) {
-      const prefix = tablePrefix || internal.getQueryAs(jq) + ".";
-      useWhereExist = jq.q.select.every((s) => {
-        if (typeof s === "string") {
-          return isOwnColumn(prefix, s);
-        } else if (internal.isExpression(s)) {
-          return false;
-        } else if (!s) {
-          return false;
-        } else {
-          for (const key in s.selectAs) {
-            const value = s.selectAs[key];
-            if (typeof value !== "string" || !isOwnColumn(prefix, value)) {
-              return false;
-            }
-          }
-          return true;
-        }
-      });
-    }
-  }
-  if (useWhereExist) {
-    return jq.where({
-      EXISTS: { q: reverseJoin(query, jq) }
-    });
-  }
-  const result = jq.join(
-    { _internalJoin: reverseJoin(query, jq) },
-    void 0
-  );
-  if (!query.q.chainMultiple) {
-    return result;
-  }
-  const item = selectRowNumber(result, relPKeys);
-  combineOrdering(result, query);
-  if (!result.q.select) result.q.select = ["*"];
-  return wrapQuery(jq, result, item);
+	const jq = joiningQuery;
+	const chain = jq.q.relChain;
+	if (!chain || chain.length === 1) return joinQuery(jq, baseQuery);
+	const last = chain[chain.length - 1];
+	const query = chain[chain.length - 2].rel.joinQuery(last.query, baseQuery);
+	let useWhereExist = true;
+	if (jq.q.returnType !== "value" && jq.q.returnType !== "valueOrThrow") {
+		let tablePrefix;
+		if (jq.q.order) {
+			const prefix = tablePrefix = (0, pqb_internal.getQueryAs)(jq) + ".";
+			useWhereExist = jq.q.order.every((o) => {
+				if (typeof o === "string") return isOwnColumn(prefix, o);
+				else if ((0, pqb_internal.isExpression)(o)) return false;
+				else {
+					for (const key in o) if (!isOwnColumn(prefix, key)) return false;
+					return true;
+				}
+			});
+		}
+		if (useWhereExist && jq.q.select) {
+			const prefix = tablePrefix || (0, pqb_internal.getQueryAs)(jq) + ".";
+			useWhereExist = jq.q.select.every((s) => {
+				if (typeof s === "string") return isOwnColumn(prefix, s);
+				else if ((0, pqb_internal.isExpression)(s)) return false;
+				else if (!s) return false;
+				else {
+					for (const key in s.selectAs) {
+						const value = s.selectAs[key];
+						if (typeof value !== "string" || !isOwnColumn(prefix, value)) return false;
+					}
+					return true;
+				}
+			});
+		}
+	}
+	if (useWhereExist) return jq.where({ EXISTS: { q: reverseJoin(query, jq) } });
+	const result = jq.join({ _internalJoin: reverseJoin(query, jq) }, void 0);
+	if (!query.q.chainMultiple) return result;
+	const item = selectRowNumber(result, relPKeys);
+	combineOrdering(result, query);
+	if (!result.q.select) result.q.select = ["*"];
+	return wrapQuery(jq, result, item);
 };
 const isOwnColumn = (prefix, column) => !column.includes(".") || column.startsWith(prefix);
 const selectRowNumber = (result, relPKeys) => {
-  const hookSelect = result.q.hookSelect = new Map(
-    result.q.hookSelect && [...result.q.hookSelect]
-  );
-  const as = `"${internal.getQueryAs(result)}"`;
-  const partitionColumns = relPKeys.map(
-    (key) => `${as}."${result.shape[key]?.data.name || key}"`
-  );
-  const item = {
-    select: {
-      sql: `row_number() OVER (PARTITION BY ${partitionColumns.join(", ")})`
-    }
-  };
-  hookSelect.set("r", item);
-  return item;
+	const hookSelect = result.q.hookSelect = new Map(result.q.hookSelect && [...result.q.hookSelect]);
+	const as = `"${(0, pqb_internal.getQueryAs)(result)}"`;
+	const item = { select: { sql: `row_number() OVER (PARTITION BY ${relPKeys.map((key) => `${as}."${result.shape[key]?.data.name || key}"`).join(", ")})` } };
+	hookSelect.set("r", item);
+	return item;
 };
 const combineOrdering = (result, joined) => {
-  const { order } = joined.q;
-  if (order) {
-    const as = internal.getQueryAs(joined);
-    const add = order.map(
-      (o) => typeof o === "string" ? `${as}.${o}` : internal.isExpression(o) ? o : Object.fromEntries(
-        Object.entries(o).map(([key, value]) => [`${as}.${key}`, value])
-      )
-    );
-    const arr = result.q.order;
-    result.q.order = arr ? [...add, ...arr] : add;
-  }
+	const { order } = joined.q;
+	if (order) {
+		const as = (0, pqb_internal.getQueryAs)(joined);
+		const add = order.map((o) => typeof o === "string" ? `${as}.${o}` : (0, pqb_internal.isExpression)(o) ? o : Object.fromEntries(Object.entries(o).map(([key, value]) => [`${as}.${key}`, value])));
+		const arr = result.q.order;
+		result.q.order = arr ? [...add, ...arr] : add;
+	}
 };
 const wrapQuery = (joiningQuery, result, item) => {
-  const baseOuterQuery = internal.cloneQueryBaseUnscoped(joiningQuery);
-  const outer = baseOuterQuery.clone();
-  outer.q.and = [new internal.DynamicRawSQL(() => new internal.RawSql(`${item.as || "r"} = 1`))];
-  outer.q.useFromLimitOffset = true;
-  outer.shape = internal.getShapeFromSelect(result, true);
-  outer.q.select = Object.keys(outer.shape);
-  outer.q.returnType = result.q.returnType;
-  result.q.returnsOne = true;
-  return result.wrap(outer);
+	const outer = (0, pqb_internal.cloneQueryBaseUnscoped)(joiningQuery).clone();
+	outer.q.and = [new pqb_internal.DynamicRawSQL(() => new pqb_internal.RawSql(`${item.as || "r"} = 1`))];
+	outer.q.useFromLimitOffset = true;
+	outer.shape = (0, pqb_internal.getShapeFromSelect)(result, true);
+	outer.q.select = Object.keys(outer.shape);
+	outer.q.returnType = result.q.returnType;
+	result.q.returnsOne = true;
+	return result.wrap(outer);
+};
+var BelongsToVirtualColumn = class extends pqb_internal.VirtualColumn {
+	constructor(schema, key, state) {
+		super(schema);
+		this.key = key;
+		this.state = state;
+		this.nestedUpdate = nestedUpdate$2(this.state);
+	}
+	create(q, ctx, items) {
+		const { key, state: { query, primaryKeys, foreignKeys } } = this;
+		let nestedCreateItems;
+		items.forEach((item) => {
+			const value = item[key];
+			const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+			if (kind) {
+				const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+					items: [],
+					values: []
+				};
+				nestedCreateItem.items.push(item);
+				nestedCreateItem.values.push(value[kind]);
+				if (kind !== "connect") for (const key of foreignKeys) item[key] = new pqb_internal.RawSql("");
+			}
+		});
+		if (!nestedCreateItems) return;
+		for (const key of foreignKeys) if (!ctx.columns.has(key)) ctx.columns.set(key, ctx.columns.size);
+		const { create, connect, connectOrCreate } = nestedCreateItems;
+		if (create) (0, pqb_internal._prependWith)(q, (as) => {
+			const count = create.items.length;
+			foreignKeys.forEach((foreignKey, i) => {
+				const primaryKey = primaryKeys[i];
+				create.items.forEach((item, i) => {
+					item[foreignKey]._sql = selectCteColumnFromManySql(as, primaryKey, i, count);
+				});
+			});
+		}, (0, pqb_internal._queryInsertMany)(query.select(...primaryKeys), create.values));
+		if (connect) connect.values.forEach((value, itemI) => {
+			const as = (0, pqb_internal.getFreeAlias)(q.q.withShapes, "q");
+			(0, pqb_internal._prependWith)(q, as, query.select(...primaryKeys).findBy(value));
+			foreignKeys.map((foreignKey, i) => {
+				connect.items[itemI][foreignKey] = new pqb_internal.RawSql(selectCteColumnMustExistSql(i, as, primaryKeys[i]));
+			});
+		});
+		if (connectOrCreate) connectOrCreate.values.forEach((value, itemI) => {
+			(0, pqb_internal._prependWith)(q, setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys), (0, pqb_internal._orCreate)((0, pqb_internal._queryWhere)(query.select(...primaryKeys), [value.where]), value.create));
+		});
+	}
+	update(q, set) {
+		q.q.wrapInTransaction = true;
+		const data = set[this.key];
+		this.nestedUpdate(q, set, data);
+	}
 };
-
-class BelongsToVirtualColumn extends internal.VirtualColumn {
-  constructor(schema, key, state) {
-    super(schema);
-    this.key = key;
-    this.state = state;
-    this.nestedUpdate = nestedUpdate$2(this.state);
-  }
-  create(q, ctx, items) {
-    const {
-      key,
-      state: { query, primaryKeys, foreignKeys }
-    } = this;
-    let nestedCreateItems;
-    items.forEach((item) => {
-      var _a;
-      const value = item[key];
-      const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
-      {
-        const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_a[kind] = {
-          items: [],
-          values: []
-        });
-        nestedCreateItem.items.push(item);
-        nestedCreateItem.values.push(value[kind]);
-        if (kind !== "connect") {
-          for (const key2 of foreignKeys) {
-            item[key2] = new internal.RawSql("");
-          }
-        }
-      }
-    });
-    if (!nestedCreateItems) {
-      return;
-    }
-    for (const key2 of foreignKeys) {
-      if (!ctx.columns.has(key2)) {
-        ctx.columns.set(key2, ctx.columns.size);
-      }
-    }
-    const { create, connect, connectOrCreate } = nestedCreateItems;
-    if (create) {
-      const selectPKeys = query.select(...primaryKeys);
-      internal._prependWith(
-        q,
-        (as) => {
-          const count = create.items.length;
-          foreignKeys.forEach((foreignKey, i) => {
-            const primaryKey = primaryKeys[i];
-            create.items.forEach((item, i2) => {
-              item[foreignKey]._sql = selectCteColumnFromManySql(
-                as,
-                primaryKey,
-                i2,
-                count
-              );
-            });
-          });
-        },
-        internal._queryInsertMany(selectPKeys, create.values)
-      );
-    }
-    if (connect) {
-      connect.values.forEach((value, itemI) => {
-        const as = internal.getFreeAlias(q.q.withShapes, "q");
-        internal._prependWith(q, as, query.select(...primaryKeys).findBy(value));
-        foreignKeys.map((foreignKey, i) => {
-          connect.items[itemI][foreignKey] = new internal.RawSql(
-            selectCteColumnMustExistSql(i, as, primaryKeys[i])
-          );
-        });
-      });
-    }
-    if (connectOrCreate) {
-      connectOrCreate.values.forEach((value, itemI) => {
-        const asFn = setForeignKeysFromCte(
-          connectOrCreate.items[itemI],
-          primaryKeys,
-          foreignKeys
-        );
-        const selectPKeys = query.select(...primaryKeys);
-        internal._prependWith(
-          q,
-          asFn,
-          internal._orCreate(
-            internal._queryWhere(selectPKeys, [value.where]),
-            value.create
-          )
-        );
-      });
-    }
-  }
-  update(q, set) {
-    q.q.wrapInTransaction = true;
-    const data = set[this.key];
-    this.nestedUpdate(q, set, data);
-  }
-}
 const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
-  const primaryKeys = relation.options.references;
-  const foreignKeys = relation.options.columns;
-  const { on } = relation.options;
-  if (on) {
-    internal._queryWhere(query, [on]);
-    internal._queryDefaults(query, on);
-  }
-  const len = primaryKeys.length;
-  const state = { query, primaryKeys, foreignKeys, len, on };
-  addAutoForeignKey(
-    tableConfig,
-    table,
-    query,
-    primaryKeys,
-    foreignKeys,
-    relation.options
-  );
-  const join = (baseQuery, joiningQuery, primaryKeys2, foreignKeys2) => {
-    const baseAs = internal.getQueryAs(baseQuery);
-    const q = joiningQuery.clone();
-    internal.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
-    for (let i = 0; i < len; i++) {
-      internal.pushQueryOnForOuter(
-        q,
-        baseQuery,
-        joiningQuery,
-        primaryKeys2[i],
-        `${baseAs}.${foreignKeys2[i]}`
-      );
-    }
-    return q;
-  };
-  const reverseJoin = (baseQuery, joiningQuery) => {
-    return join(
-      joiningQuery,
-      baseQuery,
-      foreignKeys,
-      primaryKeys
-    );
-  };
-  return {
-    returns: "one",
-    queryRelated(params) {
-      const obj = {};
-      for (let i = 0; i < len; i++) {
-        obj[primaryKeys[i]] = params[foreignKeys[i]];
-      }
-      return query.where(obj);
-    },
-    virtualColumn: new BelongsToVirtualColumn(
-      internal.defaultSchemaConfig,
-      relationName,
-      state
-    ),
-    joinQuery: joinQueryChainHOF(
-      internal.getPrimaryKeys(query),
-      reverseJoin,
-      (joiningQuery, baseQuery) => join(
-        baseQuery,
-        joiningQuery,
-        primaryKeys,
-        foreignKeys
-      )
-    ),
-    reverseJoin
-  };
+	const primaryKeys = relation.options.references;
+	const foreignKeys = relation.options.columns;
+	const { on } = relation.options;
+	if (on) {
+		(0, pqb_internal._queryWhere)(query, [on]);
+		(0, pqb_internal._queryDefaults)(query, on);
+	}
+	const len = primaryKeys.length;
+	const state = {
+		query,
+		primaryKeys,
+		foreignKeys,
+		len,
+		on
+	};
+	addAutoForeignKey(tableConfig, table, query, primaryKeys, foreignKeys, relation.options);
+	const join = (baseQuery, joiningQuery, primaryKeys, foreignKeys) => {
+		const baseAs = (0, pqb_internal.getQueryAs)(baseQuery);
+		const q = joiningQuery.clone();
+		(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.shape);
+		for (let i = 0; i < len; i++) (0, pqb_internal.pushQueryOnForOuter)(q, baseQuery, joiningQuery, primaryKeys[i], `${baseAs}.${foreignKeys[i]}`);
+		return q;
+	};
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		return join(joiningQuery, baseQuery, foreignKeys, primaryKeys);
+	};
+	return {
+		returns: "one",
+		queryRelated(params) {
+			const obj = {};
+			for (let i = 0; i < len; i++) obj[primaryKeys[i]] = params[foreignKeys[i]];
+			return query.where(obj);
+		},
+		virtualColumn: new BelongsToVirtualColumn(pqb_internal.defaultSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF((0, pqb_internal.getPrimaryKeys)(query), reverseJoin, (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)),
+		reverseJoin
+	};
 };
 const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
-  return (self, update, params) => {
-    if (params.create) {
-      const createQuery = internal._querySelect(
-        internal._queryCreate(query.clone(), params.create),
-        primaryKeys
-      );
-      const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
-      internal._prependWith(self, asFn, createQuery);
-    } else if (params.update) {
-      let appendedAs;
-      internal._hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
-        selectIdsSql._sql = selectCteColumnsSql(
-          appendedAs,
-          aliasedForeignKeys
-        );
-      });
-      const selectIdsSql = new internal.RawSql("");
-      const updateQuery = internal._queryUpdate(
-        internal._queryWhereIn(query.clone(), true, primaryKeys, selectIdsSql),
-        params.update
-      );
-      updateQuery.q.returnType = "value";
-      internal._appendQuery(self, updateQuery, (as) => appendedAs = as);
-    } else if (params.upsert) {
-      if (internal.isQueryReturnsAll(self)) {
-        throw new Error("`upsert` option is not allowed in a batch update");
-      }
-      const { relQuery } = relWithSelectIds(
-        self,
-        query,
-        primaryKeys,
-        foreignKeys
-      );
-      const upsertQuery = internal._querySelect(
-        internal._queryUpsert(
-          relQuery,
-          params.upsert
-        ),
-        primaryKeys
-      );
-      const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
-      internal._prependWith(self, asFn, upsertQuery);
-    } else if (params.delete) {
-      internal._hookSelectColumns(self, foreignKeys, internal.noop);
-      disconnect(update, foreignKeys);
-      const { selectIdsSql, relQuery } = relWithSelectIds(
-        self,
-        query,
-        primaryKeys,
-        foreignKeys
-      );
-      self.q.and = self.q.or = void 0;
-      internal._queryWhereIn(self, true, foreignKeys, selectIdsSql);
-      const deleteQuery = internal._queryDelete(relQuery);
-      deleteQuery.q.returnType = "value";
-      internal._appendQuery(self, deleteQuery, internal.noop);
-    } else if (params.disconnect) {
-      disconnect(update, foreignKeys);
-    } else if (params.set) {
-      let loadPrimaryKeys;
-      let loadForeignKeys;
-      for (let i = 0; i < len; i++) {
-        const primaryKey = primaryKeys[i];
-        if (primaryKey in params.set) {
-          update[foreignKeys[i]] = params.set[primaryKey];
-        } else {
-          (loadPrimaryKeys ?? (loadPrimaryKeys = [])).push(primaryKey);
-          (loadForeignKeys ?? (loadForeignKeys = [])).push(foreignKeys[i]);
-        }
-      }
-      if (loadPrimaryKeys) {
-        const asFn = setForeignKeysFromCte(
-          update,
-          loadPrimaryKeys,
-          loadForeignKeys,
-          true
-        );
-        internal._prependWith(
-          self,
-          asFn,
-          internal._queryFindBy(query.select(...loadPrimaryKeys), params.set)
-        );
-      }
-    }
-  };
+	return ((self, update, params) => {
+		if (params.create) {
+			const createQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryCreate)(query.clone(), params.create), primaryKeys);
+			(0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), createQuery);
+		} else if (params.update) {
+			let appendedAs;
+			(0, pqb_internal._hookSelectColumns)(self, foreignKeys, (aliasedForeignKeys) => {
+				selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedForeignKeys);
+			});
+			const selectIdsSql = new pqb_internal.RawSql("");
+			const updateQuery = (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhereIn)(query.clone(), true, primaryKeys, selectIdsSql), params.update);
+			updateQuery.q.returnType = "value";
+			(0, pqb_internal._appendQuery)(self, updateQuery, (as) => appendedAs = as);
+		} else if (params.upsert) {
+			if ((0, pqb_internal.isQueryReturnsAll)(self)) throw new Error("`upsert` option is not allowed in a batch update");
+			const { relQuery } = relWithSelectIds(self, query, primaryKeys, foreignKeys);
+			const upsertQuery = (0, pqb_internal._querySelect)((0, pqb_internal._queryUpsert)(relQuery, params.upsert), primaryKeys);
+			(0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), upsertQuery);
+		} else if (params.delete) {
+			(0, pqb_internal._hookSelectColumns)(self, foreignKeys, pqb_internal.noop);
+			disconnect(update, foreignKeys);
+			const { selectIdsSql, relQuery } = relWithSelectIds(self, query, primaryKeys, foreignKeys);
+			self.q.and = self.q.or = void 0;
+			(0, pqb_internal._queryWhereIn)(self, true, foreignKeys, selectIdsSql);
+			const deleteQuery = (0, pqb_internal._queryDelete)(relQuery);
+			deleteQuery.q.returnType = "value";
+			(0, pqb_internal._appendQuery)(self, deleteQuery, pqb_internal.noop);
+		} else if (params.disconnect) disconnect(update, foreignKeys);
+		else if (params.set) {
+			let loadPrimaryKeys;
+			let loadForeignKeys;
+			for (let i = 0; i < len; i++) {
+				const primaryKey = primaryKeys[i];
+				if (primaryKey in params.set) update[foreignKeys[i]] = params.set[primaryKey];
+				else {
+					(loadPrimaryKeys ??= []).push(primaryKey);
+					(loadForeignKeys ??= []).push(foreignKeys[i]);
+				}
+			}
+			if (loadPrimaryKeys) (0, pqb_internal._prependWith)(self, setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true), (0, pqb_internal._queryFindBy)(query.select(...loadPrimaryKeys), params.set));
+		}
+	});
 };
 const disconnect = (update, foreignKeys) => {
-  for (const foreignKey of foreignKeys) {
-    update[foreignKey] = null;
-  }
+	for (const foreignKey of foreignKeys) update[foreignKey] = null;
 };
 const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
-  const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
-  const selectIdsSql = new internal.RawSql("");
-  internal._prependWith(
-    self,
-    (as) => {
-      selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
-    },
-    selectIdsQuery
-  );
-  return {
-    selectIdsSql,
-    relQuery: internal._queryWhereIn(rel.clone(), true, primaryKeys, selectIdsSql)
-  };
+	const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
+	const selectIdsSql = new pqb_internal.RawSql("");
+	(0, pqb_internal._prependWith)(self, (as) => {
+		selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
+	}, selectIdsQuery);
+	return {
+		selectIdsSql,
+		relQuery: (0, pqb_internal._queryWhereIn)(rel.clone(), true, primaryKeys, selectIdsSql)
+	};
 };
 const makeSelectIdsQuery = (self, foreignKeys) => {
-  const selectIdsQuery = self.baseQuery.clone();
-  selectIdsQuery.q.distinct = internal.emptyArray;
-  selectIdsQuery.q.select = foreignKeys;
-  selectIdsQuery.q.and = self.q.and;
-  selectIdsQuery.q.or = self.q.or;
-  return selectIdsQuery;
+	const selectIdsQuery = self.baseQuery.clone();
+	selectIdsQuery.q.distinct = pqb_internal.emptyArray;
+	selectIdsQuery.q.select = foreignKeys;
+	selectIdsQuery.q.and = self.q.and;
+	selectIdsQuery.q.or = self.q.or;
+	return selectIdsQuery;
 };
 const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
-  for (const key of foreignKeys) {
-    record[key] = new internal.RawSql("");
-  }
-  return (as) => {
-    foreignKeys.forEach(
-      mustExist ? (foreignKey, i) => {
-        record[foreignKey]._sql = selectCteColumnMustExistSql(
-          i,
-          as,
-          primaryKeys[i]
-        );
-      } : (foreignKey, i) => {
-        record[foreignKey]._sql = selectCteColumnSql(
-          as,
-          primaryKeys[i]
-        );
-      }
-    );
-  };
+	for (const key of foreignKeys) record[key] = new pqb_internal.RawSql("");
+	return (as) => {
+		foreignKeys.forEach(mustExist ? (foreignKey, i) => {
+			record[foreignKey]._sql = selectCteColumnMustExistSql(i, as, primaryKeys[i]);
+		} : (foreignKey, i) => {
+			record[foreignKey]._sql = selectCteColumnSql(as, primaryKeys[i]);
+		});
+	};
 };
 const selectCteColumnMustExistSql = (i, cteAs, column) => {
-  const selectColumn = selectCteColumnSql(cteAs, column);
-  return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
+	const selectColumn = selectCteColumnSql(cteAs, column);
+	return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
+};
+var HasOneVirtualColumn = class extends pqb_internal.VirtualColumn {
+	constructor(schema, key, state) {
+		super(schema);
+		this.key = key;
+		this.state = state;
+		this.nestedInsert = nestedInsert$2(state);
+		this.setNulls = {};
+		for (const foreignKey of state.foreignKeys) this.setNulls[foreignKey] = null;
+	}
+	create(self, ctx, items, rowIndexes, count) {
+		if (count <= self.qb.internal.nestedCreateBatchMax) {
+			const { query: rel, primaryKeys, foreignKeys } = this.state;
+			let nestedCreateItems;
+			items.forEach((item, i) => {
+				const value = item[this.key];
+				const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+				if (kind) {
+					const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+						indexes: [],
+						items: [],
+						values: []
+					};
+					nestedCreateItem.indexes.push(rowIndexes[i]);
+					nestedCreateItem.values.push(value[kind]);
+					const data = value.create ? { ...value.create } : {};
+					for (const key of foreignKeys) data[key] = new pqb_internal.RawSql("");
+					nestedCreateItem.items.push(data);
+				}
+			});
+			if (!nestedCreateItems) return;
+			let createAs;
+			let connectAs;
+			let connectOrCreateAs;
+			(0, pqb_internal._hookSelectColumns)(self, primaryKeys, (aliasedPrimaryKeys) => {
+				foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					if (create && createAs) for (let i = 0; i < create.items.length; i++) create.items[i][key]._sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
+					if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(connectAs, primaryKey, connect.indexes[i], count);
+					if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(connectOrCreateAs, primaryKey, connectOrCreate.indexes[i], count);
+				});
+			});
+			const { create, connect, connectOrCreate } = nestedCreateItems;
+			if (create) (0, pqb_internal._appendQuery)(self, (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items), (as) => createAs = as);
+			if (connect) connect.values.forEach((value, i) => {
+				const query = (0, pqb_internal._queryUpdateOrThrow)(rel.where(value), connect.items[i]);
+				query.q.ensureCount = 1;
+				(0, pqb_internal._appendQuery)(self, query, (as) => connectAs = as);
+			});
+			if (connectOrCreate) connectOrCreate.values.forEach((value, i) => {
+				(0, pqb_internal._appendQuery)(self, (0, pqb_internal._queryUpsert)(rel.where(value.where), {
+					update: connectOrCreate.items[i],
+					create: {
+						...value.create,
+						...connectOrCreate.items[i]
+					}
+				}), (as) => connectOrCreateAs = as);
+			});
+		} else hasRelationHandleCreate(self, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+	}
+	update(self, set) {
+		const params = set[this.key];
+		if ((params.set || params.create || params.upsert) && (0, pqb_internal.isQueryReturnsAll)(self)) {
+			const key = params.set ? "set" : params.create ? "create" : "upsert";
+			throw new Error(`\`${key}\` option is not allowed in a batch update`);
+		}
+		const { primaryKeys, foreignKeys, query: relQuery } = this.state;
+		if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
+			let appendedAs;
+			(0, pqb_internal._hookSelectColumns)(self, primaryKeys, (aliasedPrimaryKeys) => {
+				selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedPrimaryKeys);
+				if (params.create || params.set || params.upsert) foreignKeys.forEach((foreignKey, i) => {
+					setIds[foreignKey]._sql = selectCteColumnSql(appendedAs, aliasedPrimaryKeys[i]);
+				});
+			});
+			const selectIdsSql = new pqb_internal.RawSql("");
+			const existingRelQuery = (0, pqb_internal._queryWhereIn)((0, pqb_internal._clone)(relQuery), true, foreignKeys, selectIdsSql);
+			let setIds = void 0;
+			if (params.create || params.set || params.upsert) {
+				setIds = {};
+				foreignKeys.forEach((foreignKey) => {
+					setIds[foreignKey] = new pqb_internal.RawSql("");
+				});
+			}
+			const nullifyOrDeleteQuery = params.update ? (0, pqb_internal._queryUpdate)(existingRelQuery, params.update) : params.upsert ? (0, pqb_internal._queryUpsert)(existingRelQuery, {
+				update: params.upsert.update,
+				create: {
+					...typeof params.upsert.create === "function" ? params.upsert.create() : params.upsert.create,
+					...setIds
+				}
+			}) : params.delete ? (0, pqb_internal._queryDelete)(existingRelQuery) : (0, pqb_internal._queryUpdate)(existingRelQuery, this.setNulls);
+			nullifyOrDeleteQuery.q.returnType = "void";
+			(0, pqb_internal._appendQuery)(self, nullifyOrDeleteQuery, (as) => appendedAs = as);
+			if (params.create) (0, pqb_internal._appendQuery)(self, (0, pqb_internal._queryInsert)((0, pqb_internal._clone)(relQuery), {
+				...params.create,
+				...setIds
+			}), pqb_internal.noop);
+			else if (params.set) {
+				const setQuery = (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhere)((0, pqb_internal._clone)(relQuery), [params.set]), setIds);
+				setQuery.q.returnType = "void";
+				(0, pqb_internal._appendQuery)(self, setQuery, pqb_internal.noop);
+			}
+		}
+	}
 };
-
-class HasOneVirtualColumn extends internal.VirtualColumn {
-  constructor(schema, key, state) {
-    super(schema);
-    this.key = key;
-    this.state = state;
-    this.nestedInsert = nestedInsert$2(state);
-    this.setNulls = {};
-    for (const foreignKey of state.foreignKeys) {
-      this.setNulls[foreignKey] = null;
-    }
-  }
-  create(self, ctx, items, rowIndexes, count) {
-    if (count <= self.qb.internal.nestedCreateBatchMax) {
-      const { query: rel, primaryKeys, foreignKeys } = this.state;
-      let nestedCreateItems;
-      items.forEach((item, i) => {
-        var _a;
-        const value = item[this.key];
-        const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
-        {
-          const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_a[kind] = {
-            indexes: [],
-            items: [],
-            values: []
-          });
-          nestedCreateItem.indexes.push(rowIndexes[i]);
-          nestedCreateItem.values.push(value[kind]);
-          const data = value.create ? { ...value.create } : {};
-          for (const key of foreignKeys) {
-            data[key] = new internal.RawSql("");
-          }
-          nestedCreateItem.items.push(data);
-        }
-      });
-      if (!nestedCreateItems) {
-        return;
-      }
-      let createAs;
-      let connectAs;
-      let connectOrCreateAs;
-      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
-        foreignKeys.forEach((key, keyI) => {
-          const primaryKey = aliasedPrimaryKeys[keyI];
-          if (create && createAs) {
-            for (let i = 0; i < create.items.length; i++) {
-              create.items[i][key]._sql = selectCteColumnFromManySql(
-                createAs,
-                primaryKey,
-                create.indexes[i],
-                count
-              );
-            }
-          }
-          if (connect && connectAs) {
-            for (let i = 0; i < connect.items.length; i++) {
-              connect.items[i][key]._sql = selectCteColumnFromManySql(
-                connectAs,
-                primaryKey,
-                connect.indexes[i],
-                count
-              );
-            }
-          }
-          if (connectOrCreate && connectOrCreateAs) {
-            for (let i = 0; i < connectOrCreate.items.length; i++) {
-              connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(
-                connectOrCreateAs,
-                primaryKey,
-                connectOrCreate.indexes[i],
-                count
-              );
-            }
-          }
-        });
-      });
-      const { create, connect, connectOrCreate } = nestedCreateItems;
-      if (create) {
-        const query = internal._queryInsertMany(internal._clone(rel), create.items);
-        internal._appendQuery(self, query, (as) => createAs = as);
-      }
-      if (connect) {
-        connect.values.forEach((value, i) => {
-          const query = internal._queryUpdateOrThrow(
-            rel.where(value),
-            connect.items[i]
-          );
-          query.q.ensureCount = 1;
-          internal._appendQuery(self, query, (as) => connectAs = as);
-        });
-      }
-      if (connectOrCreate) {
-        connectOrCreate.values.forEach((value, i) => {
-          const query = internal._queryUpsert(rel.where(value.where), {
-            update: connectOrCreate.items[i],
-            create: {
-              ...value.create,
-              ...connectOrCreate.items[i]
-            }
-          });
-          internal._appendQuery(self, query, (as) => connectOrCreateAs = as);
-        });
-      }
-    } else {
-      hasRelationHandleCreate(
-        self,
-        ctx,
-        items,
-        rowIndexes,
-        this.key,
-        this.state.primaryKeys,
-        this.nestedInsert
-      );
-    }
-  }
-  update(self, set) {
-    const params = set[this.key];
-    if ((params.set || params.create || params.upsert) && internal.isQueryReturnsAll(self)) {
-      const key = params.set ? "set" : params.create ? "create" : "upsert";
-      throw new Error(`\`${key}\` option is not allowed in a batch update`);
-    }
-    const { primaryKeys, foreignKeys, query: relQuery } = this.state;
-    if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
-      let appendedAs;
-      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
-        selectIdsSql._sql = selectCteColumnsSql(
-          appendedAs,
-          aliasedPrimaryKeys
-        );
-        if (params.create || params.set || params.upsert) {
-          foreignKeys.forEach((foreignKey, i) => {
-            setIds[foreignKey]._sql = selectCteColumnSql(
-              appendedAs,
-              aliasedPrimaryKeys[i]
-            );
-          });
-        }
-      });
-      const selectIdsSql = new internal.RawSql("");
-      const existingRelQuery = internal._queryWhereIn(
-        internal._clone(relQuery),
-        true,
-        foreignKeys,
-        selectIdsSql
-      );
-      let setIds = void 0;
-      if (params.create || params.set || params.upsert) {
-        setIds = {};
-        foreignKeys.forEach((foreignKey) => {
-          setIds[foreignKey] = new internal.RawSql("");
-        });
-      }
-      const nullifyOrDeleteQuery = params.update ? internal._queryUpdate(existingRelQuery, params.update) : params.upsert ? internal._queryUpsert(existingRelQuery, {
-        update: params.upsert.update,
-        create: {
-          ...typeof params.upsert.create === "function" ? params.upsert.create() : params.upsert.create,
-          ...setIds
-        }
-      }) : params.delete ? internal._queryDelete(existingRelQuery) : internal._queryUpdate(existingRelQuery, this.setNulls);
-      nullifyOrDeleteQuery.q.returnType = "void";
-      internal._appendQuery(self, nullifyOrDeleteQuery, (as) => appendedAs = as);
-      if (params.create) {
-        const createQuery = internal._queryInsert(internal._clone(relQuery), {
-          ...params.create,
-          ...setIds
-        });
-        internal._appendQuery(self, createQuery, internal.noop);
-      } else if (params.set) {
-        const setQuery = internal._queryUpdate(
-          internal._queryWhere(internal._clone(relQuery), [params.set]),
-          setIds
-        );
-        setQuery.q.returnType = "void";
-        internal._appendQuery(self, setQuery, internal.noop);
-      }
-    }
-  }
-}
 const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
-  const relPKeys = internal.getPrimaryKeys(query);
-  if ("through" in relation.options) {
-    const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(table, through);
-    const sourceRelation = getSourceRelation(throughRelation, source);
-    const sourceRelationQuery = sourceRelation.query.as(
-      relationName
-    );
-    const sourceQuery = sourceRelation.joinQuery(
-      sourceRelationQuery,
-      throughRelation.query
-    );
-    const whereExistsCallback = () => sourceQuery;
-    const reverseJoin2 = (baseQuery, joiningQuery) => {
-      return joinHasThrough(
-        baseQuery,
-        baseQuery,
-        joiningQuery,
-        throughRelation,
-        sourceRelation
-      );
-    };
-    return {
-      returns: "one",
-      queryRelated: (params) => {
-        const throughQuery = table.queryRelated(through, params);
-        return query.whereExists(throughQuery, whereExistsCallback);
-      },
-      joinQuery: joinQueryChainHOF(
-        relPKeys,
-        reverseJoin2,
-        (joiningQuery, baseQuery) => joinHasThrough(
-          joiningQuery,
-          baseQuery,
-          joiningQuery,
-          throughRelation,
-          sourceRelation
-        )
-      ),
-      reverseJoin: reverseJoin2
-    };
-  }
-  const primaryKeys = relation.options.columns;
-  const foreignKeys = relation.options.references;
-  const { on } = relation.options;
-  if (on) {
-    internal._queryWhere(query, [on]);
-    internal._queryDefaults(query, on);
-  }
-  addAutoForeignKey(
-    tableConfig,
-    query,
-    table,
-    primaryKeys,
-    foreignKeys,
-    relation.options
-  );
-  const state = { query, primaryKeys, foreignKeys, on };
-  const len = primaryKeys.length;
-  const reversedOn = {};
-  for (let i = 0; i < len; i++) {
-    reversedOn[foreignKeys[i]] = primaryKeys[i];
-  }
-  const fromQuerySelect = [{ selectAs: reversedOn }];
-  const reverseJoin = (baseQuery, joiningQuery) => {
-    return joinHasRelation(
-      joiningQuery,
-      baseQuery,
-      foreignKeys,
-      primaryKeys,
-      len
-    );
-  };
-  return {
-    returns: "one",
-    queryRelated: (params) => {
-      const values = {};
-      for (let i = 0; i < len; i++) {
-        values[foreignKeys[i]] = params[primaryKeys[i]];
-      }
-      return internal._queryDefaults(query.where(values), { ...on, ...values });
-    },
-    virtualColumn: new HasOneVirtualColumn(
-      internal.defaultSchemaConfig,
-      relationName,
-      state
-    ),
-    joinQuery: joinQueryChainHOF(
-      relPKeys,
-      reverseJoin,
-      (joiningQuery, baseQuery) => joinHasRelation(
-        baseQuery,
-        joiningQuery,
-        primaryKeys,
-        foreignKeys,
-        len
-      )
-    ),
-    reverseJoin,
-    modifyRelatedQuery(relationQuery) {
-      return (query2) => {
-        const baseQuery = query2.clone();
-        baseQuery.q.select = fromQuerySelect;
-        const q = relationQuery.q;
-        q.insertFrom = internal.prepareSubQueryForSql(q, baseQuery);
-        q.values = [];
-      };
-    }
-  };
+	const relPKeys = (0, pqb_internal.getPrimaryKeys)(query);
+	if ("through" in relation.options) {
+		const { through, source } = relation.options;
+		const throughRelation = getThroughRelation(table, through);
+		const sourceRelation = getSourceRelation(throughRelation, source);
+		const sourceRelationQuery = sourceRelation.query.as(relationName);
+		const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
+		const whereExistsCallback = () => sourceQuery;
+		const reverseJoin = (baseQuery, joiningQuery) => {
+			return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
+		};
+		return {
+			returns: "one",
+			queryRelated: (params) => {
+				const throughQuery = table.queryRelated(through, params);
+				return query.whereExists(throughQuery, whereExistsCallback);
+			},
+			joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
+			reverseJoin
+		};
+	}
+	const primaryKeys = relation.options.columns;
+	const foreignKeys = relation.options.references;
+	const { on } = relation.options;
+	if (on) {
+		(0, pqb_internal._queryWhere)(query, [on]);
+		(0, pqb_internal._queryDefaults)(query, on);
+	}
+	addAutoForeignKey(tableConfig, query, table, primaryKeys, foreignKeys, relation.options);
+	const state = {
+		query,
+		primaryKeys,
+		foreignKeys,
+		on
+	};
+	const len = primaryKeys.length;
+	const reversedOn = {};
+	for (let i = 0; i < len; i++) reversedOn[foreignKeys[i]] = primaryKeys[i];
+	const fromQuerySelect = [{ selectAs: reversedOn }];
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		return joinHasRelation(joiningQuery, baseQuery, foreignKeys, primaryKeys, len);
+	};
+	return {
+		returns: "one",
+		queryRelated: (params) => {
+			const values = {};
+			for (let i = 0; i < len; i++) values[foreignKeys[i]] = params[primaryKeys[i]];
+			return (0, pqb_internal._queryDefaults)(query.where(values), {
+				...on,
+				...values
+			});
+		},
+		virtualColumn: new HasOneVirtualColumn(pqb_internal.defaultSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)),
+		reverseJoin,
+		modifyRelatedQuery(relationQuery) {
+			return (query) => {
+				const baseQuery = query.clone();
+				baseQuery.q.select = fromQuerySelect;
+				const q = relationQuery.q;
+				q.insertFrom = (0, pqb_internal.prepareSubQueryForSql)(q, baseQuery);
+				q.values = [];
+			};
+		}
+	};
 };
 const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
-  return async (_, data) => {
-    const t = query.clone();
-    const items = [];
-    for (const item of data) {
-      if (item[1].connect || item[1].connectOrCreate) {
-        items.push(item);
-      }
-    }
-    let connected;
-    if (items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        const [selfData, item] = items[i];
-        const data2 = {};
-        primaryKeys.forEach((primaryKey, i2) => {
-          data2[foreignKeys[i2]] = selfData[primaryKey];
-        });
-        items[i] = "connect" in item ? internal._queryUpdateOrThrow(
-          t.where(item.connect),
-          data2
-        ) : internal._queryUpdate(
-          t.where(
-            item.connectOrCreate.where
-          ),
-          data2
-        );
-      }
-      connected = await Promise.all(items);
-    } else {
-      connected = [];
-    }
-    let connectedI = 0;
-    items.length = 0;
-    for (const item of data) {
-      if (item[1].connectOrCreate) {
-        if (!connected[connectedI++]) {
-          items.push(item);
-        }
-      } else if (item[1].create) {
-        items.push(item);
-      }
-    }
-    if (items.length) {
-      for (let i = 0, len = items.length; i < len; i++) {
-        const [selfData, item] = items[i];
-        const data2 = {
-          ..."create" in item ? item.create : item.connectOrCreate.create
-        };
-        for (let i2 = 0; i2 < primaryKeys.length; i2++) {
-          data2[foreignKeys[i2]] = selfData[primaryKeys[i2]];
-        }
-        items[i] = data2;
-      }
-      await t.insertMany(items);
-    }
-  };
+	return (async (_, data) => {
+		const t = query.clone();
+		const items = [];
+		for (const item of data) if (item[1].connect || item[1].connectOrCreate) items.push(item);
+		let connected;
+		if (items.length) {
+			for (let i = 0, len = items.length; i < len; i++) {
+				const [selfData, item] = items[i];
+				const data = {};
+				primaryKeys.forEach((primaryKey, i) => {
+					data[foreignKeys[i]] = selfData[primaryKey];
+				});
+				items[i] = "connect" in item ? (0, pqb_internal._queryUpdateOrThrow)(t.where(item.connect), data) : (0, pqb_internal._queryUpdate)(t.where(item.connectOrCreate.where), data);
+			}
+			connected = await Promise.all(items);
+		} else connected = [];
+		let connectedI = 0;
+		items.length = 0;
+		for (const item of data) if (item[1].connectOrCreate) {
+			if (!connected[connectedI++]) items.push(item);
+		} else if (item[1].create) items.push(item);
+		if (items.length) {
+			for (let i = 0, len = items.length; i < len; i++) {
+				const [selfData, item] = items[i];
+				const data = { ..."create" in item ? item.create : item.connectOrCreate.create };
+				for (let i = 0; i < primaryKeys.length; i++) data[foreignKeys[i]] = selfData[primaryKeys[i]];
+				items[i] = data;
+			}
+			await t.insertMany(items);
+		}
+	});
+};
+var HasManyVirtualColumn = class extends pqb_internal.VirtualColumn {
+	constructor(schema, key, state) {
+		super(schema);
+		this.key = key;
+		this.state = state;
+		this.nestedInsert = nestedInsert$1(state);
+		this.nestedUpdate = nestedUpdate$1(state);
+	}
+	create(self, ctx, items, rowIndexes, count) {
+		if (count <= self.qb.internal.nestedCreateBatchMax) {
+			const { query: rel, primaryKeys, foreignKeys } = this.state;
+			let nestedCreateItems;
+			items.forEach((item, i) => {
+				const value = item[this.key];
+				if (value.create?.length) {
+					const nestedCreateItem = (nestedCreateItems ??= {}).create ??= {
+						indexes: [],
+						items: []
+					};
+					nestedCreateItem.indexes.push(rowIndexes[i]);
+					const data = value.create.map((obj) => {
+						const data = { ...obj };
+						for (const key of foreignKeys) data[key] = new pqb_internal.RawSql("");
+						return data;
+					});
+					nestedCreateItem.items.push(data);
+				} else {
+					const kind = value.connect?.length ? "connect" : value.connectOrCreate?.length ? "connectOrCreate" : void 0;
+					if (kind) {
+						const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+							indexes: [],
+							items: [],
+							values: []
+						};
+						nestedCreateItem.indexes.push(rowIndexes[i]);
+						nestedCreateItem.values.push(value[kind]);
+						const data = {};
+						for (const key of foreignKeys) data[key] = new pqb_internal.RawSql("");
+						nestedCreateItem.items.push(data);
+					}
+				}
+			});
+			if (!nestedCreateItems) return;
+			let createAs;
+			let connectAs;
+			let connectOrCreateAs;
+			(0, pqb_internal._hookSelectColumns)(self, primaryKeys, (aliasedPrimaryKeys) => {
+				foreignKeys.forEach((key, keyI) => {
+					const primaryKey = aliasedPrimaryKeys[keyI];
+					if (create && createAs) for (let i = 0; i < create.items.length; i++) {
+						const sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
+						for (const item of create.items[i]) item[key]._sql = sql;
+					}
+					if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(connectAs, primaryKey, connect.indexes[i], count);
+					if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(connectOrCreateAs, primaryKey, connectOrCreate.indexes[i], count);
+				});
+			});
+			const { create, connect, connectOrCreate } = nestedCreateItems;
+			if (create) (0, pqb_internal._appendQuery)(self, (0, pqb_internal._queryInsertMany)((0, pqb_internal._clone)(rel), create.items.flat()), (as) => createAs = as);
+			if (connect) connect.values.forEach((value, i) => {
+				const query = (0, pqb_internal._queryUpdateOrThrow)(rel.whereOneOf(...value), connect.items[i]);
+				query.q.ensureCount = value.length;
+				(0, pqb_internal._appendQuery)(self, query, (as) => connectAs = as);
+			});
+			if (connectOrCreate) connectOrCreate.values.forEach((array, i) => {
+				const foreignKeyValues = connectOrCreate.items[i];
+				for (const value of array) (0, pqb_internal._appendQuery)(self, (0, pqb_internal._queryUpsert)(rel.where(value.where), {
+					update: foreignKeyValues,
+					create: {
+						...value.create,
+						...foreignKeyValues
+					}
+				}), (as) => connectOrCreateAs = as);
+			});
+		} else hasRelationHandleCreate(self, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+	}
+	update(q, set) {
+		const params = set[this.key];
+		if ((params.set || params.create) && (0, pqb_internal.isQueryReturnsAll)(q)) {
+			const key = params.set ? "set" : "create";
+			throw new Error(`\`${key}\` option is not allowed in a batch update`);
+		}
+		hasRelationHandleUpdate(q, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+	}
 };
-
-class HasManyVirtualColumn extends internal.VirtualColumn {
-  constructor(schema, key, state) {
-    super(schema);
-    this.key = key;
-    this.state = state;
-    this.nestedInsert = nestedInsert$1(state);
-    this.nestedUpdate = nestedUpdate$1(state);
-  }
-  create(self, ctx, items, rowIndexes, count) {
-    if (count <= self.qb.internal.nestedCreateBatchMax) {
-      const { query: rel, primaryKeys, foreignKeys } = this.state;
-      let nestedCreateItems;
-      items.forEach((item, i) => {
-        var _a, _b;
-        const value = item[this.key];
-        if (value.create?.length) {
-          const nestedCreateItem = (_a = nestedCreateItems ?? (nestedCreateItems = {})).create ?? (_a.create = {
-            indexes: [],
-            items: []
-          });
-          nestedCreateItem.indexes.push(rowIndexes[i]);
-          const data = value.create.map((obj) => {
-            const data2 = { ...obj };
-            for (const key of foreignKeys) {
-              data2[key] = new internal.RawSql("");
-            }
-            return data2;
-          });
-          nestedCreateItem.items.push(data);
-        } else {
-          const kind = value.connect?.length ? "connect" : value.connectOrCreate?.length ? "connectOrCreate" : void 0;
-          if (kind) {
-            const nestedCreateItem = (_b = nestedCreateItems ?? (nestedCreateItems = {}))[kind] ?? (_b[kind] = {
-              indexes: [],
-              items: [],
-              values: []
-            });
-            nestedCreateItem.indexes.push(rowIndexes[i]);
-            nestedCreateItem.values.push(value[kind]);
-            const data = {};
-            for (const key of foreignKeys) {
-              data[key] = new internal.RawSql("");
-            }
-            nestedCreateItem.items.push(data);
-          }
-        }
-      });
-      if (!nestedCreateItems) {
-        return;
-      }
-      let createAs;
-      let connectAs;
-      let connectOrCreateAs;
-      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
-        foreignKeys.forEach((key, keyI) => {
-          const primaryKey = aliasedPrimaryKeys[keyI];
-          if (create && createAs) {
-            for (let i = 0; i < create.items.length; i++) {
-              const sql = selectCteColumnFromManySql(
-                createAs,
-                primaryKey,
-                create.indexes[i],
-                count
-              );
-              for (const item of create.items[i]) {
-                item[key]._sql = sql;
-              }
-            }
-          }
-          if (connect && connectAs) {
-            for (let i = 0; i < connect.items.length; i++) {
-              connect.items[i][key]._sql = selectCteColumnFromManySql(
-                connectAs,
-                primaryKey,
-                connect.indexes[i],
-                count
-              );
-            }
-          }
-          if (connectOrCreate && connectOrCreateAs) {
-            for (let i = 0; i < connectOrCreate.items.length; i++) {
-              connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(
-                connectOrCreateAs,
-                primaryKey,
-                connectOrCreate.indexes[i],
-                count
-              );
-            }
-          }
-        });
-      });
-      const { create, connect, connectOrCreate } = nestedCreateItems;
-      if (create) {
-        const query = internal._queryInsertMany(
-          internal._clone(rel),
-          create.items.flat()
-        );
-        internal._appendQuery(self, query, (as) => createAs = as);
-      }
-      if (connect) {
-        connect.values.forEach((value, i) => {
-          const query = internal._queryUpdateOrThrow(
-            rel.whereOneOf(...value),
-            connect.items[i]
-          );
-          query.q.ensureCount = value.length;
-          internal._appendQuery(self, query, (as) => connectAs = as);
-        });
-      }
-      if (connectOrCreate) {
-        connectOrCreate.values.forEach((array, i) => {
-          const foreignKeyValues = connectOrCreate.items[i];
-          for (const value of array) {
-            const query = internal._queryUpsert(rel.where(value.where), {
-              update: foreignKeyValues,
-              create: {
-                ...value.create,
-                ...foreignKeyValues
-              }
-            });
-            internal._appendQuery(self, query, (as) => connectOrCreateAs = as);
-          }
-        });
-      }
-    } else {
-      hasRelationHandleCreate(
-        self,
-        ctx,
-        items,
-        rowIndexes,
-        this.key,
-        this.state.primaryKeys,
-        this.nestedInsert
-      );
-    }
-  }
-  update(q, set) {
-    const params = set[this.key];
-    if ((params.set || params.create) && internal.isQueryReturnsAll(q)) {
-      const key = params.set ? "set" : "create";
-      throw new Error(`\`${key}\` option is not allowed in a batch update`);
-    }
-    hasRelationHandleUpdate(
-      q,
-      set,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedUpdate
-    );
-  }
-}
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
-  const relPKeys = internal.getPrimaryKeys(query);
-  if ("through" in relation.options) {
-    const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(table, through);
-    const sourceRelation = getSourceRelation(throughRelation, source);
-    const sourceRelationQuery = sourceRelation.query.as(
-      relationName
-    );
-    const sourceQuery = sourceRelation.joinQuery(
-      sourceRelationQuery,
-      throughRelation.query
-    );
-    const whereExistsCallback = () => sourceQuery;
-    const reverseJoin2 = (baseQuery, joiningQuery) => {
-      return joinHasThrough(
-        baseQuery,
-        baseQuery,
-        joiningQuery,
-        throughRelation,
-        sourceRelation
-      );
-    };
-    return {
-      returns: "many",
-      queryRelated: (params) => {
-        const throughQuery = table.queryRelated(through, params);
-        return query.whereExists(
-          throughQuery,
-          whereExistsCallback
-        );
-      },
-      joinQuery: joinQueryChainHOF(
-        relPKeys,
-        reverseJoin2,
-        (joiningQuery, baseQuery) => joinHasThrough(
-          joiningQuery,
-          baseQuery,
-          joiningQuery,
-          throughRelation,
-          sourceRelation
-        )
-      ),
-      reverseJoin: reverseJoin2
-    };
-  }
-  const primaryKeys = relation.options.columns;
-  const foreignKeys = relation.options.references;
-  const { on } = relation.options;
-  if (on) {
-    internal._queryWhere(query, [on]);
-    internal._queryDefaults(query, on);
-  }
-  addAutoForeignKey(
-    tableConfig,
-    query,
-    table,
-    primaryKeys,
-    foreignKeys,
-    relation.options
-  );
-  const state = { query, primaryKeys, foreignKeys, on };
-  const len = primaryKeys.length;
-  const reversedOn = {};
-  for (let i = 0; i < len; i++) {
-    reversedOn[foreignKeys[i]] = primaryKeys[i];
-  }
-  const fromQuerySelect = [{ selectAs: reversedOn }];
-  const reverseJoin = (baseQuery, joiningQuery) => {
-    return joinHasRelation(
-      joiningQuery,
-      baseQuery,
-      foreignKeys,
-      primaryKeys,
-      len
-    );
-  };
-  return {
-    returns: "many",
-    queryRelated: (params) => {
-      const values = {};
-      for (let i = 0; i < len; i++) {
-        values[foreignKeys[i]] = params[primaryKeys[i]];
-      }
-      return internal._queryDefaults(query.where(values), { ...on, ...values });
-    },
-    virtualColumn: new HasManyVirtualColumn(
-      internal.defaultSchemaConfig,
-      relationName,
-      state
-    ),
-    joinQuery: joinQueryChainHOF(
-      relPKeys,
-      reverseJoin,
-      (joiningQuery, baseQuery) => joinHasRelation(
-        baseQuery,
-        joiningQuery,
-        primaryKeys,
-        foreignKeys,
-        len
-      )
-    ),
-    reverseJoin,
-    modifyRelatedQuery(relationQuery) {
-      return (query2) => {
-        const baseQuery = query2.clone();
-        baseQuery.q.select = fromQuerySelect;
-        const q = relationQuery.q;
-        q.insertFrom = internal.prepareSubQueryForSql(q, baseQuery);
-        q.values = [];
-      };
-    }
-  };
+	const relPKeys = (0, pqb_internal.getPrimaryKeys)(query);
+	if ("through" in relation.options) {
+		const { through, source } = relation.options;
+		const throughRelation = getThroughRelation(table, through);
+		const sourceRelation = getSourceRelation(throughRelation, source);
+		const sourceRelationQuery = sourceRelation.query.as(relationName);
+		const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
+		const whereExistsCallback = () => sourceQuery;
+		const reverseJoin = (baseQuery, joiningQuery) => {
+			return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
+		};
+		return {
+			returns: "many",
+			queryRelated: (params) => {
+				const throughQuery = table.queryRelated(through, params);
+				return query.whereExists(throughQuery, whereExistsCallback);
+			},
+			joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
+			reverseJoin
+		};
+	}
+	const primaryKeys = relation.options.columns;
+	const foreignKeys = relation.options.references;
+	const { on } = relation.options;
+	if (on) {
+		(0, pqb_internal._queryWhere)(query, [on]);
+		(0, pqb_internal._queryDefaults)(query, on);
+	}
+	addAutoForeignKey(tableConfig, query, table, primaryKeys, foreignKeys, relation.options);
+	const state = {
+		query,
+		primaryKeys,
+		foreignKeys,
+		on
+	};
+	const len = primaryKeys.length;
+	const reversedOn = {};
+	for (let i = 0; i < len; i++) reversedOn[foreignKeys[i]] = primaryKeys[i];
+	const fromQuerySelect = [{ selectAs: reversedOn }];
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		return joinHasRelation(joiningQuery, baseQuery, foreignKeys, primaryKeys, len);
+	};
+	return {
+		returns: "many",
+		queryRelated: (params) => {
+			const values = {};
+			for (let i = 0; i < len; i++) values[foreignKeys[i]] = params[primaryKeys[i]];
+			return (0, pqb_internal._queryDefaults)(query.where(values), {
+				...on,
+				...values
+			});
+		},
+		virtualColumn: new HasManyVirtualColumn(pqb_internal.defaultSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)),
+		reverseJoin,
+		modifyRelatedQuery(relationQuery) {
+			return (query) => {
+				const baseQuery = query.clone();
+				baseQuery.q.select = fromQuerySelect;
+				const q = relationQuery.q;
+				q.insertFrom = (0, pqb_internal.prepareSubQueryForSql)(q, baseQuery);
+				q.values = [];
+			};
+		}
+	};
 };
 const getWhereForNestedUpdate = (t, data, params, primaryKeys, foreignKeys) => {
-  return t.where({
-    IN: {
-      columns: foreignKeys,
-      values: data.map((item) => primaryKeys.map((key) => item[key]))
-    },
-    OR: params ? internal.toArray(params) : void 0
-  });
+	return t.where({
+		IN: {
+			columns: foreignKeys,
+			values: data.map((item) => primaryKeys.map((key) => item[key]))
+		},
+		OR: params ? (0, pqb_internal.toArray)(params) : void 0
+	});
 };
 const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
-  const len = primaryKeys.length;
-  return async (_, data) => {
-    const t = query.clone();
-    const items = [];
-    for (const item of data) {
-      if (item[1].connect) {
-        items.push(item);
-      }
-    }
-    if (items.length) {
-      for (let i = 0, len2 = items.length; i < len2; i++) {
-        const [selfData, { connect }] = items[i];
-        const obj = {};
-        for (let i2 = 0; i2 < len2; i2++) {
-          obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
-        }
-        items[i] = internal._queryUpdateOrThrow(
-          t.where({ OR: connect }),
-          obj
-        );
-      }
-      await Promise.all(items);
-    }
-    items.length = 0;
-    for (const item of data) {
-      if (item[1].connectOrCreate) {
-        items.push(item);
-      }
-    }
-    let connected;
-    if (items.length) {
-      const queries = [];
-      for (let i = 0, len2 = items.length; i < len2; i++) {
-        const [selfData, { connectOrCreate }] = items[i];
-        for (const item of connectOrCreate) {
-          const obj = {};
-          for (let i2 = 0; i2 < len2; i2++) {
-            obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
-          }
-          queries.push(
-            internal._queryUpdate(
-              t.where(item.where),
-              obj
-            )
-          );
-        }
-      }
-      connected = await Promise.all(queries);
-    } else {
-      connected = [];
-    }
-    let connectedI = 0;
-    items.length = 0;
-    for (const item of data) {
-      if (item[1].connectOrCreate) {
-        const length = item[1].connectOrCreate.length;
-        connectedI += length;
-        for (let i = length; i > 0; i--) {
-          if (connected[connectedI - i] === 0) {
-            items.push(item);
-            break;
-          }
-        }
-      } else if (item[1].create) {
-        items.push(item);
-      }
-    }
-    connectedI = 0;
-    if (items.length) {
-      const records = [];
-      for (const [selfData, { create, connectOrCreate }] of items) {
-        const obj = {};
-        for (let i = 0; i < len; i++) {
-          obj[foreignKeys[i]] = selfData[primaryKeys[i]];
-        }
-        if (create) {
-          for (const item of create) {
-            records.push({
-              ...item,
-              ...obj
-            });
-          }
-        }
-        if (connectOrCreate) {
-          for (const item of connectOrCreate) {
-            if (connected[connectedI++] === 0) {
-              records.push({
-                ...item.create,
-                ...obj
-              });
-            }
-          }
-        }
-      }
-      await internal._queryCreateMany(t, records);
-    }
-  };
+	const len = primaryKeys.length;
+	return (async (_, data) => {
+		const t = query.clone();
+		const items = [];
+		for (const item of data) if (item[1].connect) items.push(item);
+		if (items.length) {
+			for (let i = 0, len = items.length; i < len; i++) {
+				const [selfData, { connect }] = items[i];
+				const obj = {};
+				for (let i = 0; i < len; i++) obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+				items[i] = (0, pqb_internal._queryUpdateOrThrow)(t.where({ OR: connect }), obj);
+			}
+			await Promise.all(items);
+		}
+		items.length = 0;
+		for (const item of data) if (item[1].connectOrCreate) items.push(item);
+		let connected;
+		if (items.length) {
+			const queries = [];
+			for (let i = 0, len = items.length; i < len; i++) {
+				const [selfData, { connectOrCreate }] = items[i];
+				for (const item of connectOrCreate) {
+					const obj = {};
+					for (let i = 0; i < len; i++) obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+					queries.push((0, pqb_internal._queryUpdate)(t.where(item.where), obj));
+				}
+			}
+			connected = await Promise.all(queries);
+		} else connected = [];
+		let connectedI = 0;
+		items.length = 0;
+		for (const item of data) if (item[1].connectOrCreate) {
+			const length = item[1].connectOrCreate.length;
+			connectedI += length;
+			for (let i = length; i > 0; i--) if (connected[connectedI - i] === 0) {
+				items.push(item);
+				break;
+			}
+		} else if (item[1].create) items.push(item);
+		connectedI = 0;
+		if (items.length) {
+			const records = [];
+			for (const [selfData, { create, connectOrCreate }] of items) {
+				const obj = {};
+				for (let i = 0; i < len; i++) obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+				if (create) for (const item of create) records.push({
+					...item,
+					...obj
+				});
+				if (connectOrCreate) {
+					for (const item of connectOrCreate) if (connected[connectedI++] === 0) records.push({
+						...item.create,
+						...obj
+					});
+				}
+			}
+			await (0, pqb_internal._queryCreateMany)(t, records);
+		}
+	});
 };
 const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
-  const len = primaryKeys.length;
-  return async (_, data, params) => {
-    const t = query.clone();
-    if (params.create) {
-      const obj = {};
-      for (let i = 0; i < len; i++) {
-        obj[foreignKeys[i]] = data[0][primaryKeys[i]];
-      }
-      await t.insertMany(
-        params.create.map((create) => ({
-          ...create,
-          ...obj
-        }))
-      );
-    }
-    if (params.add) {
-      if (data.length > 1) {
-        throw new pqb.OrchidOrmInternalError(
-          query,
-          "`connect` is not available when updating multiple records, it is only applicable for a single record update"
-        );
-      }
-      const obj = {};
-      for (let i = 0; i < len; i++) {
-        obj[foreignKeys[i]] = data[0][primaryKeys[i]];
-      }
-      const relatedWheres = internal.toArray(params.add);
-      const count = await internal._queryUpdate(
-        t.where({ OR: relatedWheres }),
-        obj
-      );
-      if (count < relatedWheres.length) {
-        throw new pqb.OrchidOrmInternalError(
-          query,
-          `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`
-        );
-      }
-    }
-    if (params.disconnect || params.set) {
-      const obj = {};
-      for (const foreignKey of foreignKeys) {
-        obj[foreignKey] = null;
-      }
-      const setConditions = params.set && (Array.isArray(params.set) ? params.set.length : internal.objectHasValues(params.set)) && (Array.isArray(params.set) ? {
-        OR: params.set
-      } : params.set);
-      let queryToDisconnect = getWhereForNestedUpdate(
-        t,
-        data,
-        params.disconnect,
-        primaryKeys,
-        foreignKeys
-      );
-      if (setConditions) {
-        queryToDisconnect = queryToDisconnect.whereNot(setConditions);
-      }
-      await internal._queryUpdate(queryToDisconnect, obj);
-      if (setConditions) {
-        const obj2 = {};
-        for (let i = 0; i < len; i++) {
-          obj2[foreignKeys[i]] = data[0][primaryKeys[i]];
-        }
-        await internal._queryUpdate(
-          t.where(setConditions),
-          obj2
-        );
-      }
-    }
-    if (params.delete || params.update) {
-      const q = getWhereForNestedUpdate(
-        t,
-        data,
-        params.delete || params.update?.where,
-        primaryKeys,
-        foreignKeys
-      );
-      if (params.delete) {
-        await internal._queryDelete(q);
-      } else if (params.update) {
-        await internal._queryUpdate(q, params.update.data);
-      }
-    }
-  };
+	const len = primaryKeys.length;
+	return (async (_, data, params) => {
+		const t = query.clone();
+		if (params.create) {
+			const obj = {};
+			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
+			await t.insertMany(params.create.map((create) => ({
+				...create,
+				...obj
+			})));
+		}
+		if (params.add) {
+			if (data.length > 1) throw new pqb.OrchidOrmInternalError(query, "`connect` is not available when updating multiple records, it is only applicable for a single record update");
+			const obj = {};
+			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
+			const relatedWheres = (0, pqb_internal.toArray)(params.add);
+			const count = await (0, pqb_internal._queryUpdate)(t.where({ OR: relatedWheres }), obj);
+			if (count < relatedWheres.length) throw new pqb.OrchidOrmInternalError(query, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`);
+		}
+		if (params.disconnect || params.set) {
+			const obj = {};
+			for (const foreignKey of foreignKeys) obj[foreignKey] = null;
+			const setConditions = params.set && (Array.isArray(params.set) ? params.set.length : (0, pqb_internal.objectHasValues)(params.set)) && (Array.isArray(params.set) ? { OR: params.set } : params.set);
+			let queryToDisconnect = getWhereForNestedUpdate(t, data, params.disconnect, primaryKeys, foreignKeys);
+			if (setConditions) queryToDisconnect = queryToDisconnect.whereNot(setConditions);
+			await (0, pqb_internal._queryUpdate)(queryToDisconnect, obj);
+			if (setConditions) {
+				const obj = {};
+				for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
+				await (0, pqb_internal._queryUpdate)(t.where(setConditions), obj);
+			}
+		}
+		if (params.delete || params.update) {
+			const q = getWhereForNestedUpdate(t, data, params.delete || params.update?.where, primaryKeys, foreignKeys);
+			if (params.delete) await (0, pqb_internal._queryDelete)(q);
+			else if (params.update) await (0, pqb_internal._queryUpdate)(q, params.update.data);
+		}
+	});
+};
+var HasAndBelongsToManyVirtualColumn = class extends pqb_internal.VirtualColumn {
+	constructor(joinTable, schema, key, state) {
+		super(schema);
+		this.joinTable = joinTable;
+		this.key = key;
+		this.state = state;
+		this.nestedInsert = nestedInsert(state);
+		this.nestedUpdate = nestedUpdate(state);
+	}
+	create(q, ctx, items, rowIndexes) {
+		hasRelationHandleCreate(q, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+	}
+	update(q, set) {
+		hasRelationHandleUpdate(q, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+	}
 };
-
-class HasAndBelongsToManyVirtualColumn extends internal.VirtualColumn {
-  constructor(joinTable, schema, key, state) {
-    super(schema);
-    this.joinTable = joinTable;
-    this.key = key;
-    this.state = state;
-    this.nestedInsert = nestedInsert(state);
-    this.nestedUpdate = nestedUpdate(state);
-  }
-  create(q, ctx, items, rowIndexes) {
-    hasRelationHandleCreate(
-      q,
-      ctx,
-      items,
-      rowIndexes,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedInsert
-    );
-  }
-  update(q, set) {
-    hasRelationHandleUpdate(
-      q,
-      set,
-      this.key,
-      this.state.primaryKeys,
-      this.nestedUpdate
-    );
-  }
-}
 const removeColumnName = (column) => {
-  if (!column.data.name) return column;
-  const cloned = Object.create(column);
-  cloned.data = { ...column.data, name: void 0 };
-  return cloned;
+	if (!column.data.name) return column;
+	const cloned = Object.create(column);
+	cloned.data = {
+		...column.data,
+		name: void 0
+	};
+	return cloned;
 };
 const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query, schema) => {
-  const { options } = relation;
-  const { snakeCase } = table.internal;
-  const primaryKeys = options.columns;
-  const foreignKeys = options.references;
-  const originalForeignKeys = snakeCase ? [...foreignKeys] : foreignKeys;
-  const joinTable = options.through.table;
-  const throughForeignKeys = options.through.columns;
-  const originalThroughForeignKeys = snakeCase ? [...throughForeignKeys] : throughForeignKeys;
-  const throughPrimaryKeys = options.through.references;
-  const { on } = options;
-  if (on) {
-    internal._queryWhere(query, [on]);
-    internal._queryDefaults(query, on);
-  }
-  const foreignKeysFull = foreignKeys.map((key, i) => {
-    if (snakeCase) key = foreignKeys[i] = internal.toSnakeCase(key);
-    return `${joinTable}.${key}`;
-  });
-  const throughForeignKeysFull = throughForeignKeys.map((key, i) => {
-    if (snakeCase) key = throughForeignKeys[i] = internal.toSnakeCase(key);
-    return `${joinTable}.${key}`;
-  });
-  const foreignTable = internal.getQueryAs(query);
-  const throughPrimaryKeysFull = throughPrimaryKeys.map(
-    (key) => `${foreignTable}.${key}`
-  );
-  const len = primaryKeys.length;
-  const throughLen = throughPrimaryKeys.length;
-  const baseQuery = Object.create(qb.baseQuery);
-  baseQuery.baseQuery = baseQuery;
-  baseQuery.table = joinTable;
-  const shape = {};
-  const primaryKeysShape = {};
-  for (let i = 0; i < len; i++) {
-    const pk = primaryKeys[i];
-    shape[foreignKeys[i]] = removeColumnName(
-      table.shape[pk]
-    );
-    primaryKeysShape[pk] = table.shape[pk];
-  }
-  for (let i = 0; i < throughLen; i++) {
-    shape[throughForeignKeys[i]] = removeColumnName(
-      query.shape[throughPrimaryKeys[i]]
-    );
-  }
-  baseQuery.shape = shape;
-  baseQuery.q = {
-    ...baseQuery.q,
-    schema: options.through.schema || schema,
-    shape: baseQuery.shape
-  };
-  const subQuery = Object.create(baseQuery);
-  addAutoForeignKey(
-    tableConfig,
-    subQuery,
-    table,
-    primaryKeys,
-    foreignKeys,
-    relation.options,
-    originalForeignKeys
-  );
-  addAutoForeignKey(
-    tableConfig,
-    subQuery,
-    query,
-    throughPrimaryKeys,
-    throughForeignKeys,
-    relation.options.through,
-    originalThroughForeignKeys
-  );
-  const state = {
-    relatedTableQuery: query,
-    joinTableQuery: subQuery,
-    primaryKeys,
-    foreignKeys,
-    throughForeignKeys,
-    throughPrimaryKeys,
-    foreignKeysFull,
-    throughForeignKeysFull,
-    throughPrimaryKeysFull,
-    primaryKeysShape,
-    on
-  };
-  const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
-    const cloned = joiningQuery.clone();
-    cloned.q.joinedShapes = joinedShapes;
-    return internal._queryWhereExists(cloned, subQuery, [
-      (q) => {
-        for (let i = 0; i < throughLen; i++) {
-          internal._queryJoinOn(q, [
-            throughForeignKeysFull[i],
-            `${foreignAs}.${throughPrimaryKeys[i]}`
-          ]);
-        }
-        for (let i = 0; i < len; i++) {
-          internal._queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
-        }
-        return q;
-      }
-    ]);
-  };
-  const obj = {};
-  for (let i = 0; i < len; i++) {
-    obj[foreignKeys[i]] = primaryKeys[i];
-  }
-  const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
-  const reverseJoin = (baseQuery2, joiningQuery) => {
-    const foreignAs = internal.getQueryAs(joiningQuery);
-    return joinQuery(
-      baseQuery2,
-      internal.getQueryAs(baseQuery2),
-      foreignAs,
-      {
-        ...baseQuery2.q.joinedShapes,
-        [foreignAs]: joiningQuery.q.shape
-      }
-    );
-  };
-  return {
-    returns: "many",
-    queryRelated(params) {
-      const q = query.whereExists(subQuery, (q2) => {
-        q2 = q2.clone();
-        const where = {};
-        for (let i = 0; i < len; i++) {
-          where[foreignKeysFull[i]] = params[primaryKeys[i]];
-        }
-        for (let i = 0; i < throughLen; i++) {
-          internal._queryJoinOn(q2, [
-            throughForeignKeysFull[i],
-            throughPrimaryKeysFull[i]
-          ]);
-        }
-        return internal._queryWhere(q2, [where]);
-      });
-      return on ? internal._queryDefaults(q, on) : q;
-    },
-    virtualColumn: new HasAndBelongsToManyVirtualColumn(
-      subQuery,
-      internal.defaultSchemaConfig,
-      relationName,
-      state
-    ),
-    joinQuery: joinQueryChainHOF(
-      internal.getPrimaryKeys(query),
-      reverseJoin,
-      (joiningQuery, baseQuery2) => joinQuery(
-        joiningQuery,
-        internal.getQueryAs(baseQuery2),
-        internal.getQueryAs(joiningQuery),
-        {
-          ...joiningQuery.q.joinedShapes,
-          [baseQuery2.q.as || baseQuery2.table]: baseQuery2.q.shape
-        }
-      )
-    ),
-    reverseJoin,
-    modifyRelatedQuery(relationQuery) {
-      const ref = {};
-      internal._queryHookAfterCreate(
-        relationQuery,
-        [],
-        async (result) => {
-          const baseQuery2 = ref.q.clone();
-          baseQuery2.q.select = selectPrimaryKeysAsForeignKeys;
-          const data = result.map((resultRow) => {
-            const dataRow = {};
-            for (let i = 0; i < throughLen; i++) {
-              dataRow[throughForeignKeys[i]] = resultRow[throughPrimaryKeys[i]];
-            }
-            return dataRow;
-          });
-          const createdCount = await internal._queryCreateManyFrom(
-            subQuery.count(),
-            baseQuery2,
-            data
-          );
-          if (createdCount === 0) {
-            throw new pqb.NotFoundError(baseQuery2);
-          }
-        }
-      );
-      return (q) => {
-        ref.q = q;
-      };
-    }
-  };
+	const { options } = relation;
+	const { snakeCase } = table.internal;
+	const primaryKeys = options.columns;
+	const foreignKeys = options.references;
+	const originalForeignKeys = snakeCase ? [...foreignKeys] : foreignKeys;
+	const joinTable = options.through.table;
+	const throughForeignKeys = options.through.columns;
+	const originalThroughForeignKeys = snakeCase ? [...throughForeignKeys] : throughForeignKeys;
+	const throughPrimaryKeys = options.through.references;
+	const { on } = options;
+	if (on) {
+		(0, pqb_internal._queryWhere)(query, [on]);
+		(0, pqb_internal._queryDefaults)(query, on);
+	}
+	const foreignKeysFull = foreignKeys.map((key, i) => {
+		if (snakeCase) key = foreignKeys[i] = (0, pqb_internal.toSnakeCase)(key);
+		return `${joinTable}.${key}`;
+	});
+	const throughForeignKeysFull = throughForeignKeys.map((key, i) => {
+		if (snakeCase) key = throughForeignKeys[i] = (0, pqb_internal.toSnakeCase)(key);
+		return `${joinTable}.${key}`;
+	});
+	const foreignTable = (0, pqb_internal.getQueryAs)(query);
+	const throughPrimaryKeysFull = throughPrimaryKeys.map((key) => `${foreignTable}.${key}`);
+	const len = primaryKeys.length;
+	const throughLen = throughPrimaryKeys.length;
+	const baseQuery = Object.create(qb.baseQuery);
+	baseQuery.baseQuery = baseQuery;
+	baseQuery.table = joinTable;
+	const shape = {};
+	const primaryKeysShape = {};
+	for (let i = 0; i < len; i++) {
+		const pk = primaryKeys[i];
+		shape[foreignKeys[i]] = removeColumnName(table.shape[pk]);
+		primaryKeysShape[pk] = table.shape[pk];
+	}
+	for (let i = 0; i < throughLen; i++) shape[throughForeignKeys[i]] = removeColumnName(query.shape[throughPrimaryKeys[i]]);
+	baseQuery.shape = shape;
+	baseQuery.q = {
+		...baseQuery.q,
+		schema: options.through.schema || schema,
+		shape: baseQuery.shape
+	};
+	const subQuery = Object.create(baseQuery);
+	addAutoForeignKey(tableConfig, subQuery, table, primaryKeys, foreignKeys, relation.options, originalForeignKeys);
+	addAutoForeignKey(tableConfig, subQuery, query, throughPrimaryKeys, throughForeignKeys, relation.options.through, originalThroughForeignKeys);
+	const state = {
+		relatedTableQuery: query,
+		joinTableQuery: subQuery,
+		primaryKeys,
+		foreignKeys,
+		throughForeignKeys,
+		throughPrimaryKeys,
+		foreignKeysFull,
+		throughForeignKeysFull,
+		throughPrimaryKeysFull,
+		primaryKeysShape,
+		on
+	};
+	const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
+		const cloned = joiningQuery.clone();
+		cloned.q.joinedShapes = joinedShapes;
+		return (0, pqb_internal._queryWhereExists)(cloned, subQuery, [(q) => {
+			for (let i = 0; i < throughLen; i++) (0, pqb_internal._queryJoinOn)(q, [throughForeignKeysFull[i], `${foreignAs}.${throughPrimaryKeys[i]}`]);
+			for (let i = 0; i < len; i++) (0, pqb_internal._queryJoinOn)(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
+			return q;
+		}]);
+	};
+	const obj = {};
+	for (let i = 0; i < len; i++) obj[foreignKeys[i]] = primaryKeys[i];
+	const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		const foreignAs = (0, pqb_internal.getQueryAs)(joiningQuery);
+		return joinQuery(baseQuery, (0, pqb_internal.getQueryAs)(baseQuery), foreignAs, {
+			...baseQuery.q.joinedShapes,
+			[foreignAs]: joiningQuery.q.shape
+		});
+	};
+	return {
+		returns: "many",
+		queryRelated(params) {
+			const q = query.whereExists(subQuery, (q) => {
+				q = q.clone();
+				const where = {};
+				for (let i = 0; i < len; i++) where[foreignKeysFull[i]] = params[primaryKeys[i]];
+				for (let i = 0; i < throughLen; i++) (0, pqb_internal._queryJoinOn)(q, [throughForeignKeysFull[i], throughPrimaryKeysFull[i]]);
+				return (0, pqb_internal._queryWhere)(q, [where]);
+			});
+			return on ? (0, pqb_internal._queryDefaults)(q, on) : q;
+		},
+		virtualColumn: new HasAndBelongsToManyVirtualColumn(subQuery, pqb_internal.defaultSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF((0, pqb_internal.getPrimaryKeys)(query), reverseJoin, (joiningQuery, baseQuery) => joinQuery(joiningQuery, (0, pqb_internal.getQueryAs)(baseQuery), (0, pqb_internal.getQueryAs)(joiningQuery), {
+			...joiningQuery.q.joinedShapes,
+			[baseQuery.q.as || baseQuery.table]: baseQuery.q.shape
+		})),
+		reverseJoin,
+		modifyRelatedQuery(relationQuery) {
+			const ref = {};
+			(0, pqb_internal._queryHookAfterCreate)(relationQuery, [], async (result) => {
+				const baseQuery = ref.q.clone();
+				baseQuery.q.select = selectPrimaryKeysAsForeignKeys;
+				const data = result.map((resultRow) => {
+					const dataRow = {};
+					for (let i = 0; i < throughLen; i++) dataRow[throughForeignKeys[i]] = resultRow[throughPrimaryKeys[i]];
+					return dataRow;
+				});
+				if (await (0, pqb_internal._queryCreateManyFrom)(subQuery.count(), baseQuery, data) === 0) throw new pqb.NotFoundError(baseQuery);
+			});
+			return (q) => {
+				ref.q = q;
+			};
+		}
+	};
 };
 const queryJoinTable = (state, data, conditions) => {
-  const t = state.joinTableQuery.where({
-    IN: {
-      columns: state.foreignKeys,
-      values: data.map((item) => state.primaryKeys.map((key) => item[key]))
-    }
-  });
-  if (conditions) {
-    internal._queryWhere(t, [
-      {
-        IN: {
-          columns: state.throughForeignKeys,
-          values: internal._querySelect(
-            state.relatedTableQuery.where(conditionsToWhereArg(conditions)),
-            state.throughPrimaryKeys
-          )
-        }
-      }
-    ]);
-  }
-  if (state.on) {
-    internal._queryWhereExists(t, state.relatedTableQuery, [
-      (q) => {
-        for (let i = 0; i < state.throughPrimaryKeys.length; i++) {
-          internal._queryJoinOn(q, [
-            state.throughPrimaryKeysFull[i],
-            state.throughForeignKeysFull[i]
-          ]);
-        }
-        return q;
-      }
-    ]);
-  }
-  return t;
+	const t = state.joinTableQuery.where({ IN: {
+		columns: state.foreignKeys,
+		values: data.map((item) => state.primaryKeys.map((key) => item[key]))
+	} });
+	if (conditions) (0, pqb_internal._queryWhere)(t, [{ IN: {
+		columns: state.throughForeignKeys,
+		values: (0, pqb_internal._querySelect)(state.relatedTableQuery.where(conditionsToWhereArg(conditions)), state.throughPrimaryKeys)
+	} }]);
+	if (state.on) (0, pqb_internal._queryWhereExists)(t, state.relatedTableQuery, [(q) => {
+		for (let i = 0; i < state.throughPrimaryKeys.length; i++) (0, pqb_internal._queryJoinOn)(q, [state.throughPrimaryKeysFull[i], state.throughForeignKeysFull[i]]);
+		return q;
+	}]);
+	return t;
 };
 const conditionsToWhereArg = (conditions) => Array.isArray(conditions) ? { OR: conditions } : conditions;
 const insertToJoinTable = (state, joinTableTransaction, data, idsRows) => {
-  const len = state.primaryKeys.length;
-  const throughLen = state.throughPrimaryKeys.length;
-  const records = [];
-  for (const item of data) {
-    const obj = {};
-    for (let i = 0; i < len; i++) {
-      obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
-    }
-    for (const ids of idsRows) {
-      const record = { ...obj };
-      for (let i = 0; i < throughLen; i++) {
-        record[state.throughForeignKeys[i]] = ids[i];
-      }
-      records.push(record);
-    }
-  }
-  return joinTableTransaction.insertMany(records);
+	const len = state.primaryKeys.length;
+	const throughLen = state.throughPrimaryKeys.length;
+	const records = [];
+	for (const item of data) {
+		const obj = {};
+		for (let i = 0; i < len; i++) obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
+		for (const ids of idsRows) {
+			const record = { ...obj };
+			for (let i = 0; i < throughLen; i++) record[state.throughForeignKeys[i]] = ids[i];
+			records.push(record);
+		}
+	}
+	return joinTableTransaction.insertMany(records);
 };
-const nestedInsert = ({
-  relatedTableQuery,
-  joinTableQuery,
-  primaryKeys,
-  foreignKeys,
-  throughPrimaryKeys,
-  throughForeignKeys
-}) => {
-  const len = primaryKeys.length;
-  const throughLen = primaryKeys.length;
-  return async (_, data) => {
-    const t = relatedTableQuery.clone();
-    const items = [];
-    for (const item of data) {
-      if (item[1].connect) {
-        items.push(item);
-      }
-    }
-    let connected;
-    if (items.length) {
-      const queries = [];
-      for (const [, { connect }] of items) {
-        for (const item of connect) {
-          queries.push(
-            internal._queryFindBy(
-              t.select(...throughPrimaryKeys),
-              item
-            )
-          );
-        }
-      }
-      connected = await Promise.all(queries);
-    } else {
-      connected = [];
-    }
-    items.length = 0;
-    for (const item of data) {
-      if (item[1].connectOrCreate) {
-        items.push(item);
-      }
-    }
-    let connectOrCreated;
-    if (items.length) {
-      const queries = [];
-      for (const [, { connectOrCreate }] of items) {
-        for (const item of connectOrCreate) {
-          queries.push(
-            internal._queryFindByOptional(
-              t.select(...throughPrimaryKeys),
-              item.where
-            )
-          );
-        }
-      }
-      connectOrCreated = await Promise.all(queries);
-    } else {
-      connectOrCreated = [];
-    }
-    let connectOrCreateI = 0;
-    items.length = 0;
-    for (const item of data) {
-      if (item[1].connectOrCreate) {
-        const length = item[1].connectOrCreate.length;
-        connectOrCreateI += length;
-        for (let i = length; i > 0; i--) {
-          if (!connectOrCreated[connectOrCreateI - i]) {
-            items.push(item);
-            break;
-          }
-        }
-      } else if (item[1].create) {
-        items.push(item);
-      }
-    }
-    connectOrCreateI = 0;
-    let created;
-    if (items.length) {
-      const records2 = [];
-      for (const [, { create, connectOrCreate }] of items) {
-        if (create) {
-          records2.push(...create);
-        }
-        if (connectOrCreate) {
-          for (const item of connectOrCreate) {
-            if (!connectOrCreated[connectOrCreateI++]) {
-              records2.push(item.create);
-            }
-          }
-        }
-      }
-      created = await internal._queryCreateMany(
-        t.select(...throughPrimaryKeys),
-        records2
-      );
-    } else {
-      created = [];
-    }
-    const allKeys = data;
-    let createI = 0;
-    let connectI = 0;
-    connectOrCreateI = 0;
-    for (let index = 0, len2 = data.length; index < len2; index++) {
-      const item = data[index][1];
-      if (item.create || item.connectOrCreate) {
-        if (item.create) {
-          const len3 = item.create.length;
-          allKeys[index][1] = created.slice(createI, createI + len3);
-          createI += len3;
-        }
-        if (item.connectOrCreate) {
-          const arr = [];
-          allKeys[index][1] = arr;
-          const len3 = item.connectOrCreate.length;
-          for (let i = 0; i < len3; i++) {
-            const item2 = connectOrCreated[connectOrCreateI++];
-            if (item2) {
-              arr.push(item2);
-            } else {
-              arr.push(created[createI++]);
-            }
-          }
-        }
-      }
-      if (item.connect) {
-        const len3 = item.connect.length;
-        allKeys[index][1] = connected.slice(connectI, connectI + len3);
-        connectI += len3;
-      }
-    }
-    const records = [];
-    for (const [selfData, relationKeys] of allKeys) {
-      const obj = {};
-      for (let i = 0; i < len; i++) {
-        obj[foreignKeys[i]] = selfData[primaryKeys[i]];
-      }
-      for (const relationData of relationKeys) {
-        const record = { ...obj };
-        for (let i = 0; i < throughLen; i++) {
-          record[throughForeignKeys[i]] = relationData[throughPrimaryKeys[i]];
-        }
-        records.push(record);
-      }
-    }
-    await joinTableQuery.insertMany(records);
-  };
+const nestedInsert = ({ relatedTableQuery, joinTableQuery, primaryKeys, foreignKeys, throughPrimaryKeys, throughForeignKeys }) => {
+	const len = primaryKeys.length;
+	const throughLen = primaryKeys.length;
+	return (async (_, data) => {
+		const t = relatedTableQuery.clone();
+		const items = [];
+		for (const item of data) if (item[1].connect) items.push(item);
+		let connected;
+		if (items.length) {
+			const queries = [];
+			for (const [, { connect }] of items) for (const item of connect) queries.push((0, pqb_internal._queryFindBy)(t.select(...throughPrimaryKeys), item));
+			connected = await Promise.all(queries);
+		} else connected = [];
+		items.length = 0;
+		for (const item of data) if (item[1].connectOrCreate) items.push(item);
+		let connectOrCreated;
+		if (items.length) {
+			const queries = [];
+			for (const [, { connectOrCreate }] of items) for (const item of connectOrCreate) queries.push((0, pqb_internal._queryFindByOptional)(t.select(...throughPrimaryKeys), item.where));
+			connectOrCreated = await Promise.all(queries);
+		} else connectOrCreated = [];
+		let connectOrCreateI = 0;
+		items.length = 0;
+		for (const item of data) if (item[1].connectOrCreate) {
+			const length = item[1].connectOrCreate.length;
+			connectOrCreateI += length;
+			for (let i = length; i > 0; i--) if (!connectOrCreated[connectOrCreateI - i]) {
+				items.push(item);
+				break;
+			}
+		} else if (item[1].create) items.push(item);
+		connectOrCreateI = 0;
+		let created;
+		if (items.length) {
+			const records = [];
+			for (const [, { create, connectOrCreate }] of items) {
+				if (create) records.push(...create);
+				if (connectOrCreate) {
+					for (const item of connectOrCreate) if (!connectOrCreated[connectOrCreateI++]) records.push(item.create);
+				}
+			}
+			created = await (0, pqb_internal._queryCreateMany)(t.select(...throughPrimaryKeys), records);
+		} else created = [];
+		const allKeys = data;
+		let createI = 0;
+		let connectI = 0;
+		connectOrCreateI = 0;
+		for (let index = 0, len = data.length; index < len; index++) {
+			const item = data[index][1];
+			if (item.create || item.connectOrCreate) {
+				if (item.create) {
+					const len = item.create.length;
+					allKeys[index][1] = created.slice(createI, createI + len);
+					createI += len;
+				}
+				if (item.connectOrCreate) {
+					const arr = [];
+					allKeys[index][1] = arr;
+					const len = item.connectOrCreate.length;
+					for (let i = 0; i < len; i++) {
+						const item = connectOrCreated[connectOrCreateI++];
+						if (item) arr.push(item);
+						else arr.push(created[createI++]);
+					}
+				}
+			}
+			if (item.connect) {
+				const len = item.connect.length;
+				allKeys[index][1] = connected.slice(connectI, connectI + len);
+				connectI += len;
+			}
+		}
+		const records = [];
+		for (const [selfData, relationKeys] of allKeys) {
+			const obj = {};
+			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = selfData[primaryKeys[i]];
+			for (const relationData of relationKeys) {
+				const record = { ...obj };
+				for (let i = 0; i < throughLen; i++) record[throughForeignKeys[i]] = relationData[throughPrimaryKeys[i]];
+				records.push(record);
+			}
+		}
+		await joinTableQuery.insertMany(records);
+	});
 };
 const nestedUpdate = (state) => {
-  const len = state.primaryKeys.length;
-  const throughLen = state.throughPrimaryKeys.length;
-  return async (query, data, params) => {
-    if (params.create) {
-      const idsRows = await internal._queryCreateMany(
-        internal._queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)),
-        params.create
-      );
-      const records = [];
-      for (const item of data) {
-        const obj = {};
-        for (let i = 0; i < len; i++) {
-          obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
-        }
-        for (const ids of idsRows) {
-          const record = { ...obj };
-          for (let i = 0; i < throughLen; i++) {
-            record[state.throughForeignKeys[i]] = ids[i];
-          }
-          records.push(record);
-        }
-      }
-      await state.joinTableQuery.createMany(records);
-    }
-    if (params.update) {
-      await internal._queryUpdate(
-        internal._queryWhere(
-          state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
-            for (let i = 0; i < throughLen; i++) {
-              internal._queryJoinOn(q, [
-                state.throughForeignKeysFull[i],
-                state.throughPrimaryKeysFull[i]
-              ]);
-            }
-            return internal._queryWhere(q, [
-              {
-                IN: {
-                  columns: state.foreignKeysFull,
-                  values: data.map(
-                    (item) => state.primaryKeys.map((key) => item[key])
-                  )
-                }
-              }
-            ]);
-          }),
-          [conditionsToWhereArg(params.update.where)]
-        ),
-        params.update.data
-      );
-    }
-    if (params.add) {
-      const as = query.table;
-      const relatedWheres = internal.toArray(params.add);
-      const joinTableColumns = [
-        ...state.foreignKeys,
-        ...state.throughForeignKeys
-      ];
-      try {
-        const count = await state.joinTableQuery.insertForEachFrom(
-          internal._querySelect(
-            state.relatedTableQuery.whereOneOf(...relatedWheres),
-            [
-              Object.fromEntries([
-                ...state.primaryKeys.map((key, i) => [
-                  state.foreignKeys[i],
-                  as + "." + (state.primaryKeysShape[key].data.name || key)
-                ]),
-                ...state.throughForeignKeys.map((key, i) => [
-                  key,
-                  state.throughPrimaryKeys[i]
-                ])
-              ])
-            ]
-          ).joinData(
-            as,
-            () => Object.fromEntries(
-              state.primaryKeys.map((key) => [
-                key,
-                state.primaryKeysShape[key]
-              ])
-            ),
-            data.map((x) => internal.pick(x, state.primaryKeys))
-          )
-        ).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
-        if (count < data.length * relatedWheres.length) {
-          throw new pqb.OrchidOrmInternalError(
-            query,
-            `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count / data.length}`
-          );
-        }
-      } catch (err) {
-        if (err.code === "42P10") {
-          throw new pqb.OrchidOrmInternalError(
-            query,
-            `"${state.joinTableQuery.table}" must have a primary key or a unique index on columns (${joinTableColumns.join(
-              ", "
-            )}) for this kind of query.`
-          );
-        }
-        throw err;
-      }
-    }
-    if (params.disconnect) {
-      await internal._queryDelete(
-        queryJoinTable(state, data, params.disconnect)
-      );
-    }
-    if (params.delete) {
-      const j = queryJoinTable(state, data, params.delete);
-      const idsRows = await internal._queryDelete(
-        internal._queryRows(internal._querySelect(j, state.throughForeignKeys))
-      );
-      await internal._queryDelete(
-        state.relatedTableQuery.where({
-          IN: {
-            columns: state.throughPrimaryKeys,
-            values: idsRows
-          }
-        })
-      );
-    }
-    if (params.set) {
-      const j = queryJoinTable(state, data);
-      await internal._queryDelete(j);
-      if (Array.isArray(params.set) ? params.set.length : internal.objectHasValues(params.set)) {
-        const idsRows = await internal._queryRows(
-          internal._querySelect(
-            state.relatedTableQuery.where(
-              conditionsToWhereArg(params.set)
-            ),
-            state.throughPrimaryKeys
-          )
-        );
-        await insertToJoinTable(state, j, data, idsRows);
-      }
-    }
-  };
+	const len = state.primaryKeys.length;
+	const throughLen = state.throughPrimaryKeys.length;
+	return (async (query, data, params) => {
+		if (params.create) {
+			const idsRows = await (0, pqb_internal._queryCreateMany)((0, pqb_internal._queryRows)(state.relatedTableQuery.select(...state.throughPrimaryKeys)), params.create);
+			const records = [];
+			for (const item of data) {
+				const obj = {};
+				for (let i = 0; i < len; i++) obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
+				for (const ids of idsRows) {
+					const record = { ...obj };
+					for (let i = 0; i < throughLen; i++) record[state.throughForeignKeys[i]] = ids[i];
+					records.push(record);
+				}
+			}
+			await state.joinTableQuery.createMany(records);
+		}
+		if (params.update) await (0, pqb_internal._queryUpdate)((0, pqb_internal._queryWhere)(state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
+			for (let i = 0; i < throughLen; i++) (0, pqb_internal._queryJoinOn)(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
+			return (0, pqb_internal._queryWhere)(q, [{ IN: {
+				columns: state.foreignKeysFull,
+				values: data.map((item) => state.primaryKeys.map((key) => item[key]))
+			} }]);
+		}), [conditionsToWhereArg(params.update.where)]), params.update.data);
+		/**
+		* Performs `insertForEachFrom` on the joining table,
+		* based on a query to the related table with applied filters of `params.connect`,
+		* joins the main table data using `joinData`.
+		*/
+		if (params.add) {
+			const as = query.table;
+			const relatedWheres = (0, pqb_internal.toArray)(params.add);
+			const joinTableColumns = [...state.foreignKeys, ...state.throughForeignKeys];
+			try {
+				const count = await state.joinTableQuery.insertForEachFrom((0, pqb_internal._querySelect)(state.relatedTableQuery.whereOneOf(...relatedWheres), [Object.fromEntries([...state.primaryKeys.map((key, i) => [state.foreignKeys[i], as + "." + (state.primaryKeysShape[key].data.name || key)]), ...state.throughForeignKeys.map((key, i) => [key, state.throughPrimaryKeys[i]])])]).joinData(as, () => Object.fromEntries(state.primaryKeys.map((key) => [key, state.primaryKeysShape[key]])), data.map((x) => (0, pqb_internal.pick)(x, state.primaryKeys)))).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
+				if (count < data.length * relatedWheres.length) throw new pqb.OrchidOrmInternalError(query, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count / data.length}`);
+			} catch (err) {
+				if (err.code === "42P10") throw new pqb.OrchidOrmInternalError(query, `"${state.joinTableQuery.table}" must have a primary key or a unique index on columns (${joinTableColumns.join(", ")}) for this kind of query.`);
+				throw err;
+			}
+		}
+		if (params.disconnect) await (0, pqb_internal._queryDelete)(queryJoinTable(state, data, params.disconnect));
+		if (params.delete) {
+			const idsRows = await (0, pqb_internal._queryDelete)((0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(queryJoinTable(state, data, params.delete), state.throughForeignKeys)));
+			await (0, pqb_internal._queryDelete)(state.relatedTableQuery.where({ IN: {
+				columns: state.throughPrimaryKeys,
+				values: idsRows
+			} }));
+		}
+		if (params.set) {
+			const j = queryJoinTable(state, data);
+			await (0, pqb_internal._queryDelete)(j);
+			if (Array.isArray(params.set) ? params.set.length : (0, pqb_internal.objectHasValues)(params.set)) await insertToJoinTable(state, j, data, await (0, pqb_internal._queryRows)((0, pqb_internal._querySelect)(state.relatedTableQuery.where(conditionsToWhereArg(params.set)), state.throughPrimaryKeys)));
+		}
+	});
 };
-
 const applyRelations = (qb, tables, result, schema) => {
-  const tableEntries = Object.entries(tables);
-  const delayedRelations = /* @__PURE__ */ new Map();
-  for (const name in tables) {
-    const table = tables[name];
-    if (!("relations" in table) || typeof table.relations !== "object")
-      continue;
-    const dbTable = result[name];
-    for (const relationName in table.relations) {
-      const relation = table.relations[relationName];
-      const otherTableClass = relation.fn();
-      const otherTable = tableEntries.find(
-        (pair) => pair[1] instanceof otherTableClass
-      );
-      if (!otherTable) {
-        throw new Error(
-          `Cannot find table class for class ${otherTableClass.name}`
-        );
-      }
-      const otherTableName = otherTable[0];
-      const otherDbTable = result[otherTableName];
-      if (!otherDbTable)
-        throw new Error(`Cannot find table class by name ${otherTableName}`);
-      const data = {
-        relationName,
-        relation,
-        dbTable,
-        otherDbTable
-      };
-      const options = relation.options;
-      if (typeof options.through === "string" && typeof options.source === "string") {
-        const throughRelation = getThroughRelation(dbTable, options.through);
-        if (!throughRelation) {
-          delayRelation(delayedRelations, dbTable, options.through, data);
-          continue;
-        }
-        const sourceRelation = getSourceRelation(
-          throughRelation,
-          options.source
-        );
-        if (!sourceRelation) {
-          delayRelation(
-            delayedRelations,
-            throughRelation.table,
-            options.source,
-            data
-          );
-          continue;
-        }
-      }
-      applyRelation(table, qb, data, delayedRelations, schema);
-    }
-  }
-  if (delayedRelations.size) {
-    const { value } = delayedRelations.values().next();
-    for (const key in value) {
-      for (const item of value[key]) {
-        const { relation } = item;
-        if (item.dbTable.relations[item.relationName]) continue;
-        const as = item.dbTable.definedAs;
-        let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
-        const table = result[as];
-        const { through, source } = relation.options;
-        const throughRel = table.relations[through];
-        if (through && !throughRel) {
-          message += `: cannot find \`${through}\` relation required by the \`through\` option`;
-        } else if (source && throughRel && !throughRel.table.relations[source]) {
-          message += `: cannot find \`${source}\` relation in \`${throughRel.table.definedAs}\` required by the \`source\` option`;
-        }
-        throw new Error(message);
-      }
-    }
-  }
+	const tableEntries = Object.entries(tables);
+	const delayedRelations = /* @__PURE__ */ new Map();
+	for (const name in tables) {
+		const table = tables[name];
+		if (!("relations" in table) || typeof table.relations !== "object") continue;
+		const dbTable = result[name];
+		for (const relationName in table.relations) {
+			const relation = table.relations[relationName];
+			const otherTableClass = relation.fn();
+			const otherTable = tableEntries.find((pair) => pair[1] instanceof otherTableClass);
+			if (!otherTable) throw new Error(`Cannot find table class for class ${otherTableClass.name}`);
+			const otherTableName = otherTable[0];
+			const otherDbTable = result[otherTableName];
+			if (!otherDbTable) throw new Error(`Cannot find table class by name ${otherTableName}`);
+			const data = {
+				relationName,
+				relation,
+				dbTable,
+				otherDbTable
+			};
+			const options = relation.options;
+			if (typeof options.through === "string" && typeof options.source === "string") {
+				const throughRelation = getThroughRelation(dbTable, options.through);
+				if (!throughRelation) {
+					delayRelation(delayedRelations, dbTable, options.through, data);
+					continue;
+				}
+				if (!getSourceRelation(throughRelation, options.source)) {
+					delayRelation(delayedRelations, throughRelation.table, options.source, data);
+					continue;
+				}
+			}
+			applyRelation(table, qb, data, delayedRelations, schema);
+		}
+	}
+	if (delayedRelations.size) {
+		const { value } = delayedRelations.values().next();
+		for (const key in value) for (const item of value[key]) {
+			const { relation } = item;
+			if (item.dbTable.relations[item.relationName]) continue;
+			const as = item.dbTable.definedAs;
+			let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
+			const table = result[as];
+			const { through, source } = relation.options;
+			const throughRel = table.relations[through];
+			if (through && !throughRel) message += `: cannot find \`${through}\` relation required by the \`through\` option`;
+			else if (source && throughRel && !throughRel.table.relations[source]) message += `: cannot find \`${source}\` relation in \`${throughRel.table.definedAs}\` required by the \`source\` option`;
+			throw new Error(message);
+		}
+	}
 };
 const delayRelation = (delayedRelations, table, relationName, data) => {
-  let tableRelations = delayedRelations.get(table);
-  if (!tableRelations) {
-    tableRelations = {};
-    delayedRelations.set(table, tableRelations);
-  }
-  if (tableRelations[relationName]) {
-    tableRelations[relationName].push(data);
-  } else {
-    tableRelations[relationName] = [data];
-  }
+	let tableRelations = delayedRelations.get(table);
+	if (!tableRelations) {
+		tableRelations = {};
+		delayedRelations.set(table, tableRelations);
+	}
+	if (tableRelations[relationName]) tableRelations[relationName].push(data);
+	else tableRelations[relationName] = [data];
 };
 const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations, schema) => {
-  const baseQuery = Object.create(otherDbTable);
-  baseQuery.baseQuery = baseQuery;
-  const query = baseQuery.as(relationName);
-  const definedAs = query.definedAs;
-  if (!definedAs) {
-    throw new Error(
-      `Table class for table ${query.table} is not attached to db instance`
-    );
-  }
-  const { type } = relation;
-  let data;
-  if (type === "belongsTo") {
-    data = makeBelongsToMethod(table, dbTable, relation, relationName, query);
-  } else if (type === "hasOne") {
-    data = makeHasOneMethod(table, dbTable, relation, relationName, query);
-  } else if (type === "hasMany") {
-    data = makeHasManyMethod(table, dbTable, relation, relationName, query);
-  } else if (type === "hasAndBelongsToMany") {
-    data = makeHasAndBelongsToManyMethod(
-      table,
-      dbTable,
-      qb,
-      relation,
-      relationName,
-      query,
-      schema
-    );
-  } else {
-    throw new Error(`Unknown relation type ${type}`);
-  }
-  if (data.returns === "one") {
-    if (relation.options.required) {
-      internal._queryTake(query);
-    } else {
-      internal._queryTakeOptional(query);
-    }
-    query.q.returnsOne = true;
-  }
-  if (data.virtualColumn) {
-    dbTable.shape[relationName] = dbTable.q.shape[relationName] = data.virtualColumn;
-  }
-  baseQuery.joinQuery = data.joinQuery;
-  const { join: originalJoin } = baseQuery;
-  baseQuery.join = function(...args) {
-    if (args.length) {
-      return originalJoin.apply(this, args);
-    } else {
-      const q = this.clone();
-      q.q.innerJoinLateral = true;
-      return q;
-    }
-  };
-  dbTable.relations[relationName] = {
-    table: otherDbTable,
-    query,
-    queryRelated: data.queryRelated,
-    joinQuery: data.joinQuery,
-    reverseJoin: data.reverseJoin,
-    modifyRelatedQuery: data.modifyRelatedQuery
-  };
-  (dbTable.relationQueries ?? (dbTable.relationQueries = {}))[relationName] = query;
-  const tableRelations = delayedRelations.get(dbTable);
-  if (!tableRelations) return;
-  tableRelations[relationName]?.forEach((data2) => {
-    applyRelation(table, qb, data2, delayedRelations, schema);
-  });
+	const baseQuery = Object.create(otherDbTable);
+	baseQuery.baseQuery = baseQuery;
+	const query = baseQuery.as(relationName);
+	if (!query.definedAs) throw new Error(`Table class for table ${query.table} is not attached to db instance`);
+	const { type } = relation;
+	let data;
+	if (type === "belongsTo") data = makeBelongsToMethod(table, dbTable, relation, relationName, query);
+	else if (type === "hasOne") data = makeHasOneMethod(table, dbTable, relation, relationName, query);
+	else if (type === "hasMany") data = makeHasManyMethod(table, dbTable, relation, relationName, query);
+	else if (type === "hasAndBelongsToMany") data = makeHasAndBelongsToManyMethod(table, dbTable, qb, relation, relationName, query, schema);
+	else throw new Error(`Unknown relation type ${type}`);
+	if (data.returns === "one") {
+		if (relation.options.required) (0, pqb_internal._queryTake)(query);
+		else (0, pqb_internal._queryTakeOptional)(query);
+		query.q.returnsOne = true;
+	}
+	if (data.virtualColumn) dbTable.shape[relationName] = dbTable.q.shape[relationName] = data.virtualColumn;
+	baseQuery.joinQuery = data.joinQuery;
+	const { join: originalJoin } = baseQuery;
+	baseQuery.join = function(...args) {
+		if (args.length) return originalJoin.apply(this, args);
+		else {
+			const q = this.clone();
+			q.q.innerJoinLateral = true;
+			return q;
+		}
+	};
+	dbTable.relations[relationName] = {
+		table: otherDbTable,
+		query,
+		queryRelated: data.queryRelated,
+		joinQuery: data.joinQuery,
+		reverseJoin: data.reverseJoin,
+		modifyRelatedQuery: data.modifyRelatedQuery
+	};
+	(dbTable.relationQueries ??= {})[relationName] = query;
+	const tableRelations = delayedRelations.get(dbTable);
+	if (!tableRelations) return;
+	tableRelations[relationName]?.forEach((data) => {
+		applyRelation(table, qb, data, delayedRelations, schema);
+	});
 };
-
 function transaction(fnOrOptions, fn) {
-  return this.$qb.transaction(
-    fnOrOptions,
-    fn
-  );
+	return this.$qb.transaction(fnOrOptions, fn);
 }
 function ensureTransaction(cb) {
-  return this.$qb.ensureTransaction(cb);
+	return this.$qb.ensureTransaction(cb);
 }
 function isInTransaction() {
-  return this.$qb.isInTransaction();
+	return this.$qb.isInTransaction();
 }
 function afterCommit(hook) {
-  this.$qb.afterCommit(hook);
+	this.$qb.afterCommit(hook);
 }
-
-const orchidORMWithAdapter = ({
-  log,
-  logger,
-  autoPreparedStatements,
-  noPrimaryKey = "error",
-  schema,
-  ...options
-}, tables) => {
-  const commonOptions = {
-    log,
-    logger,
-    autoPreparedStatements,
-    noPrimaryKey
-  };
-  let adapter;
-  let asyncStorage;
-  let qb;
-  if ("db" in options) {
-    adapter = options.db.q.adapter;
-    asyncStorage = options.db.internal.asyncStorage;
-    qb = options.db.qb;
-  } else {
-    adapter = options.adapter;
-    asyncStorage = new node_async_hooks.AsyncLocalStorage();
-    qb = internal._initQueryBuilder(
-      adapter,
-      internal.makeColumnTypes(internal.defaultSchemaConfig),
-      asyncStorage,
-      commonOptions,
-      options
-    );
-  }
-  const result = {
-    $transaction: transaction,
-    $ensureTransaction: ensureTransaction,
-    $isInTransaction: isInTransaction,
-    $afterCommit: afterCommit,
-    $adapterNotInTransaction: adapter,
-    $getAdapter,
-    $qb: qb,
-    get $query() {
-      return qb.query;
-    },
-    $queryArrays: (...args) => qb.queryArrays(...args),
-    $with: qb.with.bind(qb),
-    $withRecursive: qb.withRecursive.bind(qb),
-    $withSql: qb.withSql.bind(qb),
-    $from: qb.from.bind(qb),
-    $close: adapter.close.bind(adapter),
-    $withOptions: qb.withOptions.bind(qb)
-  };
-  const tableInstances = {};
-  for (const key in tables) {
-    if (key[0] === "$") {
-      throw new Error(`Table class name must not start with $`);
-    }
-    const tableClass = tables[key];
-    const table = tableClass.instance();
-    tableInstances[key] = table;
-    const options2 = {
-      ...commonOptions,
-      schema: table.schema || schema,
-      language: table.language,
-      scopes: table.scopes,
-      softDelete: table.softDelete,
-      snakeCase: table.snakeCase,
-      comment: table.comment,
-      noPrimaryKey: table.noPrimaryKey ? "ignore" : void 0,
-      computed: table.computed,
-      nowSQL: tableClass.nowSQL
-    };
-    const dbTable = new pqb.Db(
-      adapter,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      qb,
-      table.table,
-      table.columns.shape,
-      table.types,
-      asyncStorage,
-      options2,
-      table.constructor.prototype.columns?.data ?? {}
-    );
-    dbTable.definedAs = key;
-    dbTable.db = result;
-    dbTable.filePath = table.filePath;
-    dbTable.name = table.constructor.name;
-    result[key] = dbTable;
-  }
-  applyRelations(qb, tableInstances, result, schema);
-  for (const key in tables) {
-    const table = tableInstances[key];
-    if (table.init) {
-      table.init(result);
-      Object.assign(result[key].baseQuery.q, table.q);
-    }
-  }
-  return result;
+const orchidORMWithAdapter = ({ log, logger, autoPreparedStatements, noPrimaryKey = "error", schema, ...options }, tables) => {
+	const commonOptions = {
+		log,
+		logger,
+		autoPreparedStatements,
+		noPrimaryKey
+	};
+	let adapter;
+	let asyncStorage;
+	let qb;
+	if ("db" in options) {
+		adapter = options.db.q.adapter;
+		asyncStorage = options.db.internal.asyncStorage;
+		qb = options.db.qb;
+	} else {
+		adapter = options.adapter;
+		asyncStorage = new node_async_hooks.AsyncLocalStorage();
+		qb = (0, pqb_internal._initQueryBuilder)(adapter, (0, pqb_internal.makeColumnTypes)(pqb_internal.defaultSchemaConfig), asyncStorage, commonOptions, options);
+	}
+	const result = {
+		$transaction: transaction,
+		$ensureTransaction: ensureTransaction,
+		$isInTransaction: isInTransaction,
+		$afterCommit: afterCommit,
+		$adapterNotInTransaction: adapter,
+		$getAdapter,
+		$qb: qb,
+		get $query() {
+			return qb.query;
+		},
+		$queryArrays: ((...args) => qb.queryArrays(...args)),
+		$with: qb.with.bind(qb),
+		$withRecursive: qb.withRecursive.bind(qb),
+		$withSql: qb.withSql.bind(qb),
+		$from: qb.from.bind(qb),
+		$close: adapter.close.bind(adapter),
+		$withOptions: qb.withOptions.bind(qb)
+	};
+	const tableInstances = {};
+	for (const key in tables) {
+		if (key[0] === "$") throw new Error(`Table class name must not start with $`);
+		const tableClass = tables[key];
+		const table = tableClass.instance();
+		tableInstances[key] = table;
+		const options = {
+			...commonOptions,
+			schema: table.schema || schema,
+			language: table.language,
+			scopes: table.scopes,
+			softDelete: table.softDelete,
+			snakeCase: table.snakeCase,
+			comment: table.comment,
+			noPrimaryKey: table.noPrimaryKey ? "ignore" : void 0,
+			computed: table.computed,
+			nowSQL: tableClass.nowSQL
+		};
+		const dbTable = new pqb.Db(adapter, qb, table.table, table.columns.shape, table.types, asyncStorage, options, table.constructor.prototype.columns?.data ?? {});
+		dbTable.definedAs = key;
+		dbTable.db = result;
+		dbTable.filePath = table.filePath;
+		dbTable.name = table.constructor.name;
+		result[key] = dbTable;
+	}
+	applyRelations(qb, tableInstances, result, schema);
+	for (const key in tables) {
+		const table = tableInstances[key];
+		if (table.init) {
+			table.init(result);
+			Object.assign(result[key].baseQuery.q, table.q);
+		}
+	}
+	return result;
 };
 function $getAdapter() {
-  return this.$qb.$getAdapter();
+	return this.$qb.$getAdapter();
 }
-
 const createRepo = (table, methods) => {
-  const queryMethods = {
-    ...methods.queryMethods,
-    ...methods.queryOneMethods,
-    ...methods.queryWithWhereMethods,
-    ...methods.queryOneWithWhereMethods
-  };
-  const plainMethods = methods.methods;
-  const repo = (q2) => {
-    const proto = Object.create(q2.baseQuery);
-    proto.baseQuery = proto;
-    const result = Object.create(proto);
-    result.q = internal.getClonedQueryData(q2.q);
-    if (plainMethods) {
-      Object.assign(proto.baseQuery, plainMethods);
-    }
-    for (const key in queryMethods) {
-      const method = queryMethods[key];
-      proto.baseQuery[key] = function(...args) {
-        return method(this, ...args);
-      };
-    }
-    return result;
-  };
-  const q = repo(table);
-  return new Proxy(repo, {
-    get(_, key) {
-      return q[key];
-    }
-  });
+	const queryMethods = {
+		...methods.queryMethods,
+		...methods.queryOneMethods,
+		...methods.queryWithWhereMethods,
+		...methods.queryOneWithWhereMethods
+	};
+	const plainMethods = methods.methods;
+	const repo = (q) => {
+		const proto = Object.create(q.baseQuery);
+		proto.baseQuery = proto;
+		const result = Object.create(proto);
+		result.q = (0, pqb_internal.getClonedQueryData)(q.q);
+		if (plainMethods) Object.assign(proto.baseQuery, plainMethods);
+		for (const key in queryMethods) {
+			const method = queryMethods[key];
+			proto.baseQuery[key] = function(...args) {
+				return method(this, ...args);
+			};
+		}
+		return result;
+	};
+	const q = repo(table);
+	return new Proxy(repo, { get(_, key) {
+		return q[key];
+	} });
 };
-
 exports.createBaseTable = createBaseTable;
 exports.createRepo = createRepo;
 exports.orchidORMWithAdapter = orchidORMWithAdapter;
-Object.keys(pqb).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return pqb[k]; }
-  });
+Object.keys(pqb).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return pqb[k];
+		}
+	});
 });
-//# sourceMappingURL=index.js.map
+
+//# sourceMappingURL=index.js.map