orchid-orm 1.3.15 → 1.4.16

package/dist/index.esm.js

@@ -1,7 +1,7 @@
-import { getColumnTypes, isQueryReturnsAll, addQueryOn, getQueryAs, toSqlCacheKey, pushQueryValue, NotFoundError, relationQueryKey, Db, Adapter, anyShape, columnTypes, getClonedQueryData } from 'pqb';
+import { getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Db, Adapter, anyShape, columnTypes, getClonedQueryData } from 'pqb';
 
-const createModel = (options) => {
-  return class Model {
+const createBaseTable = (options) => {
+  return class BaseTable {
     constructor() {
       this.setColumns = (fn) => {
         const shape = getColumnTypes(options.columnTypes, fn);
@@ -47,150 +47,249 @@ const createModel = (options) => {
   };
 };
 
-const makeBelongsToMethod = (relation, query) => {
+class BelongsToVirtualColumn extends VirtualColumn {
+  constructor(key, state) {
+    super();
+    this.key = key;
+    this.state = state;
+    this.nestedInsert = nestedInsert$3(this.state);
+    this.nestedUpdate = nestedUpdate$3(this.state);
+  }
+  create(q, ctx, item, rowIndex) {
+    const {
+      key,
+      state: { foreignKey, primaryKey }
+    } = this;
+    let columnIndex = ctx.columns.get(foreignKey);
+    if (columnIndex === void 0) {
+      ctx.columns.set(foreignKey, columnIndex = ctx.columns.size);
+    }
+    const store = ctx;
+    if (!store.belongsTo)
+      store.belongsTo = {};
+    const values = [rowIndex, columnIndex, item[key]];
+    if (store.belongsTo[key]) {
+      store.belongsTo[key].push(values);
+      return;
+    }
+    const relationData = [values];
+    store.belongsTo[key] = relationData;
+    q.query.wrapInTransaction = true;
+    pushQueryValue(q, "beforeCreate", async (q2) => {
+      const inserted = await this.nestedInsert(
+        q2,
+        relationData.map(([, , data]) => data)
+      );
+      const { values: values2 } = q2.query;
+      relationData.forEach(([rowIndex2, columnIndex2], index) => {
+        values2[rowIndex2][columnIndex2] = inserted[index][primaryKey];
+      });
+    });
+  }
+  update(q, ctx, set) {
+    q.query.wrapInTransaction = true;
+    const data = set[this.key];
+    if (this.nestedUpdate(q, set, data, ctx)) {
+      ctx.willSetKeys = true;
+    }
+  }
+}
+const makeBelongsToMethod = (relation, relationName, query) => {
   const { primaryKey, foreignKey } = relation.options;
+  const state = { query, primaryKey, foreignKey };
   return {
     returns: "one",
     method: (params) => {
       return query.findBy({ [primaryKey]: params[foreignKey] });
     },
-    nestedInsert: async (q, data) => {
-      const connectOrCreate = data.filter(
-        (item) => Boolean(item.connectOrCreate)
+    virtualColumn: new BelongsToVirtualColumn(relationName, state),
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
+    },
+    primaryKey
+  };
+};
+const nestedInsert$3 = ({ query, primaryKey }) => {
+  return async (q, data) => {
+    const connectOrCreate = data.filter(
+      (item) => Boolean(item.connectOrCreate)
+    );
+    const t = query.transacting(q);
+    let connectOrCreated;
+    if (connectOrCreate.length) {
+      connectOrCreated = await Promise.all(
+        connectOrCreate.map(
+          (item) => t.findBy(item.connectOrCreate.where)._takeOptional()
+        )
       );
-      const t = query.transacting(q);
-      let connectOrCreated;
-      if (connectOrCreate.length) {
-        connectOrCreated = await Promise.all(
-          connectOrCreate.map(
-            (item) => t.findBy(item.connectOrCreate.where)._takeOptional()
-          )
-        );
-      } else {
-        connectOrCreated = [];
-      }
-      let connectOrCreatedI = 0;
-      const create = data.filter(
-        (item) => {
-          if (item.connectOrCreate) {
-            return !connectOrCreated[connectOrCreatedI++];
-          } else {
-            return Boolean(item.create);
-          }
+    } else {
+      connectOrCreated = [];
+    }
+    let connectOrCreatedI = 0;
+    const create = data.filter(
+      (item) => {
+        if (item.connectOrCreate) {
+          return !connectOrCreated[connectOrCreatedI++];
+        } else {
+          return Boolean(item.create);
         }
-      );
-      let created;
-      if (create.length) {
-        created = await t.select(primaryKey)._createMany(
-          create.map(
-            (item) => "create" in item ? item.create : item.connectOrCreate.create
-          )
-        );
-      } else {
-        created = [];
       }
-      const connect = data.filter(
-        (item) => Boolean(item.connect)
+    );
+    let created;
+    if (create.length) {
+      created = await t.select(primaryKey)._createMany(
+        create.map(
+          (item) => "create" in item ? item.create : item.connectOrCreate.create
+        )
       );
-      let connected;
-      if (connect.length) {
-        connected = await Promise.all(
-          connect.map((item) => t.findBy(item.connect)._take())
-        );
-      } else {
-        connected = [];
-      }
-      let createdI = 0;
-      let connectedI = 0;
-      connectOrCreatedI = 0;
-      return data.map(
-        (item) => item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++]
+    } else {
+      created = [];
+    }
+    const connect = data.filter(
+      (item) => Boolean(item.connect)
+    );
+    let connected;
+    if (connect.length) {
+      connected = await Promise.all(
+        connect.map((item) => t.findBy(item.connect)._take())
       );
-    },
-    nestedUpdate: (q, update, params, state) => {
-      var _a, _b;
-      if (params.upsert && isQueryReturnsAll(q)) {
-        throw new Error("`upsert` option is not allowed in a batch update");
-      }
-      let idForDelete;
-      q._beforeUpdate(async (q2) => {
-        if (params.disconnect) {
-          update[foreignKey] = null;
-        } else if (params.set) {
-          if (primaryKey in params.set) {
-            update[foreignKey] = params.set[primaryKey];
-          } else {
-            update[foreignKey] = await query.transacting(q2)._findBy(params.set)._get(primaryKey);
-          }
-        } else if (params.create) {
-          update[foreignKey] = await query.transacting(q2)._get(primaryKey)._create(params.create);
-        } else if (params.delete) {
-          const selectQuery = q2.transacting(q2);
-          selectQuery.query.type = void 0;
-          idForDelete = await selectQuery._getOptional(foreignKey);
-          update[foreignKey] = null;
-        }
-      });
-      const { upsert } = params;
-      if (upsert || params.update || params.delete) {
-        if (!((_a = q.query.select) == null ? void 0 : _a.includes("*")) && !((_b = q.query.select) == null ? void 0 : _b.includes(foreignKey))) {
-          q._select(foreignKey);
+    } else {
+      connected = [];
+    }
+    let createdI = 0;
+    let connectedI = 0;
+    connectOrCreatedI = 0;
+    return data.map(
+      (item) => item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++]
+    );
+  };
+};
+const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
+  return (q, update, params, state) => {
+    var _a, _b;
+    if (params.upsert && isQueryReturnsAll(q)) {
+      throw new Error("`upsert` option is not allowed in a batch update");
+    }
+    let idForDelete;
+    q._beforeUpdate(async (q2) => {
+      if (params.disconnect) {
+        update[foreignKey] = null;
+      } else if (params.set) {
+        if (primaryKey in params.set) {
+          update[foreignKey] = params.set[primaryKey];
+        } else {
+          update[foreignKey] = await query.transacting(q2)._findBy(params.set)._get(primaryKey);
         }
+      } else if (params.create) {
+        update[foreignKey] = await query.transacting(q2)._get(primaryKey)._create(params.create);
+      } else if (params.delete) {
+        const selectQuery = q2.transacting(q2);
+        selectQuery.query.type = void 0;
+        idForDelete = await selectQuery._getOptional(foreignKey);
+        update[foreignKey] = null;
       }
-      if (upsert) {
-        if (!state.updateLater) {
-          state.updateLater = {};
-          state.updateLaterPromises = [];
+    });
+    const { upsert } = params;
+    if (upsert || params.update || params.delete) {
+      if (!((_a = q.query.select) == null ? void 0 : _a.includes("*")) && !((_b = q.query.select) == null ? void 0 : _b.includes(foreignKey))) {
+        q._select(foreignKey);
+      }
+    }
+    if (upsert) {
+      if (!state.updateLater) {
+        state.updateLater = {};
+        state.updateLaterPromises = [];
+      }
+      const { handleResult } = q.query;
+      q.query.handleResult = async (q2, queryResult) => {
+        const data = await handleResult(q2, queryResult);
+        const id = data[0][foreignKey];
+        if (id !== null) {
+          await query.transacting(q2)._findBy({ [primaryKey]: id })._update(upsert.update);
+        } else {
+          state.updateLaterPromises.push(
+            query.transacting(q2)._select(primaryKey)._create(upsert.create).then((result) => {
+              state.updateLater[foreignKey] = result[primaryKey];
+            })
+          );
         }
-        const { handleResult } = q.query;
-        q.query.handleResult = async (q2, queryResult) => {
-          const data = await handleResult(q2, queryResult);
-          const id = data[0][foreignKey];
-          if (id !== null) {
-            await query.transacting(q2)._findBy({ [primaryKey]: id })._update(upsert.update);
-          } else {
-            state.updateLaterPromises.push(
-              query.transacting(q2)._select(primaryKey)._create(upsert.create).then((result) => {
-                state.updateLater[foreignKey] = result[primaryKey];
-              })
-            );
-          }
-          return data;
-        };
-      } else if (params.delete || params.update) {
-        q._afterQuery(async (q2, data) => {
-          const id = params.delete ? idForDelete : Array.isArray(data) ? data.length === 0 ? null : {
-            in: data.map((item) => item[foreignKey]).filter((id2) => id2 !== null)
-          } : data[foreignKey];
-          if (id !== void 0 && id !== null) {
-            const t = query.transacting(q2)._findBy({
-              [primaryKey]: id
-            });
-            if (params.delete) {
-              await t._delete();
-            } else if (params.update) {
-              await t._update(params.update);
-            }
+        return data;
+      };
+    } else if (params.delete || params.update) {
+      q._afterQuery(async (q2, data) => {
+        const id = params.delete ? idForDelete : Array.isArray(data) ? data.length === 0 ? null : {
+          in: data.map((item) => item[foreignKey]).filter((id2) => id2 !== null)
+        } : data[foreignKey];
+        if (id !== void 0 && id !== null) {
+          const t = query.transacting(q2)._findBy({
+            [primaryKey]: id
+          });
+          if (params.delete) {
+            await t._delete();
+          } else if (params.update) {
+            await t._update(params.update);
           }
-        });
-      }
-      return !params.update && !params.upsert;
-    },
-    joinQuery(fromQuery, toQuery) {
-      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
-    },
-    reverseJoin(fromQuery, toQuery) {
-      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
-    },
-    primaryKey
+        }
+      });
+    }
+    return !params.update && !params.upsert;
   };
 };
 
-const getThroughRelation = (model, through) => {
-  return model.relations[through];
+const getThroughRelation = (table, through) => {
+  return table.relations[through];
 };
 const getSourceRelation = (throughRelation, source) => {
-  return throughRelation.model.relations[source];
+  return throughRelation.table.relations[source];
+};
+const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nestedInsert) => {
+  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 = [rowIndex, value];
+  if (store.hasRelation[key]) {
+    store.hasRelation[key].push(values);
+    return;
+  }
+  q.query.wrapInTransaction = true;
+  ctx.returnTypeAll = true;
+  ctx.requiredReturning[primaryKey] = true;
+  const relationData = [values];
+  store.hasRelation[key] = relationData;
+  pushQueryValue(q, "afterCreate", async (q2) => {
+    const { resultAll } = ctx;
+    return nestedInsert(
+      q2,
+      relationData.map(([rowIndex2, data]) => [
+        resultAll[rowIndex2],
+        data
+      ])
+    );
+  });
+};
+const hasRelationHandleUpdate = (q, ctx, set, key, primaryKey, nestedUpdate) => {
+  var _a, _b;
+  const value = set[key];
+  if (!value.set && !("upsert" in value) && (!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;
+  if (!((_a = q.query.select) == null ? void 0 : _a.includes("*")) && !((_b = q.query.select) == null ? void 0 : _b.includes(primaryKey))) {
+    q._select(primaryKey);
+  }
+  q.query.wrapInTransaction = true;
+  ctx.returnTypeAll = true;
+  pushQueryValue(q, "afterUpdate", (q2) => {
+    return nestedUpdate(
+      q2,
+      ctx.resultAll,
+      value
+    );
+  });
 };
 
 var __defProp$4 = Object.defineProperty;
@@ -212,7 +311,37 @@ var __spreadValues$4 = (a, b) => {
   return a;
 };
 var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-const makeHasOneMethod = (model, relation, relationName, query) => {
+class HasOneVirtualColumn extends VirtualColumn {
+  constructor(key, state) {
+    super();
+    this.key = key;
+    this.state = state;
+    this.nestedInsert = nestedInsert$2(state);
+    this.nestedUpdate = nestedUpdate$2(state);
+  }
+  create(q, ctx, item, rowIndex) {
+    hasRelationHandleCreate(
+      q,
+      ctx,
+      item,
+      rowIndex,
+      this.key,
+      this.state.primaryKey,
+      this.nestedInsert
+    );
+  }
+  update(q, ctx, set) {
+    hasRelationHandleUpdate(
+      q,
+      ctx,
+      set,
+      this.key,
+      this.state.primaryKey,
+      this.nestedUpdate
+    );
+  }
+}
+const makeHasOneMethod = (table, relation, relationName, query) => {
   if (relation.options.required) {
     query._take();
   } else {
@@ -220,21 +349,19 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
   }
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceQuery = sourceRelation.joinQuery(throughRelation.query, sourceRelation.query).as(relationName);
     const whereExistsCallback = () => sourceQuery;
     return {
       returns: "one",
       method: (params) => {
-        const throughQuery = model[through](params);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
         );
       },
-      nestedInsert: void 0,
-      nestedUpdate: void 0,
       joinQuery(fromQuery, toQuery) {
         return toQuery.whereExists(
           throughRelation.joinQuery(fromQuery, throughRelation.query),
@@ -263,6 +390,7 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
     };
   }
   const { primaryKey, foreignKey } = relation.options;
+  const state = { query, primaryKey, foreignKey };
   const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
   return {
     returns: "one",
@@ -270,75 +398,7 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
       const values = { [foreignKey]: params[primaryKey] };
       return query.where(values)._defaults(values);
     },
-    nestedInsert: async (q, data) => {
-      const connect = data.filter(
-        (item) => Boolean(item[1].connect || item[1].connectOrCreate)
-      );
-      const t = query.transacting(q);
-      let connected;
-      if (connect.length) {
-        connected = await Promise.all(
-          connect.map(([selfData, item]) => {
-            const data2 = { [foreignKey]: selfData[primaryKey] };
-            return "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(item.connectOrCreate.where)._update(data2);
-          })
-        );
-      } else {
-        connected = [];
-      }
-      let connectedI = 0;
-      const create = data.filter(
-        (item) => {
-          if (item[1].connectOrCreate) {
-            return !connected[connectedI++];
-          }
-          return Boolean(item[1].create);
-        }
-      );
-      if (create.length) {
-        await t._count()._createMany(
-          create.map(([selfData, item]) => __spreadValues$4({
-            [foreignKey]: selfData[primaryKey]
-          }, "create" in item ? item.create : item.connectOrCreate.create))
-        );
-      }
-    },
-    nestedUpdate: async (q, data, params) => {
-      if ((params.set || params.create || params.upsert) && isQueryReturnsAll(q)) {
-        const key = params.set ? "set" : params.create ? "create" : "upsert";
-        throw new Error(`\`${key}\` option is not allowed in a batch update`);
-      }
-      const t = query.transacting(q);
-      const ids = data.map((item) => item[primaryKey]);
-      const currentRelationsQuery = t.where({
-        [foreignKey]: { in: ids }
-      });
-      if (params.create || params.disconnect || params.set) {
-        await currentRelationsQuery._update({ [foreignKey]: null });
-        if (params.create) {
-          await t._count()._create(__spreadProps$2(__spreadValues$4({}, params.create), {
-            [foreignKey]: data[0][primaryKey]
-          }));
-        }
-        if (params.set) {
-          await t._where(params.set)._update({ [foreignKey]: data[0][primaryKey] });
-        }
-      } else if (params.update) {
-        await currentRelationsQuery._update(params.update);
-      } else if (params.delete) {
-        await currentRelationsQuery._delete();
-      } else if (params.upsert) {
-        const { update, create } = params.upsert;
-        const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
-        if (updatedIds.length < ids.length) {
-          await t.createMany(
-            ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$2(__spreadValues$4({}, create), {
-              [foreignKey]: id
-            }))
-          );
-        }
-      }
-    },
+    virtualColumn: new HasOneVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
       return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
     },
@@ -355,6 +415,79 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
     }
   };
 };
+const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
+  return async (q, data) => {
+    const connect = data.filter(
+      (item) => Boolean(item[1].connect || item[1].connectOrCreate)
+    );
+    const t = query.transacting(q);
+    let connected;
+    if (connect.length) {
+      connected = await Promise.all(
+        connect.map(([selfData, item]) => {
+          const data2 = { [foreignKey]: selfData[primaryKey] };
+          return "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(item.connectOrCreate.where)._update(data2);
+        })
+      );
+    } else {
+      connected = [];
+    }
+    let connectedI = 0;
+    const create = data.filter(
+      (item) => {
+        if (item[1].connectOrCreate) {
+          return !connected[connectedI++];
+        }
+        return Boolean(item[1].create);
+      }
+    );
+    if (create.length) {
+      await t._count()._createMany(
+        create.map(([selfData, item]) => __spreadValues$4({
+          [foreignKey]: selfData[primaryKey]
+        }, "create" in item ? item.create : item.connectOrCreate.create))
+      );
+    }
+  };
+};
+const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
+  return async (q, data, params) => {
+    if ((params.set || params.create || params.upsert) && isQueryReturnsAll(q)) {
+      const key = params.set ? "set" : params.create ? "create" : "upsert";
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
+    const t = query.transacting(q);
+    const ids = data.map((item) => item[primaryKey]);
+    const currentRelationsQuery = t.where({
+      [foreignKey]: { in: ids }
+    });
+    if (params.create || params.disconnect || params.set) {
+      await currentRelationsQuery._update({ [foreignKey]: null });
+      if (params.create) {
+        await t._count()._create(__spreadProps$2(__spreadValues$4({}, params.create), {
+          [foreignKey]: data[0][primaryKey]
+        }));
+      }
+      if (params.set) {
+        await t._where(params.set)._update({ [foreignKey]: data[0][primaryKey] });
+      }
+    } else if (params.update) {
+      await currentRelationsQuery._update(params.update);
+    } else if (params.delete) {
+      await currentRelationsQuery._delete();
+    } else if (params.upsert) {
+      const { update, create } = params.upsert;
+      const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
+      if (updatedIds.length < ids.length) {
+        await t.createMany(
+          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$2(__spreadValues$4({}, create), {
+            [foreignKey]: id
+          }))
+        );
+      }
+    }
+  };
+};
 
 var __defProp$3 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
@@ -375,10 +508,40 @@ var __spreadValues$3 = (a, b) => {
   return a;
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const makeHasManyMethod = (model, relation, relationName, query) => {
+class HasManyVirtualColumn extends VirtualColumn {
+  constructor(key, state) {
+    super();
+    this.key = key;
+    this.state = state;
+    this.nestedInsert = nestedInsert$1(state);
+    this.nestedUpdate = nestedUpdate$1(state);
+  }
+  create(q, ctx, item, rowIndex) {
+    hasRelationHandleCreate(
+      q,
+      ctx,
+      item,
+      rowIndex,
+      this.key,
+      this.state.primaryKey,
+      this.nestedInsert
+    );
+  }
+  update(q, ctx, set) {
+    hasRelationHandleUpdate(
+      q,
+      ctx,
+      set,
+      this.key,
+      this.state.primaryKey,
+      this.nestedUpdate
+    );
+  }
+}
+const makeHasManyMethod = (table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
@@ -389,14 +552,12 @@ const makeHasManyMethod = (model, relation, relationName, query) => {
     return {
       returns: "many",
       method: (params) => {
-        const throughQuery = model[through](params);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
         );
       },
-      nestedInsert: void 0,
-      nestedUpdate: void 0,
       joinQuery(fromQuery, toQuery) {
         return toQuery.whereExists(
           throughRelation.joinQuery(fromQuery, throughRelation.query),
@@ -425,6 +586,7 @@ const makeHasManyMethod = (model, relation, relationName, query) => {
     };
   }
   const { primaryKey, foreignKey } = relation.options;
+  const state = { query, primaryKey, foreignKey };
   const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
   return {
     returns: "many",
@@ -432,117 +594,7 @@ const makeHasManyMethod = (model, relation, relationName, query) => {
       const values = { [foreignKey]: params[primaryKey] };
       return query.where(values)._defaults(values);
     },
-    nestedInsert: async (q, data) => {
-      const connect = data.filter(
-        (item) => Boolean(item[1].connect)
-      );
-      const t = query.transacting(q);
-      if (connect.length) {
-        await Promise.all(
-          connect.flatMap(
-            ([selfData, { connect: connect2 }]) => t.or(...connect2)._updateOrThrow({ [foreignKey]: selfData[primaryKey] })
-          )
-        );
-      }
-      const connectOrCreate = data.filter(
-        (item) => Boolean(item[1].connectOrCreate)
-      );
-      let connected;
-      if (connectOrCreate.length) {
-        connected = await Promise.all(
-          connectOrCreate.flatMap(
-            ([selfData, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
-              (item) => t.where(item.where)._update({
-                [foreignKey]: selfData[primaryKey]
-              })
-            )
-          )
-        );
-      } else {
-        connected = [];
-      }
-      let connectedI = 0;
-      const create = data.filter(
-        (item) => {
-          if (item[1].connectOrCreate) {
-            const length = item[1].connectOrCreate.length;
-            connectedI += length;
-            for (let i = length; i > 0; i--) {
-              if (connected[connectedI - i] === 0)
-                return true;
-            }
-          }
-          return Boolean(item[1].create);
-        }
-      );
-      connectedI = 0;
-      if (create.length) {
-        await t._createMany(
-          create.flatMap(
-            ([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
-              return [
-                ...create2.map((item) => __spreadValues$3({
-                  [foreignKey]: selfData[primaryKey]
-                }, item)),
-                ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$3({
-                  [foreignKey]: selfData[primaryKey]
-                }, item.create))
-              ];
-            }
-          )
-        );
-      }
-    },
-    nestedUpdate: async (q, data, params) => {
-      var _a;
-      if ((params.set || params.create) && isQueryReturnsAll(q)) {
-        const key = params.set ? "set" : "create";
-        throw new Error(`\`${key}\` option is not allowed in a batch update`);
-      }
-      const t = query.transacting(q);
-      if (params.create) {
-        await t._count()._createMany(
-          params.create.map((create) => __spreadProps$1(__spreadValues$3({}, create), {
-            [foreignKey]: data[0][primaryKey]
-          }))
-        );
-        delete t.query[toSqlCacheKey];
-      }
-      if (params.disconnect || params.set) {
-        await t.where(
-          getWhereForNestedUpdate(
-            data,
-            params.disconnect,
-            primaryKey,
-            foreignKey
-          )
-        )._update({ [foreignKey]: null });
-        if (params.set) {
-          delete t.query[toSqlCacheKey];
-          await t.where(
-            Array.isArray(params.set) ? {
-              OR: params.set
-            } : params.set
-          )._update({ [foreignKey]: data[0][primaryKey] });
-        }
-      }
-      if (params.delete || params.update) {
-        delete t.query[toSqlCacheKey];
-        const q2 = t._where(
-          getWhereForNestedUpdate(
-            data,
-            params.delete || ((_a = params.update) == null ? void 0 : _a.where),
-            primaryKey,
-            foreignKey
-          )
-        );
-        if (params.delete) {
-          await q2._delete();
-        } else if (params.update) {
-          await q2._update(params.update.data);
-        }
-      }
-    },
+    virtualColumn: new HasManyVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
       return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
     },
@@ -572,6 +624,119 @@ const getWhereForNestedUpdate = (data, params, primaryKey, foreignKey) => {
   }
   return where;
 };
+const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
+  return async (q, data) => {
+    const connect = data.filter(
+      (item) => Boolean(item[1].connect)
+    );
+    const t = query.transacting(q);
+    if (connect.length) {
+      await Promise.all(
+        connect.flatMap(
+          ([selfData, { connect: connect2 }]) => t.or(...connect2)._updateOrThrow({ [foreignKey]: selfData[primaryKey] })
+        )
+      );
+    }
+    const connectOrCreate = data.filter(
+      (item) => Boolean(item[1].connectOrCreate)
+    );
+    let connected;
+    if (connectOrCreate.length) {
+      connected = await Promise.all(
+        connectOrCreate.flatMap(
+          ([selfData, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
+            (item) => t.where(item.where)._update({
+              [foreignKey]: selfData[primaryKey]
+            })
+          )
+        )
+      );
+    } else {
+      connected = [];
+    }
+    let connectedI = 0;
+    const create = data.filter(
+      (item) => {
+        if (item[1].connectOrCreate) {
+          const length = item[1].connectOrCreate.length;
+          connectedI += length;
+          for (let i = length; i > 0; i--) {
+            if (connected[connectedI - i] === 0)
+              return true;
+          }
+        }
+        return Boolean(item[1].create);
+      }
+    );
+    connectedI = 0;
+    if (create.length) {
+      await t._createMany(
+        create.flatMap(([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
+          return [
+            ...create2.map((item) => __spreadValues$3({
+              [foreignKey]: selfData[primaryKey]
+            }, item)),
+            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$3({
+              [foreignKey]: selfData[primaryKey]
+            }, item.create))
+          ];
+        })
+      );
+    }
+  };
+};
+const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
+  return async (q, data, params) => {
+    var _a;
+    if ((params.set || params.create) && isQueryReturnsAll(q)) {
+      const key = params.set ? "set" : "create";
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
+    const t = query.transacting(q);
+    if (params.create) {
+      await t._count()._createMany(
+        params.create.map((create) => __spreadProps$1(__spreadValues$3({}, create), {
+          [foreignKey]: data[0][primaryKey]
+        }))
+      );
+      delete t.query[toSqlCacheKey];
+    }
+    if (params.disconnect || params.set) {
+      await t.where(
+        getWhereForNestedUpdate(
+          data,
+          params.disconnect,
+          primaryKey,
+          foreignKey
+        )
+      )._update({ [foreignKey]: null });
+      if (params.set) {
+        delete t.query[toSqlCacheKey];
+        await t.where(
+          Array.isArray(params.set) ? {
+            OR: params.set
+          } : params.set
+        )._update({ [foreignKey]: data[0][primaryKey] });
+      }
+    }
+    if (params.delete || params.update) {
+      delete t.query[toSqlCacheKey];
+      const q2 = t._where(
+        getWhereForNestedUpdate(
+          data,
+          params.delete || ((_a = params.update) == null ? void 0 : _a.where),
+          primaryKey,
+          foreignKey
+        )
+      );
+      if (params.delete) {
+        await q2._delete();
+      } else if (params.update) {
+        await q2._update(params.update.data);
+      }
+    }
+  };
+};
 
 var __defProp$2 = Object.defineProperty;
 var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
@@ -589,7 +754,37 @@ var __spreadValues$2 = (a, b) => {
     }
   return a;
 };
-const makeHasAndBelongsToManyMethod = (model, qb, relation, query) => {
+class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
+  constructor(key, state) {
+    super();
+    this.key = key;
+    this.state = state;
+    this.nestedInsert = nestedInsert(state);
+    this.nestedUpdate = nestedUpdate(state);
+  }
+  create(q, ctx, item, rowIndex) {
+    hasRelationHandleCreate(
+      q,
+      ctx,
+      item,
+      rowIndex,
+      this.key,
+      this.state.primaryKey,
+      this.nestedInsert
+    );
+  }
+  update(q, ctx, set) {
+    hasRelationHandleUpdate(
+      q,
+      ctx,
+      set,
+      this.key,
+      this.state.primaryKey,
+      this.nestedUpdate
+    );
+  }
+}
+const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
   const {
     primaryKey: pk,
     foreignKey: fk,
@@ -600,14 +795,14 @@ const makeHasAndBelongsToManyMethod = (model, qb, relation, query) => {
   const foreignKeyFull = `${joinTable}.${fk}`;
   const associationForeignKeyFull = `${joinTable}.${afk}`;
   const associationPrimaryKeyFull = `${getQueryAs(query)}.${apk}`;
-  const __model = Object.create(qb.__model);
-  __model.__model = __model;
-  __model.table = joinTable;
-  __model.shape = {
-    [fk]: model.shape[pk],
+  const __table = Object.create(qb.__table);
+  __table.__table = __table;
+  __table.table = joinTable;
+  __table.shape = {
+    [fk]: table.shape[pk],
     [afk]: query.shape[apk]
   };
-  const subQuery = Object.create(__model);
+  const subQuery = Object.create(__table);
   subQuery.query = __spreadValues$2({}, subQuery.query);
   const state = {
     relatedTableQuery: query,
@@ -615,7 +810,10 @@ const makeHasAndBelongsToManyMethod = (model, qb, relation, query) => {
     primaryKey: pk,
     foreignKey: fk,
     associationPrimaryKey: apk,
-    associationForeignKey: afk
+    associationForeignKey: afk,
+    foreignKeyFull,
+    associationForeignKeyFull,
+    associationPrimaryKeyFull
   };
   return {
     returns: "many",
@@ -627,144 +825,7 @@ const makeHasAndBelongsToManyMethod = (model, qb, relation, query) => {
         })
       );
     },
-    nestedInsert: async (q, data) => {
-      const connect = data.filter(
-        (item) => Boolean(item[1].connect)
-      );
-      const t = query.transacting(q);
-      let connected;
-      if (connect.length) {
-        connected = await Promise.all(
-          connect.flatMap(
-            ([, { connect: connect2 }]) => connect2.map((item) => t.select(apk)._findBy(item)._take())
-          )
-        );
-      } else {
-        connected = [];
-      }
-      const connectOrCreate = data.filter(
-        (item) => Boolean(item[1].connectOrCreate)
-      );
-      let connectOrCreated;
-      if (connectOrCreate.length) {
-        connectOrCreated = await Promise.all(
-          connectOrCreate.flatMap(
-            ([, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
-              (item) => t.select(apk)._findBy(item.where)._takeOptional()
-            )
-          )
-        );
-      } else {
-        connectOrCreated = [];
-      }
-      let connectOrCreateI = 0;
-      const create = data.filter(
-        (item) => {
-          if (item[1].connectOrCreate) {
-            const length = item[1].connectOrCreate.length;
-            connectOrCreateI += length;
-            for (let i = length; i > 0; i--) {
-              if (!connectOrCreated[connectOrCreateI - i])
-                return true;
-            }
-          }
-          return Boolean(item[1].create);
-        }
-      );
-      connectOrCreateI = 0;
-      let created;
-      if (create.length) {
-        created = await t.select(apk)._createMany(
-          create.flatMap(([, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => [
-            ...create2,
-            ...connectOrCreate2.filter(() => !connectOrCreated[connectOrCreateI++]).map((item) => item.create)
-          ])
-        );
-      } else {
-        created = [];
-      }
-      const allKeys = data;
-      let createI = 0;
-      let connectI = 0;
-      connectOrCreateI = 0;
-      data.forEach(([, data2], index) => {
-        if (data2.create || data2.connectOrCreate) {
-          if (data2.create) {
-            const len = data2.create.length;
-            allKeys[index][1] = created.slice(createI, createI + len);
-            createI += len;
-          }
-          if (data2.connectOrCreate) {
-            const arr = [];
-            allKeys[index][1] = arr;
-            const len = data2.connectOrCreate.length;
-            for (let i = 0; i < len; i++) {
-              const item = connectOrCreated[connectOrCreateI++];
-              if (item) {
-                arr.push(item);
-              } else {
-                arr.push(created[createI++]);
-              }
-            }
-          }
-        }
-        if (data2.connect) {
-          const len = data2.connect.length;
-          allKeys[index][1] = connected.slice(connectI, connectI + len);
-          connectI += len;
-        }
-      });
-      await subQuery.transacting(q)._count()._createMany(
-        allKeys.flatMap(([selfData, relationKeys]) => {
-          const selfKey = selfData[pk];
-          return relationKeys.map((relationData) => ({
-            [fk]: selfKey,
-            [afk]: relationData[apk]
-          }));
-        })
-      );
-    },
-    nestedUpdate: async (q, data, params) => {
-      if (params.create) {
-        const ids = await query.transacting(q)._pluck(apk)._createMany(params.create);
-        await subQuery.transacting(q)._createMany(
-          data.flatMap(
-            (item) => ids.map((id) => ({
-              [fk]: item[pk],
-              [afk]: id
-            }))
-          )
-        );
-      }
-      if (params.update) {
-        await query.transacting(q)._whereExists(
-          subQuery,
-          (q2) => q2._on(associationForeignKeyFull, associationPrimaryKeyFull)._where({
-            IN: {
-              columns: [foreignKeyFull],
-              values: [data.map((item) => item[pk])]
-            }
-          })
-        )._where(
-          Array.isArray(params.update.where) ? { OR: params.update.where } : params.update.where
-        )._update(params.update.data);
-      }
-      if (params.disconnect) {
-        await queryJoinTable(state, q, data, params.disconnect)._delete();
-      }
-      if (params.delete) {
-        const j = queryJoinTable(state, q, data, params.delete);
-        const ids = await j._pluck(afk)._delete();
-        await queryRelatedTable(query, q, { [apk]: { in: ids } })._delete();
-      }
-      if (params.set) {
-        const j = queryJoinTable(state, q, data);
-        await j._delete();
-        delete j.query[toSqlCacheKey];
-        const ids = await queryRelatedTable(query, q, params.set)._pluck(apk);
-        await insertToJoinTable(state, j, data, ids);
-      }
-    },
+    virtualColumn: new HasAndBelongsToManyVirtualColumn(relationName, state),
     joinQuery(fromQuery, toQuery) {
       return toQuery.whereExists(
         subQuery,
@@ -830,39 +891,201 @@ const insertToJoinTable = (state, joinTableTransaction, data, ids) => {
     )
   );
 };
+const nestedInsert = ({
+  relatedTableQuery,
+  joinTableQuery,
+  primaryKey,
+  foreignKey,
+  associationPrimaryKey,
+  associationForeignKey
+}) => {
+  return async (q, data) => {
+    const connect = data.filter(
+      (item) => Boolean(item[1].connect)
+    );
+    const t = relatedTableQuery.transacting(q);
+    let connected;
+    if (connect.length) {
+      connected = await Promise.all(
+        connect.flatMap(
+          ([, { connect: connect2 }]) => connect2.map(
+            (item) => t.select(associationPrimaryKey)._findBy(item)._take()
+          )
+        )
+      );
+    } else {
+      connected = [];
+    }
+    const connectOrCreate = data.filter(
+      (item) => Boolean(item[1].connectOrCreate)
+    );
+    let connectOrCreated;
+    if (connectOrCreate.length) {
+      connectOrCreated = await Promise.all(
+        connectOrCreate.flatMap(
+          ([, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
+            (item) => t.select(associationPrimaryKey)._findBy(item.where)._takeOptional()
+          )
+        )
+      );
+    } else {
+      connectOrCreated = [];
+    }
+    let connectOrCreateI = 0;
+    const create = data.filter(
+      (item) => {
+        if (item[1].connectOrCreate) {
+          const length = item[1].connectOrCreate.length;
+          connectOrCreateI += length;
+          for (let i = length; i > 0; i--) {
+            if (!connectOrCreated[connectOrCreateI - i])
+              return true;
+          }
+        }
+        return Boolean(item[1].create);
+      }
+    );
+    connectOrCreateI = 0;
+    let created;
+    if (create.length) {
+      created = await t.select(associationPrimaryKey)._createMany(
+        create.flatMap(([, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => [
+          ...create2,
+          ...connectOrCreate2.filter(() => !connectOrCreated[connectOrCreateI++]).map((item) => item.create)
+        ])
+      );
+    } else {
+      created = [];
+    }
+    const allKeys = data;
+    let createI = 0;
+    let connectI = 0;
+    connectOrCreateI = 0;
+    data.forEach(([, data2], index) => {
+      if (data2.create || data2.connectOrCreate) {
+        if (data2.create) {
+          const len = data2.create.length;
+          allKeys[index][1] = created.slice(createI, createI + len);
+          createI += len;
+        }
+        if (data2.connectOrCreate) {
+          const arr = [];
+          allKeys[index][1] = arr;
+          const len = data2.connectOrCreate.length;
+          for (let i = 0; i < len; i++) {
+            const item = connectOrCreated[connectOrCreateI++];
+            if (item) {
+              arr.push(item);
+            } else {
+              arr.push(created[createI++]);
+            }
+          }
+        }
+      }
+      if (data2.connect) {
+        const len = data2.connect.length;
+        allKeys[index][1] = connected.slice(connectI, connectI + len);
+        connectI += len;
+      }
+    });
+    await joinTableQuery.transacting(q)._count()._createMany(
+      allKeys.flatMap(([selfData, relationKeys]) => {
+        const selfKey = selfData[primaryKey];
+        return relationKeys.map((relationData) => ({
+          [foreignKey]: selfKey,
+          [associationForeignKey]: relationData[associationPrimaryKey]
+        }));
+      })
+    );
+  };
+};
+const nestedUpdate = (state) => {
+  return async (q, data, params) => {
+    if (params.create) {
+      const ids = await state.relatedTableQuery.transacting(q)._pluck(state.associationPrimaryKey)._createMany(params.create);
+      await state.joinTableQuery.transacting(q)._createMany(
+        data.flatMap(
+          (item) => ids.map((id) => ({
+            [state.foreignKey]: item[state.primaryKey],
+            [state.associationForeignKey]: id
+          }))
+        )
+      );
+    }
+    if (params.update) {
+      await state.relatedTableQuery.transacting(q)._whereExists(
+        state.joinTableQuery,
+        (q2) => q2._on(
+          state.associationForeignKeyFull,
+          state.associationPrimaryKeyFull
+        )._where({
+          IN: {
+            columns: [state.foreignKeyFull],
+            values: [data.map((item) => item[state.primaryKey])]
+          }
+        })
+      )._where(
+        Array.isArray(params.update.where) ? { OR: params.update.where } : params.update.where
+      )._update(params.update.data);
+    }
+    if (params.disconnect) {
+      await queryJoinTable(state, q, data, params.disconnect)._delete();
+    }
+    if (params.delete) {
+      const j = queryJoinTable(state, q, data, params.delete);
+      const ids = await j._pluck(state.associationForeignKey)._delete();
+      await queryRelatedTable(state.relatedTableQuery, q, {
+        [state.associationPrimaryKey]: { in: ids }
+      })._delete();
+    }
+    if (params.set) {
+      const j = queryJoinTable(state, q, data);
+      await j._delete();
+      delete j.query[toSqlCacheKey];
+      const ids = await queryRelatedTable(
+        state.relatedTableQuery,
+        q,
+        params.set
+      )._pluck(state.associationPrimaryKey);
+      await insertToJoinTable(state, j, data, ids);
+    }
+  };
+};
 
-const applyRelations = (qb, models, result) => {
-  const modelsEntries = Object.entries(models);
+const applyRelations = (qb, tables, result) => {
+  const tableEntries = Object.entries(tables);
   const delayedRelations = /* @__PURE__ */ new Map();
-  for (const modelName in models) {
-    const model = models[modelName];
-    if (!("relations" in model) || typeof model.relations !== "object")
+  for (const name in tables) {
+    const table = tables[name];
+    if (!("relations" in table) || typeof table.relations !== "object")
       continue;
-    const dbModel = result[modelName];
-    for (const relationName in model.relations) {
-      const relation = model.relations[relationName];
-      const otherModelClass = relation.fn();
-      const otherModel = modelsEntries.find(
-        (pair) => pair[1] instanceof otherModelClass
+    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 (!otherModel) {
-        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      if (!otherTable) {
+        throw new Error(
+          `Cannot find table class for class ${otherTableClass.name}`
+        );
       }
-      const otherModelName = otherModel[0];
-      const otherDbModel = result[otherModelName];
-      if (!otherDbModel)
-        throw new Error(`Cannot find model by name ${otherModelName}`);
+      const otherTableName = otherTable[0];
+      const otherDbTable = result[otherTableName];
+      if (!otherDbTable)
+        throw new Error(`Cannot find table class by name ${otherTableName}`);
       const data = {
         relationName,
         relation,
-        dbModel,
-        otherDbModel
+        dbTable,
+        otherDbTable
       };
       const options = relation.options;
       if (typeof options.through === "string" && typeof options.source === "string") {
-        const throughRelation = getThroughRelation(dbModel, options.through);
+        const throughRelation = getThroughRelation(dbTable, options.through);
         if (!throughRelation) {
-          delayRelation(delayedRelations, dbModel, options.through, data);
+          delayRelation(delayedRelations, dbTable, options.through, data);
           continue;
         }
         const sourceRelation = getSourceRelation(
@@ -872,7 +1095,7 @@ const applyRelations = (qb, models, result) => {
         if (!sourceRelation) {
           delayRelation(
             delayedRelations,
-            throughRelation.model,
+            throughRelation.table,
             options.source,
             data
           );
@@ -887,92 +1110,99 @@ const applyRelations = (qb, models, result) => {
     for (const key in value) {
       for (const item of value[key]) {
         const { relation } = item;
-        if (item.dbModel.relations[item.relationName])
+        if (item.dbTable.relations[item.relationName])
           continue;
-        const as = item.dbModel.definedAs;
+        const as = item.dbTable.definedAs;
         let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
-        const model = result[as];
+        const table = result[as];
         const { through, source } = relation.options;
-        const throughRel = model.relations[through];
+        const throughRel = table.relations[through];
         if (through && !throughRel) {
           message += `: cannot find \`${through}\` relation required by the \`through\` option`;
-        } else if (source && throughRel && !throughRel.model.relations[source]) {
-          message += `: cannot find \`${source}\` relation in \`${throughRel.model.definedAs}\` required by the \`source\` 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, model, relationName, data) => {
-  let modelRelations = delayedRelations.get(model);
-  if (!modelRelations) {
-    modelRelations = {};
-    delayedRelations.set(model, modelRelations);
+const delayRelation = (delayedRelations, table, relationName, data) => {
+  let tableRelations = delayedRelations.get(table);
+  if (!tableRelations) {
+    tableRelations = {};
+    delayedRelations.set(table, tableRelations);
   }
-  if (modelRelations[relationName]) {
-    modelRelations[relationName].push(data);
+  if (tableRelations[relationName]) {
+    tableRelations[relationName].push(data);
   } else {
-    modelRelations[relationName] = [data];
+    tableRelations[relationName] = [data];
   }
 };
-const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, delayedRelations) => {
+const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
   var _a;
-  const query = (relation.options.scope ? relation.options.scope(otherDbModel) : otherDbModel).as(relationName);
+  const query = (relation.options.scope ? relation.options.scope(otherDbTable) : otherDbTable).as(relationName);
   const definedAs = query.definedAs;
   if (!definedAs) {
     throw new Error(
-      `Model for table ${query.table} is not attached to db instance`
+      `Table class for table ${query.table} is not attached to db instance`
     );
   }
   const { type } = relation;
   let data;
   if (type === "belongsTo") {
-    data = makeBelongsToMethod(relation, query);
+    data = makeBelongsToMethod(relation, relationName, query);
   } else if (type === "hasOne") {
-    data = makeHasOneMethod(dbModel, relation, relationName, query);
+    data = makeHasOneMethod(dbTable, relation, relationName, query);
   } else if (type === "hasMany") {
-    data = makeHasManyMethod(dbModel, relation, relationName, query);
+    data = makeHasManyMethod(dbTable, relation, relationName, query);
   } else if (type === "hasAndBelongsToMany") {
-    data = makeHasAndBelongsToManyMethod(dbModel, qb, relation, query);
+    data = makeHasAndBelongsToManyMethod(
+      dbTable,
+      qb,
+      relation,
+      relationName,
+      query
+    );
   } else {
     throw new Error(`Unknown relation type ${type}`);
   }
   if (data.returns === "one") {
     query._take();
   }
-  makeRelationQuery(dbModel, definedAs, relationName, data);
-  dbModel.relations[relationName] = {
+  if (data.virtualColumn) {
+    dbTable.shape[relationName] = data.virtualColumn;
+  }
+  makeRelationQuery(dbTable, definedAs, relationName, data);
+  dbTable.relations[relationName] = {
     type,
     key: relationName,
-    model: otherDbModel,
+    table: otherDbTable,
     query,
-    nestedInsert: data.nestedInsert,
-    nestedUpdate: data.nestedUpdate,
     joinQuery: data.joinQuery,
     primaryKey: data.primaryKey,
     options: relation.options
   };
-  const modelRelations = delayedRelations.get(dbModel);
-  if (!modelRelations)
+  const tableRelations = delayedRelations.get(dbTable);
+  if (!tableRelations)
     return;
-  (_a = modelRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
+  (_a = tableRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
     applyRelation(qb, data2, delayedRelations);
   });
 };
-const makeRelationQuery = (model, definedAs, relationName, data) => {
-  Object.defineProperty(model, relationName, {
+const makeRelationQuery = (table, definedAs, relationName, data) => {
+  Object.defineProperty(table, relationName, {
     get() {
       var _a;
-      const toModel = this.db[definedAs].as(relationName);
+      const toTable = this.db[definedAs].as(relationName);
       if (data.returns === "one") {
-        toModel._take();
+        toTable._take();
       }
-      const query = this.isSubQuery ? toModel : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+      const query = this.isSubQuery ? toTable : toTable._whereExists(data.reverseJoin(this, toTable), (q) => q);
       query.query[relationQueryKey] = {
         relationName,
         sourceQuery: this,
-        relationQuery: toModel,
+        relationQuery: toTable,
         joinQuery: data.joinQuery
       };
       const setQuery = (_a = data.modifyRelatedQuery) == null ? void 0 : _a.call(data, query);
@@ -995,10 +1225,10 @@ function transaction(fn) {
     for (const key in this) {
       const value = this[key];
       if (value instanceof Db) {
-        const model = value.transacting(q);
-        model.__model = model;
-        model.db = orm;
-        orm[key] = model;
+        const table = value.transacting(q);
+        table.__table = table;
+        table.db = orm;
+        orm[key] = table;
       } else {
         orm[key] = value;
       }
@@ -1038,7 +1268,7 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-const orchidORM = (_a, models) => {
+const orchidORM = (_a, tables) => {
   var _b = _a, {
     log,
     logger,
@@ -1072,31 +1302,31 @@ const orchidORM = (_a, models) => {
     $queryBuilder: qb,
     $close: () => adapter.close()
   };
-  const modelInstances = {};
-  for (const key in models) {
+  const tableInstances = {};
+  for (const key in tables) {
     if (key[0] === "$") {
-      throw new Error(`Model name must not start with $`);
+      throw new Error(`Table class name must not start with $`);
     }
-    const model = new models[key]();
-    modelInstances[key] = model;
+    const table = new tables[key]();
+    tableInstances[key] = table;
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
-      schema: model.schema
+      schema: table.schema
     });
-    if (model.noPrimaryKey)
+    if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";
-    const dbModel = new Db(
+    const dbTable = new Db(
       adapter,
       qb,
-      model.table,
-      model.columns.shape,
-      model.columnTypes,
+      table.table,
+      table.columns.shape,
+      table.columnTypes,
       options2
     );
-    dbModel.definedAs = key;
-    dbModel.db = result;
-    result[key] = dbModel;
+    dbTable.definedAs = key;
+    dbTable.db = result;
+    result[key] = dbTable;
   }
-  applyRelations(qb, modelInstances, result);
+  applyRelations(qb, tableInstances, result);
   return result;
 };
 
@@ -1116,26 +1346,26 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const createRepo = (model, methods) => {
+const createRepo = (table, methods) => {
   const queryMethods = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
   const plainMethods = methods.methods;
   const repo = (q2) => {
-    const proto = Object.create(q2.__model);
-    proto.__model = proto;
+    const proto = Object.create(q2.__table);
+    proto.__table = proto;
     const result = Object.create(proto);
     result.query = getClonedQueryData(q2.query);
     if (plainMethods) {
-      Object.assign(proto.__model, plainMethods);
+      Object.assign(proto.__table, plainMethods);
     }
     for (const key in queryMethods) {
       const method = queryMethods[key];
-      proto.__model[key] = function(...args) {
+      proto.__table[key] = function(...args) {
         return method(this, ...args);
       };
     }
     return result;
   };
-  const q = repo(model);
+  const q = repo(table);
   return new Proxy(repo, {
     get(_, key) {
       return q[key];
@@ -1143,5 +1373,5 @@ const createRepo = (model, methods) => {
   });
 };
 
-export { createModel, createRepo, orchidORM };
+export { createBaseTable, createRepo, orchidORM };
 //# sourceMappingURL=index.esm.js.map