orchid-orm 1.64.10 → 1.65.0

package/dist/index.js

@@ -1,10 +1,11 @@
 'use strict';
 
-var pqb = require('pqb');
+var internal = require('pqb/internal');
 var node_async_hooks = require('node:async_hooks');
+var pqb = require('pqb');
 
 function createBaseTable({
-  schemaConfig = pqb.defaultSchemaConfig,
+  schemaConfig = internal.defaultSchemaConfig,
   columnTypes: columnTypesArg,
   snakeCase,
   filePath: filePathArg,
@@ -14,12 +15,12 @@ function createBaseTable({
   autoForeignKeys
 } = {}) {
   var _a;
-  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(pqb.makeColumnTypes(schemaConfig)) : columnTypesArg || pqb.makeColumnTypes(schemaConfig);
-  const filePathOrStack = filePathArg || pqb.getStackTrace();
+  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(internal.makeColumnTypes(schemaConfig)) : columnTypesArg || internal.makeColumnTypes(schemaConfig);
+  const filePathOrStack = filePathArg || internal.getStackTrace();
   let filePath;
   const defaultColumns = {
-    shape: pqb.emptyObject,
-    data: pqb.emptyArray
+    shape: internal.emptyObject,
+    data: internal.emptyArray
   };
   const instances = /* @__PURE__ */ new WeakMap();
   const base = (_a = class {
@@ -59,7 +60,7 @@ function createBaseTable({
       if (typeof filePathOrStack === "string") {
         return filePath = filePathOrStack;
       }
-      filePath = pqb.getCallerFilePath(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.`
@@ -80,21 +81,21 @@ function createBaseTable({
       if (this.filePath) return this.filePath;
       if (typeof filePathOrStack === "string")
         return this.filePath = filePathOrStack;
-      const filePath2 = pqb.getCallerFilePath(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[pqb.snakeCaseKey] = this.snakeCase;
-      const shape = pqb.getColumnTypes(columnTypes, fn, nowSQL, this.language);
-      const tableData = pqb.parseTableData(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 = pqb.toSnakeCase(key);
+          const snakeName = internal.toSnakeCase(key);
           if (snakeName !== key) {
             column.data.name = snakeName;
           }
@@ -139,8 +140,8 @@ function createBaseTable({
         options
       };
     }
-  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a.columnTypes = columnTypes, _a.sql = pqb._createDbSqlMethod(columnTypes), _a);
-  pqb.applyMixins(base, [pqb.QueryHooks]);
+  }, _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.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
@@ -168,7 +169,7 @@ const hasRelationHandleCreate = (q, ctx, items, rowIndexes, key, primaryKeys, ne
     }
     const relationData = [values];
     store.hasRelation[key] = relationData;
-    pqb._queryHookAfterCreate(
+    internal._queryHookAfterCreate(
       q,
       primaryKeys,
       (rows, q2) => nestedInsert(
@@ -186,7 +187,7 @@ const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
   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;
-  pqb._queryHookAfterUpdate(q, primaryKeys, (rows, q2) => {
+  internal._queryHookAfterUpdate(q, primaryKeys, (rows, q2) => {
     return nestedUpdate(
       q2,
       rows,
@@ -201,7 +202,7 @@ function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelat
       baseQuery
     ),
     () => {
-      const as = pqb.getQueryAs(joiningQuery);
+      const as = internal.getQueryAs(joiningQuery);
       return sourceRelation.joinQuery(
         sourceRelation.query.as(as),
         throughRelation.query
@@ -210,11 +211,11 @@ function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelat
   );
 }
 function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len) {
-  const baseAs = pqb.getQueryAs(baseQuery);
+  const baseAs = internal.getQueryAs(baseQuery);
   const q = joiningQuery.clone();
-  pqb.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
+  internal.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
   for (let i = 0; i < len; i++) {
-    pqb.pushQueryOnForOuter(
+    internal.pushQueryOnForOuter(
       q,
       baseQuery,
       joiningQuery,
@@ -230,7 +231,7 @@ const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, opti
   let fkeyOptions = options.foreignKey !== void 0 ? options.foreignKey : tableConfig.autoForeignKeys;
   if (!fkeyOptions) return;
   if (fkeyOptions === true) {
-    fkeyOptions = tableConfig.autoForeignKeys || pqb.emptyObject;
+    fkeyOptions = tableConfig.autoForeignKeys || internal.emptyObject;
   }
   if (foreignKeys.length === 1) {
     const column = from.shape[foreignKeys[0]];
@@ -303,11 +304,11 @@ const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, b
   if (jq.q.returnType !== "value" && jq.q.returnType !== "valueOrThrow") {
     let tablePrefix;
     if (jq.q.order) {
-      const prefix = tablePrefix = pqb.getQueryAs(jq) + ".";
+      const prefix = tablePrefix = internal.getQueryAs(jq) + ".";
       useWhereExist = jq.q.order.every((o) => {
         if (typeof o === "string") {
           return isOwnColumn(prefix, o);
-        } else if (pqb.isExpression(o)) {
+        } else if (internal.isExpression(o)) {
           return false;
         } else {
           for (const key in o) {
@@ -320,11 +321,11 @@ const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, b
       });
     }
     if (useWhereExist && jq.q.select) {
-      const prefix = tablePrefix || pqb.getQueryAs(jq) + ".";
+      const prefix = tablePrefix || internal.getQueryAs(jq) + ".";
       useWhereExist = jq.q.select.every((s) => {
         if (typeof s === "string") {
           return isOwnColumn(prefix, s);
-        } else if (pqb.isExpression(s)) {
+        } else if (internal.isExpression(s)) {
           return false;
         } else if (!s) {
           return false;
@@ -362,7 +363,7 @@ const selectRowNumber = (result, relPKeys) => {
   const hookSelect = result.q.hookSelect = new Map(
     result.q.hookSelect && [...result.q.hookSelect]
   );
-  const as = `"${pqb.getQueryAs(result)}"`;
+  const as = `"${internal.getQueryAs(result)}"`;
   const partitionColumns = relPKeys.map(
     (key) => `${as}."${result.shape[key]?.data.name || key}"`
   );
@@ -377,9 +378,9 @@ const selectRowNumber = (result, relPKeys) => {
 const combineOrdering = (result, joined) => {
   const { order } = joined.q;
   if (order) {
-    const as = pqb.getQueryAs(joined);
+    const as = internal.getQueryAs(joined);
     const add = order.map(
-      (o) => typeof o === "string" ? `${as}.${o}` : pqb.isExpression(o) ? o : Object.fromEntries(
+      (o) => typeof o === "string" ? `${as}.${o}` : internal.isExpression(o) ? o : Object.fromEntries(
         Object.entries(o).map(([key, value]) => [`${as}.${key}`, value])
       )
     );
@@ -388,18 +389,18 @@ const combineOrdering = (result, joined) => {
   }
 };
 const wrapQuery = (joiningQuery, result, item) => {
-  const baseOuterQuery = pqb.cloneQueryBaseUnscoped(joiningQuery);
+  const baseOuterQuery = internal.cloneQueryBaseUnscoped(joiningQuery);
   const outer = baseOuterQuery.clone();
-  outer.q.and = [new pqb.DynamicRawSQL(() => new pqb.RawSql(`${item.as || "r"} = 1`))];
+  outer.q.and = [new internal.DynamicRawSQL(() => new internal.RawSql(`${item.as || "r"} = 1`))];
   outer.q.useFromLimitOffset = true;
-  outer.shape = pqb.getShapeFromSelect(result, 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);
 };
 
-class BelongsToVirtualColumn extends pqb.VirtualColumn {
+class BelongsToVirtualColumn extends internal.VirtualColumn {
   constructor(schema, key, state) {
     super(schema);
     this.key = key;
@@ -425,7 +426,7 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
         nestedCreateItem.values.push(value[kind]);
         if (kind !== "connect") {
           for (const key2 of foreignKeys) {
-            item[key2] = new pqb.RawSql("");
+            item[key2] = new internal.RawSql("");
           }
         }
       }
@@ -441,7 +442,7 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
     const { create, connect, connectOrCreate } = nestedCreateItems;
     if (create) {
       const selectPKeys = query.select(...primaryKeys);
-      pqb._prependWith(
+      internal._prependWith(
         q,
         (as) => {
           const count = create.items.length;
@@ -457,15 +458,15 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
             });
           });
         },
-        pqb._queryInsertMany(selectPKeys, create.values)
+        internal._queryInsertMany(selectPKeys, create.values)
       );
     }
     if (connect) {
       connect.values.forEach((value, itemI) => {
-        const as = pqb.getFreeAlias(q.q.withShapes, "q");
-        pqb._prependWith(q, as, query.select(...primaryKeys).findBy(value));
+        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 pqb.RawSql(
+          connect.items[itemI][foreignKey] = new internal.RawSql(
             selectCteColumnMustExistSql(i, as, primaryKeys[i])
           );
         });
@@ -479,11 +480,11 @@ class BelongsToVirtualColumn extends pqb.VirtualColumn {
           foreignKeys
         );
         const selectPKeys = query.select(...primaryKeys);
-        pqb._prependWith(
+        internal._prependWith(
           q,
           asFn,
-          pqb._orCreate(
-            pqb._queryWhere(selectPKeys, [value.where]),
+          internal._orCreate(
+            internal._queryWhere(selectPKeys, [value.where]),
             value.create
           )
         );
@@ -501,8 +502,8 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
   const foreignKeys = relation.options.columns;
   const { on } = relation.options;
   if (on) {
-    pqb._queryWhere(query, [on]);
-    pqb._queryDefaults(query, on);
+    internal._queryWhere(query, [on]);
+    internal._queryDefaults(query, on);
   }
   const len = primaryKeys.length;
   const state = { query, primaryKeys, foreignKeys, len, on };
@@ -515,11 +516,11 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
     relation.options
   );
   const join = (baseQuery, joiningQuery, primaryKeys2, foreignKeys2) => {
-    const baseAs = pqb.getQueryAs(baseQuery);
+    const baseAs = internal.getQueryAs(baseQuery);
     const q = joiningQuery.clone();
-    pqb.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
+    internal.setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.shape);
     for (let i = 0; i < len; i++) {
-      pqb.pushQueryOnForOuter(
+      internal.pushQueryOnForOuter(
         q,
         baseQuery,
         joiningQuery,
@@ -547,12 +548,12 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
       return query.where(obj);
     },
     virtualColumn: new BelongsToVirtualColumn(
-      pqb.defaultSchemaConfig,
+      internal.defaultSchemaConfig,
       relationName,
       state
     ),
     joinQuery: joinQueryChainHOF(
-      pqb.getPrimaryKeys(query),
+      internal.getPrimaryKeys(query),
       reverseJoin,
       (joiningQuery, baseQuery) => join(
         baseQuery,
@@ -567,29 +568,29 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
 const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
   return (self, update, params) => {
     if (params.create) {
-      const createQuery = pqb._querySelect(
-        pqb._queryCreate(query.clone(), params.create),
+      const createQuery = internal._querySelect(
+        internal._queryCreate(query.clone(), params.create),
         primaryKeys
       );
       const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
-      pqb._prependWith(self, asFn, createQuery);
+      internal._prependWith(self, asFn, createQuery);
     } else if (params.update) {
       let appendedAs;
-      pqb._hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
+      internal._hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
         selectIdsSql._sql = selectCteColumnsSql(
           appendedAs,
           aliasedForeignKeys
         );
       });
-      const selectIdsSql = new pqb.RawSql("");
-      const updateQuery = pqb._queryUpdate(
-        pqb._queryWhereIn(query.clone(), true, primaryKeys, selectIdsSql),
+      const selectIdsSql = new internal.RawSql("");
+      const updateQuery = internal._queryUpdate(
+        internal._queryWhereIn(query.clone(), true, primaryKeys, selectIdsSql),
         params.update
       );
       updateQuery.q.returnType = "value";
-      pqb._appendQuery(self, updateQuery, (as) => appendedAs = as);
+      internal._appendQuery(self, updateQuery, (as) => appendedAs = as);
     } else if (params.upsert) {
-      if (pqb.isQueryReturnsAll(self)) {
+      if (internal.isQueryReturnsAll(self)) {
         throw new Error("`upsert` option is not allowed in a batch update");
       }
       const { relQuery } = relWithSelectIds(
@@ -598,17 +599,17 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
         primaryKeys,
         foreignKeys
       );
-      const upsertQuery = pqb._querySelect(
-        pqb._queryUpsert(
+      const upsertQuery = internal._querySelect(
+        internal._queryUpsert(
           relQuery,
           params.upsert
         ),
         primaryKeys
       );
       const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
-      pqb._prependWith(self, asFn, upsertQuery);
+      internal._prependWith(self, asFn, upsertQuery);
     } else if (params.delete) {
-      pqb._hookSelectColumns(self, foreignKeys, pqb.noop);
+      internal._hookSelectColumns(self, foreignKeys, internal.noop);
       disconnect(update, foreignKeys);
       const { selectIdsSql, relQuery } = relWithSelectIds(
         self,
@@ -617,10 +618,10 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
         foreignKeys
       );
       self.q.and = self.q.or = void 0;
-      pqb._queryWhereIn(self, true, foreignKeys, selectIdsSql);
-      const deleteQuery = pqb._queryDelete(relQuery);
+      internal._queryWhereIn(self, true, foreignKeys, selectIdsSql);
+      const deleteQuery = internal._queryDelete(relQuery);
       deleteQuery.q.returnType = "value";
-      pqb._appendQuery(self, deleteQuery, pqb.noop);
+      internal._appendQuery(self, deleteQuery, internal.noop);
     } else if (params.disconnect) {
       disconnect(update, foreignKeys);
     } else if (params.set) {
@@ -642,10 +643,10 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
           loadForeignKeys,
           true
         );
-        pqb._prependWith(
+        internal._prependWith(
           self,
           asFn,
-          pqb._queryFindBy(query.select(...loadPrimaryKeys), params.set)
+          internal._queryFindBy(query.select(...loadPrimaryKeys), params.set)
         );
       }
     }
@@ -658,8 +659,8 @@ const disconnect = (update, foreignKeys) => {
 };
 const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
   const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
-  const selectIdsSql = new pqb.RawSql("");
-  pqb._prependWith(
+  const selectIdsSql = new internal.RawSql("");
+  internal._prependWith(
     self,
     (as) => {
       selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
@@ -668,12 +669,12 @@ const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
   );
   return {
     selectIdsSql,
-    relQuery: pqb._queryWhereIn(rel.clone(), true, primaryKeys, selectIdsSql)
+    relQuery: internal._queryWhereIn(rel.clone(), true, primaryKeys, selectIdsSql)
   };
 };
 const makeSelectIdsQuery = (self, foreignKeys) => {
   const selectIdsQuery = self.baseQuery.clone();
-  selectIdsQuery.q.distinct = pqb.emptyArray;
+  selectIdsQuery.q.distinct = internal.emptyArray;
   selectIdsQuery.q.select = foreignKeys;
   selectIdsQuery.q.and = self.q.and;
   selectIdsQuery.q.or = self.q.or;
@@ -681,7 +682,7 @@ const makeSelectIdsQuery = (self, foreignKeys) => {
 };
 const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
   for (const key of foreignKeys) {
-    record[key] = new pqb.RawSql("");
+    record[key] = new internal.RawSql("");
   }
   return (as) => {
     foreignKeys.forEach(
@@ -705,7 +706,7 @@ const selectCteColumnMustExistSql = (i, cteAs, column) => {
   return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
 };
 
-class HasOneVirtualColumn extends pqb.VirtualColumn {
+class HasOneVirtualColumn extends internal.VirtualColumn {
   constructor(schema, key, state) {
     super(schema);
     this.key = key;
@@ -734,7 +735,7 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
           nestedCreateItem.values.push(value[kind]);
           const data = value.create ? { ...value.create } : {};
           for (const key of foreignKeys) {
-            data[key] = new pqb.RawSql("");
+            data[key] = new internal.RawSql("");
           }
           nestedCreateItem.items.push(data);
         }
@@ -745,7 +746,7 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
       let createAs;
       let connectAs;
       let connectOrCreateAs;
-      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
         foreignKeys.forEach((key, keyI) => {
           const primaryKey = aliasedPrimaryKeys[keyI];
           if (create && createAs) {
@@ -782,29 +783,29 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
       });
       const { create, connect, connectOrCreate } = nestedCreateItems;
       if (create) {
-        const query = pqb._queryInsertMany(pqb._clone(rel), create.items);
-        pqb._appendQuery(self, query, (as) => createAs = as);
+        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 = pqb._queryUpdateOrThrow(
+          const query = internal._queryUpdateOrThrow(
             rel.where(value),
             connect.items[i]
           );
           query.q.ensureCount = 1;
-          pqb._appendQuery(self, query, (as) => connectAs = as);
+          internal._appendQuery(self, query, (as) => connectAs = as);
         });
       }
       if (connectOrCreate) {
         connectOrCreate.values.forEach((value, i) => {
-          const query = pqb._queryUpsert(rel.where(value.where), {
+          const query = internal._queryUpsert(rel.where(value.where), {
             update: connectOrCreate.items[i],
             create: {
               ...value.create,
               ...connectOrCreate.items[i]
             }
           });
-          pqb._appendQuery(self, query, (as) => connectOrCreateAs = as);
+          internal._appendQuery(self, query, (as) => connectOrCreateAs = as);
         });
       }
     } else {
@@ -821,14 +822,14 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
   }
   update(self, set) {
     const params = set[this.key];
-    if ((params.set || params.create || params.upsert) && pqb.isQueryReturnsAll(self)) {
+    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;
-      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
         selectIdsSql._sql = selectCteColumnsSql(
           appendedAs,
           aliasedPrimaryKeys
@@ -842,9 +843,9 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
           });
         }
       });
-      const selectIdsSql = new pqb.RawSql("");
-      const existingRelQuery = pqb._queryWhereIn(
-        pqb._clone(relQuery),
+      const selectIdsSql = new internal.RawSql("");
+      const existingRelQuery = internal._queryWhereIn(
+        internal._clone(relQuery),
         true,
         foreignKeys,
         selectIdsSql
@@ -853,37 +854,37 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
       if (params.create || params.set || params.upsert) {
         setIds = {};
         foreignKeys.forEach((foreignKey) => {
-          setIds[foreignKey] = new pqb.RawSql("");
+          setIds[foreignKey] = new internal.RawSql("");
         });
       }
-      const nullifyOrDeleteQuery = params.update ? pqb._queryUpdate(existingRelQuery, params.update) : params.upsert ? pqb._queryUpsert(existingRelQuery, {
+      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 ? pqb._queryDelete(existingRelQuery) : pqb._queryUpdate(existingRelQuery, this.setNulls);
+      }) : params.delete ? internal._queryDelete(existingRelQuery) : internal._queryUpdate(existingRelQuery, this.setNulls);
       nullifyOrDeleteQuery.q.returnType = "void";
-      pqb._appendQuery(self, nullifyOrDeleteQuery, (as) => appendedAs = as);
+      internal._appendQuery(self, nullifyOrDeleteQuery, (as) => appendedAs = as);
       if (params.create) {
-        const createQuery = pqb._queryInsert(pqb._clone(relQuery), {
+        const createQuery = internal._queryInsert(internal._clone(relQuery), {
           ...params.create,
           ...setIds
         });
-        pqb._appendQuery(self, createQuery, pqb.noop);
+        internal._appendQuery(self, createQuery, internal.noop);
       } else if (params.set) {
-        const setQuery = pqb._queryUpdate(
-          pqb._queryWhere(pqb._clone(relQuery), [params.set]),
+        const setQuery = internal._queryUpdate(
+          internal._queryWhere(internal._clone(relQuery), [params.set]),
           setIds
         );
         setQuery.q.returnType = "void";
-        pqb._appendQuery(self, setQuery, pqb.noop);
+        internal._appendQuery(self, setQuery, internal.noop);
       }
     }
   }
 }
 const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
-  const relPKeys = pqb.getPrimaryKeys(query);
+  const relPKeys = internal.getPrimaryKeys(query);
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
@@ -929,8 +930,8 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
   const foreignKeys = relation.options.references;
   const { on } = relation.options;
   if (on) {
-    pqb._queryWhere(query, [on]);
-    pqb._queryDefaults(query, on);
+    internal._queryWhere(query, [on]);
+    internal._queryDefaults(query, on);
   }
   addAutoForeignKey(
     tableConfig,
@@ -963,10 +964,10 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return pqb._queryDefaults(query.where(values), { ...on, ...values });
+      return internal._queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasOneVirtualColumn(
-      pqb.defaultSchemaConfig,
+      internal.defaultSchemaConfig,
       relationName,
       state
     ),
@@ -987,7 +988,7 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
         const baseQuery = query2.clone();
         baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
-        q.insertFrom = pqb.prepareSubQueryForSql(q, baseQuery);
+        q.insertFrom = internal.prepareSubQueryForSql(q, baseQuery);
         q.values = [];
       };
     }
@@ -1010,10 +1011,10 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
         primaryKeys.forEach((primaryKey, i2) => {
           data2[foreignKeys[i2]] = selfData[primaryKey];
         });
-        items[i] = "connect" in item ? pqb._queryUpdateOrThrow(
+        items[i] = "connect" in item ? internal._queryUpdateOrThrow(
           t.where(item.connect),
           data2
-        ) : pqb._queryUpdate(
+        ) : internal._queryUpdate(
           t.where(
             item.connectOrCreate.where
           ),
@@ -1051,7 +1052,7 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
   };
 };
 
-class HasManyVirtualColumn extends pqb.VirtualColumn {
+class HasManyVirtualColumn extends internal.VirtualColumn {
   constructor(schema, key, state) {
     super(schema);
     this.key = key;
@@ -1075,7 +1076,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
           const data = value.create.map((obj) => {
             const data2 = { ...obj };
             for (const key of foreignKeys) {
-              data2[key] = new pqb.RawSql("");
+              data2[key] = new internal.RawSql("");
             }
             return data2;
           });
@@ -1092,7 +1093,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
             nestedCreateItem.values.push(value[kind]);
             const data = {};
             for (const key of foreignKeys) {
-              data[key] = new pqb.RawSql("");
+              data[key] = new internal.RawSql("");
             }
             nestedCreateItem.items.push(data);
           }
@@ -1104,7 +1105,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
       let createAs;
       let connectAs;
       let connectOrCreateAs;
-      pqb._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
+      internal._hookSelectColumns(self, primaryKeys, (aliasedPrimaryKeys) => {
         foreignKeys.forEach((key, keyI) => {
           const primaryKey = aliasedPrimaryKeys[keyI];
           if (create && createAs) {
@@ -1144,34 +1145,34 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
       });
       const { create, connect, connectOrCreate } = nestedCreateItems;
       if (create) {
-        const query = pqb._queryInsertMany(
-          pqb._clone(rel),
+        const query = internal._queryInsertMany(
+          internal._clone(rel),
           create.items.flat()
         );
-        pqb._appendQuery(self, query, (as) => createAs = as);
+        internal._appendQuery(self, query, (as) => createAs = as);
       }
       if (connect) {
         connect.values.forEach((value, i) => {
-          const query = pqb._queryUpdateOrThrow(
+          const query = internal._queryUpdateOrThrow(
             rel.whereOneOf(...value),
             connect.items[i]
           );
           query.q.ensureCount = value.length;
-          pqb._appendQuery(self, query, (as) => connectAs = as);
+          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 = pqb._queryUpsert(rel.where(value.where), {
+            const query = internal._queryUpsert(rel.where(value.where), {
               update: foreignKeyValues,
               create: {
                 ...value.create,
                 ...foreignKeyValues
               }
             });
-            pqb._appendQuery(self, query, (as) => connectOrCreateAs = as);
+            internal._appendQuery(self, query, (as) => connectOrCreateAs = as);
           }
         });
       }
@@ -1189,7 +1190,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
   }
   update(q, set) {
     const params = set[this.key];
-    if ((params.set || params.create) && pqb.isQueryReturnsAll(q)) {
+    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`);
     }
@@ -1203,7 +1204,7 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
   }
 }
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
-  const relPKeys = pqb.getPrimaryKeys(query);
+  const relPKeys = internal.getPrimaryKeys(query);
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
@@ -1252,8 +1253,8 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
   const foreignKeys = relation.options.references;
   const { on } = relation.options;
   if (on) {
-    pqb._queryWhere(query, [on]);
-    pqb._queryDefaults(query, on);
+    internal._queryWhere(query, [on]);
+    internal._queryDefaults(query, on);
   }
   addAutoForeignKey(
     tableConfig,
@@ -1286,10 +1287,10 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return pqb._queryDefaults(query.where(values), { ...on, ...values });
+      return internal._queryDefaults(query.where(values), { ...on, ...values });
     },
     virtualColumn: new HasManyVirtualColumn(
-      pqb.defaultSchemaConfig,
+      internal.defaultSchemaConfig,
       relationName,
       state
     ),
@@ -1310,7 +1311,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
         const baseQuery = query2.clone();
         baseQuery.q.select = fromQuerySelect;
         const q = relationQuery.q;
-        q.insertFrom = pqb.prepareSubQueryForSql(q, baseQuery);
+        q.insertFrom = internal.prepareSubQueryForSql(q, baseQuery);
         q.values = [];
       };
     }
@@ -1322,7 +1323,7 @@ const getWhereForNestedUpdate = (t, data, params, primaryKeys, foreignKeys) => {
       columns: foreignKeys,
       values: data.map((item) => primaryKeys.map((key) => item[key]))
     },
-    OR: params ? pqb.toArray(params) : void 0
+    OR: params ? internal.toArray(params) : void 0
   });
 };
 const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
