orchid-orm 1.19.0 → 1.20.1

package/dist/index.mjs

@@ -1,35 +1,43 @@
-import { columnTypes, QueryHooks, getColumnTypes, getQueryAs, setQueryObjectValue, pushQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, toSQLCacheKey, OrchidOrmInternalError, NotFoundError, Adapter, Db, anyShape, addComputedColumns, getClonedQueryData } from 'pqb';
+import { makeColumnTypes, defaultSchemaConfig, QueryHooks, getColumnTypes, _queryHookAfterCreate, _queryHookAfterUpdate, getQueryAs, setQueryObjectValue, pushQueryOn, VirtualColumn, pushQueryValue, _queryCreateMany, isQueryReturnsAll, _queryHookBeforeUpdate, _queryFindBy, _queryCreate, _queryRows, _queryUpdate, _queryDelete, _queryDefaults, _queryUpdateOrThrow, _queryWhere, toSQLCacheKey, _queryJoinOn, OrchidOrmInternalError, _queryCreateFrom, NotFoundError, _queryFindByOptional, _querySelect, _queryTake, _queryTakeOptional, _queryAll, Adapter, Db, anyShape, addComputedColumns, getClonedQueryData } from 'pqb';
 export * from 'pqb';
 import { getStackTrace, applyMixins, getCallerFilePath, snakeCaseKey, toSnakeCase, emptyArray, toArray } from 'orchid-core';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 function createBaseTable({
+  schemaConfig = defaultSchemaConfig,
   columnTypes: columnTypesArg,
   snakeCase,
   filePath: filePathArg,
   nowSQL,
   exportAs = "BaseTable",
-  language,
-  schemaProvider: schemaProviderArg
+  language
 } = {}) {
   var _a;
-  const columnTypes$1 = typeof columnTypesArg === "function" ? columnTypesArg(
-    columnTypes
-  ) : columnTypesArg || columnTypes;
+  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(makeColumnTypes(schemaConfig)) : columnTypesArg || makeColumnTypes(defaultSchemaConfig);
   const filePathOrStack = filePathArg || getStackTrace();
   let filePath;
-  function schemaProvider() {
-    const schema = schemaProviderArg.call(this);
-    this.schema = () => schema;
-    return schema;
-  }
   const base = (_a = class {
     constructor() {
       this.snakeCase = snakeCase;
-      this.types = columnTypes$1;
+      this.types = columnTypes;
       this.q = {};
       this.language = language;
     }
+    static inputSchema() {
+      return this._inputSchema === void 0 ? this._inputSchema = schemaConfig.inputSchema.call(this) : this._inputSchema;
+    }
+    static outputSchema() {
+      return this._outputSchema === void 0 ? this._outputSchema = schemaConfig.outputSchema.call(this) : this._outputSchema;
+    }
+    static querySchema() {
+      return this._querySchema === void 0 ? this._querySchema = schemaConfig.querySchema.call(this) : this._querySchema;
+    }
+    static updateSchema() {
+      return this._updateSchema === void 0 ? this._updateSchema = schemaConfig.updateSchema.call(this) : this._updateSchema;
+    }
+    static pkeySchema() {
+      return this._pkeySchema === void 0 ? this._pkeySchema = schemaConfig.pkeySchema.call(this) : this._pkeySchema;
+    }
     static getFilePath() {
       if (filePath)
         return filePath;
@@ -63,8 +71,8 @@ function createBaseTable({
       );
     }
     setColumns(fn) {
-      columnTypes$1[snakeCaseKey] = this.snakeCase;
-      const shape = getColumnTypes(columnTypes$1, fn, nowSQL, this.language);
+      columnTypes[snakeCaseKey] = this.snakeCase;
+      const shape = getColumnTypes(columnTypes, fn, nowSQL, this.language);
       if (this.snakeCase) {
         for (const key in shape) {
           const column = shape[key];
@@ -76,7 +84,7 @@ function createBaseTable({
           }
         }
       }
-      return shape;
+      return this.constructor.prototype.columns = shape;
     }
     setComputed(computed) {
       return computed;
@@ -112,9 +120,9 @@ function createBaseTable({
         options
       };
     }
-  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a.schema = schemaProvider, _a);
+  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a);
   applyMixins(base, [QueryHooks]);
-  base.prototype.types = columnTypes$1;
+  base.prototype.types = columnTypes;
   return base;
 }
 
@@ -141,7 +149,8 @@ const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKeys, neste
   q.q.wrapInTransaction = true;
   const relationData = [values];
   store.hasRelation[key] = relationData;
-  q._afterCreate(
+  _queryHookAfterCreate(
+    q,
     primaryKeys,
     (rows, q2) => nestedInsert(
       q2,
@@ -158,7 +167,7 @@ const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
     return;
   selectIfNotSelected(q, primaryKeys);
   q.q.wrapInTransaction = true;
-  q._afterUpdate(q.primaryKeys, (rows, q2) => {
+  _queryHookAfterUpdate(q, q.primaryKeys, (rows, q2) => {
     return nestedUpdate(
       q2,
       rows,
@@ -225,8 +234,8 @@ const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuer
 };
 
 class BelongsToVirtualColumn extends VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$3(this.state);
@@ -303,7 +312,11 @@ const makeBelongsToMethod = (relation, relationName, query) => {
     method(params) {
       return query.where(makeWhere(params));
     },
-    virtualColumn: new BelongsToVirtualColumn(relationName, state),
+    virtualColumn: new BelongsToVirtualColumn(
+      defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)
@@ -346,7 +359,7 @@ const nestedInsert$3 = ({ query, primaryKeys }) => {
       for (let i = 0, len = items.length; i < len; i++) {
         items[i] = "create" in items[i] ? items[i].create : items[i].connectOrCreate.create;
       }
-      created = await t.select(...primaryKeys)._createMany(items);
+      created = await _queryCreateMany(t.select(...primaryKeys), items);
     } else {
       created = emptyArray;
     }
@@ -380,7 +393,7 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
       throw new Error("`upsert` option is not allowed in a batch update");
     }
     let idsForDelete;
-    q._beforeUpdate(async (q2) => {
+    _queryHookBeforeUpdate(q, async (q2) => {
       if (params.disconnect) {
         for (const key of foreignKeys) {
           update[key] = null;
@@ -398,7 +411,9 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
           }
         }
         if (loadPrimaryKeys) {
-          const record = await query.select(...loadPrimaryKeys)._findBy(params.set);
+          const record = await _queryFindBy(query.select(...loadPrimaryKeys), [
+            params.set
+          ]);
           for (let i = 0, len2 = loadPrimaryKeys.length; i < len2; i++) {
             update[loadForeignKeys[i]] = record[loadPrimaryKeys[i]];
           }
@@ -406,7 +421,7 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
       } else if (params.create) {
         const q3 = query.clone();
         q3.q.select = primaryKeys;
-        const record = await q3._create(params.create);
+        const record = await _queryCreate(q3, params.create);
         for (let i = 0; i < len; i++) {
           update[foreignKeys[i]] = record[primaryKeys[i]];
         }
@@ -414,7 +429,7 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
         const selectQuery = q2.clone();
         selectQuery.q.type = void 0;
         selectQuery.q.distinct = emptyArray;
-        idsForDelete = await selectQuery._rows();
+        idsForDelete = await _queryRows(selectQuery);
         for (const foreignKey of foreignKeys) {
           update[foreignKey] = null;
         }
@@ -438,17 +453,20 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
           obj[primaryKeys[i]] = id;
         }
         if (obj) {
-          await query.findBy(obj)._update(upsert.update);
+          await _queryUpdate(
+            query.findBy(obj),
+            upsert.update
+          );
         } else {
           const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
-          const result = await query.select(...primaryKeys)._create(data);
+          const result = await _queryCreate(query.select(...primaryKeys), data);
           for (let i = 0; i < len; i++) {
             ((_a2 = state.updateData) != null ? _a2 : state.updateData = {})[foreignKeys[i]] = result[primaryKeys[i]];
           }
         }
       });
     } else if (params.delete || params.update) {
-      q._afterUpdate([], async (data) => {
+      _queryHookAfterUpdate(q, [], async (data) => {
         let ids;
         if (params.delete) {
           ids = idsForDelete;
@@ -476,11 +494,9 @@ const nestedUpdate$3 = ({ query, primaryKeys, foreignKeys, len }) => {
           ids
         );
         if (params.delete) {
-          await t._delete();
+          await _queryDelete(t);
         } else {
-          await t._update(
-            params.update
-          );
+          await _queryUpdate(t, params.update);
         }
       });
     }
@@ -504,8 +520,8 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 class HasOneVirtualColumn extends VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$2(state);
@@ -600,9 +616,13 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return query.where(values)._defaults(values);
+      return _queryDefaults(query.where(values), values);
     },
-    virtualColumn: new HasOneVirtualColumn(relationName, state),
+    virtualColumn: new HasOneVirtualColumn(
+      defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
@@ -636,9 +656,15 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
         for (let i2 = 0; i2 < len; i2++) {
           data2[foreignKeys[i2]] = selfData[primaryKeys[i2]];
         }
-        items[i] = "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(
-          item.connectOrCreate.where
-        )._update(data2);
+        items[i] = "connect" in item ? _queryUpdateOrThrow(
+          t.where(item.connect),
+          data2
+        ) : _queryUpdate(
+          t.where(
+            item.connectOrCreate.where
+          ),
+          data2
+        );
       }
       connected = await Promise.all(items);
     } else {
@@ -684,7 +710,8 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
       ids
     );
     if (params.create || params.disconnect || params.set) {
-      await currentRelationsQuery._update(
+      await _queryUpdate(
+        currentRelationsQuery,
         setNulls
       );
       const record = data[0];
@@ -700,16 +727,25 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys }) => {
         for (let i = 0; i < len; i++) {
           obj[foreignKeys[i]] = record[primaryKeys[i]];
         }
-        await t._where(params.set)._update(obj);
+        await _queryUpdate(
+          _queryWhere(t, [params.set]),
+          obj
+        );
       }
     } else if (params.update) {
-      await currentRelationsQuery._update(params.update);
+      await _queryUpdate(
+        currentRelationsQuery,
+        params.update
+      );
     } else if (params.delete) {
-      await currentRelationsQuery._delete();
+      await _queryDelete(currentRelationsQuery);
     } else if (params.upsert) {
       const { update, create } = params.upsert;
       currentRelationsQuery.q.select = foreignKeys;
-      const updatedIds = await currentRelationsQuery._rows()._update(update);
+      const updatedIds = await _queryUpdate(
+        _queryRows(currentRelationsQuery),
+        update
+      );
       if (updatedIds.length < ids.length) {
         const data2 = typeof create === "function" ? create() : create;
         await t.createMany(
@@ -748,8 +784,8 @@ var __spreadValues$4 = (a, b) => {
   return a;
 };
 class HasManyVirtualColumn extends VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$1(state);
@@ -848,9 +884,13 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
       for (let i = 0; i < len; i++) {
         values[foreignKeys[i]] = params[primaryKeys[i]];
       }
-      return query.where(values)._defaults(values);
+      return _queryDefaults(query.where(values), values);
     },
-    virtualColumn: new HasManyVirtualColumn(relationName, state),
+    virtualColumn: new HasManyVirtualColumn(
+      defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
@@ -893,7 +933,10 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
         for (let i2 = 0; i2 < len2; i2++) {
           obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
         }
-        items[i] = t.orWhere(...connect)._updateOrThrow(obj);
+        items[i] = _queryUpdateOrThrow(
+          t.orWhere(...connect),
+          obj
+        );
       }
       await Promise.all(items);
     }
@@ -914,7 +957,10 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
             obj[foreignKeys[i2]] = selfData[primaryKeys[i2]];
           }
           queries.push(
-            t.where(item.where)._update(obj)
+            _queryUpdate(
+              t.where(item.where),
+              obj
+            )
           );
         }
       }
@@ -959,7 +1005,7 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
           }
         }
       }
-      await t._createMany(records);
+      await _queryCreateMany(t, records);
     }
   };
 };
@@ -983,24 +1029,30 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
       for (const foreignKey of foreignKeys) {
         obj[foreignKey] = null;
       }
-      await getWhereForNestedUpdate(
-        t,
-        data,
-        params.disconnect,
-        primaryKeys,
-        foreignKeys
-      )._update(obj);
+      await _queryUpdate(
+        getWhereForNestedUpdate(
+          t,
+          data,
+          params.disconnect,
+          primaryKeys,
+          foreignKeys
+        ),
+        obj
+      );
       if (params.set) {
         delete t.q[toSQLCacheKey];
         const obj2 = {};
         for (let i = 0; i < len; i++) {
           obj2[foreignKeys[i]] = data[0][primaryKeys[i]];
         }
-        await t.where(
-          Array.isArray(params.set) ? {
-            OR: params.set
-          } : params.set
-        )._update(obj2);
+        await _queryUpdate(
+          t.where(
+            Array.isArray(params.set) ? {
+              OR: params.set
+            } : params.set
+          ),
+          obj2
+        );
       }
     }
     if (params.delete || params.update) {
@@ -1013,9 +1065,9 @@ const nestedUpdate$1 = ({ query, primaryKeys, foreignKeys }) => {
         foreignKeys
       );
       if (params.delete) {
-        await q._delete();
+        await _queryDelete(q);
       } else if (params.update) {
-        await q._update(params.update.data);
+        await _queryUpdate(q, params.update.data);
       }
     }
   };