@@ -1342,7 +1343,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
         for (let i2 = 0; i2 < len2; i2++) {
           obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
         }
-        items[i] = pqb._queryUpdateOrThrow(
+        items[i] = internal._queryUpdateOrThrow(
           t.where({ OR: connect }),
           obj
         );
@@ -1366,7 +1367,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
             obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
           }
           queries.push(
-            pqb._queryUpdate(
+            internal._queryUpdate(
               t.where(item.where),
               obj
             )
@@ -1420,7 +1421,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
           }
         }
       }
-      await pqb._queryCreateMany(t, records);
+      await internal._queryCreateMany(t, records);
     }
   };
 };
@@ -1442,7 +1443,7 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
     }
     if (params.add) {
       if (data.length > 1) {
-        throw new pqb.OrchidOrmInternalError(
+        throw new internal.OrchidOrmInternalError(
           query,
           "`connect` is not available when updating multiple records, it is only applicable for a single record update"
         );
@@ -1451,13 +1452,13 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
       for (let i = 0; i < len; i++) {
         obj[foreignKeys[i]] = data[0][primaryKeys[i]];
       }
-      const relatedWheres = pqb.toArray(params.add);
-      const count = await pqb._queryUpdate(
+      const relatedWheres = internal.toArray(params.add);
+      const count = await internal._queryUpdate(
         t.where({ OR: relatedWheres }),
         obj
       );
       if (count < relatedWheres.length) {
-        throw new pqb.OrchidOrmInternalError(
+        throw new internal.OrchidOrmInternalError(
           query,
           `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`
         );
@@ -1468,7 +1469,7 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
       for (const foreignKey of foreignKeys) {
         obj[foreignKey] = null;
       }
-      const setConditions = params.set && (Array.isArray(params.set) ? params.set.length : pqb.objectHasValues(params.set)) && (Array.isArray(params.set) ? {
+      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(
@@ -1481,13 +1482,13 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
       if (setConditions) {
         queryToDisconnect = queryToDisconnect.whereNot(setConditions);
       }
-      await pqb._queryUpdate(queryToDisconnect, obj);
+      await internal._queryUpdate(queryToDisconnect, obj);
       if (setConditions) {
         const obj2 = {};
         for (let i = 0; i < len; i++) {
           obj2[foreignKeys[i]] = data[0][primaryKeys[i]];
         }
-        await pqb._queryUpdate(
+        await internal._queryUpdate(
           t.where(setConditions),
           obj2
         );
@@ -1502,15 +1503,15 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
         foreignKeys
       );
       if (params.delete) {
-        await pqb._queryDelete(q);
+        await internal._queryDelete(q);
       } else if (params.update) {
-        await pqb._queryUpdate(q, params.update.data);
+        await internal._queryUpdate(q, params.update.data);
       }
     }
   };
 };
 
-class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
+class HasAndBelongsToManyVirtualColumn extends internal.VirtualColumn {
   constructor(joinTable, schema, key, state) {
     super(schema);
     this.joinTable = joinTable;
@@ -1558,18 +1559,18 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   const throughPrimaryKeys = options.through.references;
   const { on } = options;
   if (on) {
-    pqb._queryWhere(query, [on]);
-    pqb._queryDefaults(query, on);
+    internal._queryWhere(query, [on]);
+    internal._queryDefaults(query, on);
   }
   const foreignKeysFull = foreignKeys.map((key, i) => {
-    if (snakeCase) key = foreignKeys[i] = pqb.toSnakeCase(key);
+    if (snakeCase) key = foreignKeys[i] = internal.toSnakeCase(key);
     return `${joinTable}.${key}`;
   });
   const throughForeignKeysFull = throughForeignKeys.map((key, i) => {
-    if (snakeCase) key = throughForeignKeys[i] = pqb.toSnakeCase(key);
+    if (snakeCase) key = throughForeignKeys[i] = internal.toSnakeCase(key);
     return `${joinTable}.${key}`;
   });
-  const foreignTable = pqb.getQueryAs(query);
+  const foreignTable = internal.getQueryAs(query);
   const throughPrimaryKeysFull = throughPrimaryKeys.map(
     (key) => `${foreignTable}.${key}`
   );
@@ -1633,16 +1634,16 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
     const cloned = joiningQuery.clone();
     cloned.q.joinedShapes = joinedShapes;
-    return pqb._queryWhereExists(cloned, subQuery, [
+    return internal._queryWhereExists(cloned, subQuery, [
       (q) => {
         for (let i = 0; i < throughLen; i++) {
-          pqb._queryJoinOn(q, [
+          internal._queryJoinOn(q, [
             throughForeignKeysFull[i],
             `${foreignAs}.${throughPrimaryKeys[i]}`
           ]);
         }
         for (let i = 0; i < len; i++) {
-          pqb._queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
+          internal._queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
         }
         return q;
       }
@@ -1654,10 +1655,10 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
   }
   const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
   const reverseJoin = (baseQuery2, joiningQuery) => {
-    const foreignAs = pqb.getQueryAs(joiningQuery);
+    const foreignAs = internal.getQueryAs(joiningQuery);
     return joinQuery(
       baseQuery2,
-      pqb.getQueryAs(baseQuery2),
+      internal.getQueryAs(baseQuery2),
       foreignAs,
       {
         ...baseQuery2.q.joinedShapes,
@@ -1675,28 +1676,28 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
           where[foreignKeysFull[i]] = params[primaryKeys[i]];
         }
         for (let i = 0; i < throughLen; i++) {
-          pqb._queryJoinOn(q2, [
+          internal._queryJoinOn(q2, [
             throughForeignKeysFull[i],
             throughPrimaryKeysFull[i]
           ]);
         }
-        return pqb._queryWhere(q2, [where]);
+        return internal._queryWhere(q2, [where]);
       });
-      return on ? pqb._queryDefaults(q, on) : q;
+      return on ? internal._queryDefaults(q, on) : q;
     },
     virtualColumn: new HasAndBelongsToManyVirtualColumn(
       subQuery,
-      pqb.defaultSchemaConfig,
+      internal.defaultSchemaConfig,
       relationName,
       state
     ),
     joinQuery: joinQueryChainHOF(
-      pqb.getPrimaryKeys(query),
+      internal.getPrimaryKeys(query),
       reverseJoin,
       (joiningQuery, baseQuery2) => joinQuery(
         joiningQuery,
-        pqb.getQueryAs(baseQuery2),
-        pqb.getQueryAs(joiningQuery),
+        internal.getQueryAs(baseQuery2),
+        internal.getQueryAs(joiningQuery),
         {
           ...joiningQuery.q.joinedShapes,
           [baseQuery2.q.as || baseQuery2.table]: baseQuery2.q.shape
@@ -1706,7 +1707,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
     reverseJoin,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
-      pqb._queryHookAfterCreate(
+      internal._queryHookAfterCreate(
         relationQuery,
         [],
         async (result) => {
@@ -1719,13 +1720,13 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
             }
             return dataRow;
           });
-          const createdCount = await pqb._queryCreateManyFrom(
+          const createdCount = await internal._queryCreateManyFrom(
             subQuery.count(),
             baseQuery2,
             data
           );
           if (createdCount === 0) {
-            throw new pqb.NotFoundError(baseQuery2);
+            throw new internal.NotFoundError(baseQuery2);
           }
         }
       );
@@ -1743,11 +1744,11 @@ const queryJoinTable = (state, data, conditions) => {
     }
   });
   if (conditions) {
-    pqb._queryWhere(t, [
+    internal._queryWhere(t, [
       {
         IN: {
           columns: state.throughForeignKeys,
-          values: pqb._querySelect(
+          values: internal._querySelect(
             state.relatedTableQuery.where(conditionsToWhereArg(conditions)),
             state.throughPrimaryKeys
           )
@@ -1756,10 +1757,10 @@ const queryJoinTable = (state, data, conditions) => {
     ]);
   }
   if (state.on) {
-    pqb._queryWhereExists(t, state.relatedTableQuery, [
+    internal._queryWhereExists(t, state.relatedTableQuery, [
       (q) => {
         for (let i = 0; i < state.throughPrimaryKeys.length; i++) {
-          pqb._queryJoinOn(q, [
+          internal._queryJoinOn(q, [
             state.throughPrimaryKeysFull[i],
             state.throughForeignKeysFull[i]
           ]);
@@ -1814,7 +1815,7 @@ const nestedInsert = ({
       for (const [, { connect }] of items) {
         for (const item of connect) {
           queries.push(
-            pqb._queryFindBy(
+            internal._queryFindBy(
               t.select(...throughPrimaryKeys),
               item
             )
@@ -1837,7 +1838,7 @@ const nestedInsert = ({
       for (const [, { connectOrCreate }] of items) {
         for (const item of connectOrCreate) {
           queries.push(
-            pqb._queryFindByOptional(
+            internal._queryFindByOptional(
               t.select(...throughPrimaryKeys),
               item.where
             )
@@ -1880,7 +1881,7 @@ const nestedInsert = ({
           }
         }
       }
-      created = await pqb._queryCreateMany(
+      created = await internal._queryCreateMany(
         t.select(...throughPrimaryKeys),
         records2
       );
@@ -1941,8 +1942,8 @@ const nestedUpdate = (state) => {
   const throughLen = state.throughPrimaryKeys.length;
   return async (query, data, params) => {
     if (params.create) {
-      const idsRows = await pqb._queryCreateMany(
-        pqb._queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)),
+      const idsRows = await internal._queryCreateMany(
+        internal._queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)),
         params.create
       );
       const records = [];
@@ -1962,16 +1963,16 @@ const nestedUpdate = (state) => {
       await state.joinTableQuery.createMany(records);
     }
     if (params.update) {
-      await pqb._queryUpdate(
-        pqb._queryWhere(
+      await internal._queryUpdate(
+        internal._queryWhere(
           state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
             for (let i = 0; i < throughLen; i++) {
-              pqb._queryJoinOn(q, [
+              internal._queryJoinOn(q, [
                 state.throughForeignKeysFull[i],
                 state.throughPrimaryKeysFull[i]
               ]);
             }
-            return pqb._queryWhere(q, [
+            return internal._queryWhere(q, [
               {
                 IN: {
                   columns: state.foreignKeysFull,
@@ -1989,14 +1990,14 @@ const nestedUpdate = (state) => {
     }
     if (params.add) {
       const as = query.table;
-      const relatedWheres = pqb.toArray(params.add);
+      const relatedWheres = internal.toArray(params.add);
       const joinTableColumns = [
         ...state.foreignKeys,
         ...state.throughForeignKeys
       ];
       try {
         const count = await state.joinTableQuery.insertForEachFrom(
-          pqb._querySelect(
+          internal._querySelect(
             state.relatedTableQuery.whereOneOf(...relatedWheres),
             [
               Object.fromEntries([
@@ -2018,18 +2019,18 @@ const nestedUpdate = (state) => {
                 state.primaryKeysShape[key]
               ])
             ),
-            data.map((x) => pqb.pick(x, state.primaryKeys))
+            data.map((x) => internal.pick(x, state.primaryKeys))
           )
         ).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
         if (count < data.length * relatedWheres.length) {
-          throw new pqb.OrchidOrmInternalError(
+          throw new internal.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(
+          throw new internal.OrchidOrmInternalError(
             query,
             `"${state.joinTableQuery.table}" must have a primary key or a unique index on columns (${joinTableColumns.join(
               ", "
@@ -2040,16 +2041,16 @@ const nestedUpdate = (state) => {
       }
     }
     if (params.disconnect) {
-      await pqb._queryDelete(
+      await internal._queryDelete(
         queryJoinTable(state, data, params.disconnect)
       );
     }
     if (params.delete) {
       const j = queryJoinTable(state, data, params.delete);
-      const idsRows = await pqb._queryDelete(
-        pqb._queryRows(pqb._querySelect(j, state.throughForeignKeys))
+      const idsRows = await internal._queryDelete(
+        internal._queryRows(internal._querySelect(j, state.throughForeignKeys))
       );
-      await pqb._queryDelete(
+      await internal._queryDelete(
         state.relatedTableQuery.where({
           IN: {
             columns: state.throughPrimaryKeys,
@@ -2060,10 +2061,10 @@ const nestedUpdate = (state) => {
     }
     if (params.set) {
       const j = queryJoinTable(state, data);
-      await pqb._queryDelete(j);
-      if (Array.isArray(params.set) ? params.set.length : pqb.objectHasValues(params.set)) {
-        const idsRows = await pqb._queryRows(
-          pqb._querySelect(
+      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)
             ),
@@ -2195,9 +2196,9 @@ const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTabl
   }
   if (data.returns === "one") {
     if (relation.options.required) {
-      pqb._queryTake(query);
+      internal._queryTake(query);
     } else {
-      pqb._queryTakeOptional(query);
+      internal._queryTakeOptional(query);
     }
     query.q.returnsOne = true;
   }
@@ -2271,9 +2272,9 @@ const orchidORMWithAdapter = ({
   } else {
     adapter = options.adapter;
     asyncStorage = new node_async_hooks.AsyncLocalStorage();
-    qb = pqb._initQueryBuilder(
+    qb = internal._initQueryBuilder(
       adapter,
-      pqb.makeColumnTypes(pqb.defaultSchemaConfig),
+      internal.makeColumnTypes(internal.defaultSchemaConfig),
       asyncStorage,
       commonOptions,
       options
@@ -2318,7 +2319,7 @@ const orchidORMWithAdapter = ({
       computed: table.computed,
       nowSQL: tableClass.nowSQL
     };
-    const dbTable = new pqb.Db(
+    const dbTable = new internal.Db(
       adapter,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       qb,
@@ -2361,7 +2362,7 @@ const createRepo = (table, methods) => {
     const proto = Object.create(q2.baseQuery);
     proto.baseQuery = proto;
     const result = Object.create(proto);
-    result.q = pqb.getClonedQueryData(q2.q);
+    result.q = internal.getClonedQueryData(q2.q);
     if (plainMethods) {
       Object.assign(proto.baseQuery, plainMethods);
     }