@@ -1041,8 +1093,8 @@ var __spreadValues$3 = (a, b) => {
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert(state);
@@ -1111,7 +1163,9 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   baseQuery.table = joinTable;
   const shape = {};
   for (let i = 0; i < len; i++) {
-    shape[foreignKeys[i]] = removeColumnName(table.shape[primaryKeys[i]]);
+    shape[foreignKeys[i]] = removeColumnName(
+      table.shape[primaryKeys[i]]
+    );
   }
   for (let i = 0; i < throughLen; i++) {
     shape[throughForeignKeys[i]] = removeColumnName(
@@ -1137,13 +1191,13 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   const joinQuery = (joiningQuery, tableAs, foreignAs) => {
     return joiningQuery.whereExists(subQuery, (q) => {
       for (let i = 0; i < throughLen; i++) {
-        q._on(
+        _queryJoinOn(q, [
           throughForeignKeysFull[i],
           `${foreignAs}.${throughPrimaryKeys[i]}`
-        );
+        ]);
       }
       for (let i = 0; i < len; i++) {
-        q._on(foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`);
+        _queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
       }
       return q;
     });
@@ -1170,12 +1224,19 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
           where[foreignKeysFull[i]] = params[primaryKeys[i]];
         }
         for (let i = 0; i < throughLen; i++) {
-          q._on(throughForeignKeysFull[i], throughPrimaryKeysFull[i]);
+          _queryJoinOn(q, [
+            throughForeignKeysFull[i],
+            throughPrimaryKeysFull[i]
+          ]);
         }
-        return q._where(where);
+        return _queryWhere(q, [where]);
       });
     },
-    virtualColumn: new HasAndBelongsToManyVirtualColumn(relationName, state),
+    virtualColumn: new HasAndBelongsToManyVirtualColumn(
+      defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(reverseJoin, (joiningQuery, baseQuery2) => {
       const joined = joinQuery(
         joiningQuery,
@@ -1190,7 +1251,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     reverseJoin,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
-      relationQuery._afterCreate([], async (result) => {
+      _queryHookAfterCreate(relationQuery, [], async (result) => {
         if (result.length > 1) {
           throw new OrchidOrmInternalError(
             relationQuery,
@@ -1203,7 +1264,11 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
         for (let i = 0; i < throughLen; i++) {
           data[throughForeignKeys[i]] = result[0][throughPrimaryKeys[i]];
         }
-        const createdCount = await subQuery.count()._createFrom(baseQuery2, data);
+        const createdCount = await _queryCreateFrom(
+          subQuery.count(),
+          baseQuery2,
+          data
+        );
         if (createdCount === 0) {
           throw new NotFoundError(baseQuery2);
         }
@@ -1222,12 +1287,17 @@ const queryJoinTable = (state, data, conditions) => {
     }
   });
   if (conditions) {
-    t._where({
-      IN: {
-        columns: state.throughForeignKeys,
-        values: state.relatedTableQuery.where(conditionsToWhereArg(conditions))._select(...state.throughPrimaryKeys)
+    _queryWhere(t, [
+      {
+        IN: {
+          columns: state.throughForeignKeys,
+          values: _querySelect(
+            state.relatedTableQuery.where(conditionsToWhereArg(conditions)),
+            state.throughPrimaryKeys
+          )
+        }
       }
-    });
+    ]);
   }
   return t;
 };
@@ -1274,9 +1344,7 @@ const nestedInsert = ({
       const queries = [];
       for (const [, { connect }] of items) {
         for (const item of connect) {
-          queries.push(
-            t.select(...throughPrimaryKeys)._findBy(item)._take()
-          );
+          queries.push(_queryFindBy(t.select(...throughPrimaryKeys), [item]));
         }
       }
       connected = await Promise.all(queries);
@@ -1295,7 +1363,7 @@ const nestedInsert = ({
       for (const [, { connectOrCreate }] of items) {
         for (const item of connectOrCreate) {
           queries.push(
-            t.select(...throughPrimaryKeys)._findBy(item.where)._takeOptional()
+            _queryFindByOptional(t.select(...throughPrimaryKeys), [item.where])
           );
         }
       }
@@ -1335,7 +1403,10 @@ const nestedInsert = ({
           }
         }
       }
-      created = await t.select(...throughPrimaryKeys)._createMany(records2);
+      created = await _queryCreateMany(
+        t.select(...throughPrimaryKeys),
+        records2
+      );
     } else {
       created = [];
     }
@@ -1393,7 +1464,10 @@ const nestedUpdate = (state) => {
   const throughLen = state.throughPrimaryKeys.length;
   return async (_, data, params) => {
     if (params.create) {
-      const idsRows = await state.relatedTableQuery.select(...state.throughPrimaryKeys)._rows()._createMany(params.create);
+      const idsRows = await _queryCreateMany(
+        _queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)),
+        params.create
+      );
       const records = [];
       for (const item of data) {
         const obj = {};
@@ -1411,41 +1485,58 @@ const nestedUpdate = (state) => {
       await state.joinTableQuery.createMany(records);
     }
     if (params.update) {
-      await state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
-        for (let i = 0; i < throughLen; i++) {
-          q._on(
-            state.throughForeignKeysFull[i],
-            state.throughPrimaryKeysFull[i]
-          );
-        }
-        return q._where({
-          IN: {
-            columns: state.foreignKeysFull,
-            values: data.map(
-              (item) => state.primaryKeys.map((key) => item[key])
-            )
-          }
-        });
-      })._where(conditionsToWhereArg(params.update.where))._update(params.update.data);
+      await _queryUpdate(
+        _queryWhere(
+          state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
+            for (let i = 0; i < throughLen; i++) {
+              _queryJoinOn(q, [
+                state.throughForeignKeysFull[i],
+                state.throughPrimaryKeysFull[i]
+              ]);
+            }
+            return _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.disconnect) {
-      await queryJoinTable(state, data, params.disconnect)._delete();
+      await _queryDelete(queryJoinTable(state, data, params.disconnect));
     }
     if (params.delete) {
       const j = queryJoinTable(state, data, params.delete);
-      const idsRows = await j._select(...state.throughForeignKeys)._rows()._delete();
-      await state.relatedTableQuery.where({
-        IN: {
-          columns: state.throughPrimaryKeys,
-          values: idsRows
-        }
-      })._delete();
+      const idsRows = await _queryDelete(
+        _queryRows(_querySelect(j, state.throughForeignKeys))
+      );
+      await _queryDelete(
+        state.relatedTableQuery.where({
+          IN: {
+            columns: state.throughPrimaryKeys,
+            values: idsRows
+          }
+        })
+      );
     }
     if (params.set) {
       const j = queryJoinTable(state, data);
-      await j._delete();
+      await _queryDelete(j);
       delete j.q[toSQLCacheKey];
-      const idsRows = await state.relatedTableQuery.where(conditionsToWhereArg(params.set))._select(...state.throughPrimaryKeys)._rows();
+      const idsRows = await _queryRows(
+        _querySelect(
+          state.relatedTableQuery.where(conditionsToWhereArg(params.set)),
+          state.throughPrimaryKeys
+        )
+      );
       await insertToJoinTable(state, j, data, idsRows);
     }
   };
@@ -1587,9 +1678,9 @@ const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, de
   }
   if (data.returns === "one") {
     if (relation.options.required) {
-      query._take();
+      _queryTake(query);
     } else {
-      query._takeOptional();
+      _queryTakeOptional(query);
     }
     query.q.returnsOne = true;
   }
@@ -1632,11 +1723,13 @@ const makeRelationQuery = (table, relationName, data, q) => {
         query = toTable;
         query.q.isSubQuery = true;
       } else {
-        query = toTable._all()._where({
-          EXISTS: {
-            args: [data.reverseJoin(this, toTable)]
+        query = _queryWhere(_queryAll(toTable), [
+          {
+            EXISTS: {
+              args: [data.reverseJoin(this, toTable)]
+            }
           }
-        });
+        ]);
       }
       if (this.q.relChain) {
         query.q.relChain = [...this.q.relChain, this];
@@ -1734,7 +1827,7 @@ const orchidORM = (_a, tables) => {
       void 0,
       void 0,
       anyShape,
-      columnTypes,
+      makeColumnTypes(defaultSchemaConfig),
       transactionStorage,
       commonOptions
     );