pqb 0.54.1 → 0.54.2

package/dist/index.js

@@ -432,7 +432,7 @@ class ColumnType extends orchidCore.ColumnTypeBase {
         return sql2;
       }
     });
-    column.data.readonly = true;
+    column.data.readOnly = true;
     return column;
   }
 }
@@ -2158,7 +2158,7 @@ class TsVectorColumn extends ColumnType {
       toSQL,
       toCode
     });
-    column.data.readonly = true;
+    column.data.readOnly = true;
     return column;
   }
 }
@@ -2458,8 +2458,7 @@ class VirtualColumn extends ColumnType {
     super(schema, inputSchema);
     this.dataType = "";
     this.operators = Operators.any;
-    this.data.explicitSelect = true;
-    this.data.insertable = this.data.updatable = false;
+    this.data.explicitSelect = this.data.appReadOnly = this.data.virtual = true;
   }
   toCode() {
     throw new Error(`toCode is not implemented for virtual column`);
@@ -2470,8 +2469,7 @@ const _UnknownColumn = class _UnknownColumn extends VirtualColumn {
   constructor(schema) {
     super(schema, schema.unknown());
     this.selectable = true;
-    this.data.explicitSelect = void 0;
-    this.data.insertable = this.data.updatable = true;
+    this.data.explicitSelect = this.data.appReadOnly = this.data.virtual = void 0;
   }
 };
 _UnknownColumn.instance = new _UnknownColumn(defaultSchemaConfig);
@@ -2730,8 +2728,9 @@ class NotFoundError extends OrchidOrmError {
 }
 _query = new WeakMap();
 class OrchidOrmInternalError extends Error {
-  constructor(query, message) {
+  constructor(query, message, data) {
     super(message);
+    this.data = data;
     // `#query` is private to prevent it from serializing to not cause problems to test runner reports
     __privateAdd(this, _query2);
     __privateSet(this, _query2, query);
@@ -3380,8 +3379,8 @@ const noneMethods = {
 const _queryNone = (q) => {
   if (isQueryNone(q)) return q;
   q = extendQuery(q, noneMethods);
-  pushQueryValueImmutable(q, "and", new RawSQL("false"));
-  pushQueryValueImmutable(
+  orchidCore.pushQueryValueImmutable(q, "and", new RawSQL("false"));
+  orchidCore.pushQueryValueImmutable(
     q,
     "transform",
     (_, queryData) => noneResult(q, queryData, queryData.returnType)
@@ -3405,11 +3404,7 @@ const resolveCallbacksInArgs = (q, args) => {
 };
 const _queryWhere = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return pushQueryArrayImmutable(
-    q,
-    "and",
-    args
-  );
+  return pushQueryArrayImmutable(q, "and", args);
 };
 const _queryFindBy = (q, args) => {
   return _queryTake(_queryWhere(q, args));
@@ -3418,7 +3413,7 @@ const _queryFindByOptional = (q, args) => {
   return _queryTakeOptional(_queryWhere(q, args));
 };
 const _queryWhereSql = (q, args) => {
-  return pushQueryValueImmutable(
+  return orchidCore.pushQueryValueImmutable(
     q,
     "and",
     sqlQueryArgsToExpression(args)
@@ -3426,24 +3421,24 @@ const _queryWhereSql = (q, args) => {
 };
 const _queryWhereNot = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     NOT: args
   });
 };
 const _queryWhereNotSql = (q, args) => {
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     NOT: sqlQueryArgsToExpression(args)
   });
 };
 const _queryWhereOneOf = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     OR: args
   });
 };
 const _queryWhereNotOneOf = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     NOT: { OR: args }
   });
 };
@@ -3493,9 +3488,9 @@ const _queryWhereIn = (q, and, arg, values, not) => {
   }
   if (not) item = { NOT: item };
   if (and) {
-    pushQueryValueImmutable(q, "and", item);
+    orchidCore.pushQueryValueImmutable(q, "and", item);
   } else {
-    pushQueryValueImmutable(q, "or", [item]);
+    orchidCore.pushQueryValueImmutable(q, "or", [item]);
   }
   return q;
 };
@@ -4299,10 +4294,6 @@ const pushQueryArrayImmutable = (q, key, value) => {
   q.q[key] = arr ? [...arr, ...value] : value;
   return q;
 };
-const pushQueryValueImmutable = (q, key, value) => {
-  orchidCore.pushOrNewArrayToObjectImmutable(q.q, key, value);
-  return q;
-};
 const setQueryObjectValueImmutable = (q, object, key, value) => {
   q.q[object] = {
     ...q.q[object],
@@ -4518,7 +4509,7 @@ const _join = (query, require, type, first, args) => {
       computeds
     );
   }
-  pushQueryValueImmutable(query, "join", {
+  orchidCore.pushQueryValueImmutable(query, "join", {
     type,
     args: joinArgs
   });
@@ -4595,7 +4586,7 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
   }
   as || (as = getQueryAs(arg));
   orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.computeds);
-  pushQueryValueImmutable(q, "join", {
+  orchidCore.pushQueryValueImmutable(q, "join", {
     type: `${type} LATERAL`,
     args: { l: arg, a: as, i: innerJoinLateral }
   });
@@ -4986,7 +4977,7 @@ const applyComputedColumns = (q, fn) => {
       const { data } = col;
       data.computed = item;
       data.explicitSelect = true;
-      data.readonly = true;
+      data.readOnly = true;
       addColumnParserToQuery(
         q.q,
         key,
@@ -5800,7 +5791,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
       );
     }
     if (query.hookSelect || query.parsers || query.transform) {
-      pushQueryValueImmutable(q, "batchParsers", {
+      orchidCore.pushQueryValueImmutable(q, "batchParsers", {
         path: [key],
         fn: (path, queryResult) => {
           const { rows } = queryResult;
@@ -6544,7 +6535,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     const { from, values: v } = values;
     const q2 = from.clone();
     if (v) {
-      pushQueryValueImmutable(
+      orchidCore.pushQueryValueImmutable(
         q2,
         "select",
         new RawSQL(
@@ -8802,7 +8793,7 @@ class WithMethods {
   withSql(name, ...args) {
     const q = _clone(this);
     const [options, shape, sql] = args.length === 2 ? [void 0, args[0], args[1]] : args;
-    pushQueryValueImmutable(q, "with", {
+    orchidCore.pushQueryValueImmutable(q, "with", {
       n: name,
       o: options,
       s: sql(q)
@@ -8825,38 +8816,50 @@ const processCreateItem = (q, item, rowIndex, ctx, encoders) => {
   var _a;
   const { shape } = q.q;
   for (const key in item) {
-    if (shape[key]?.data.insertable !== false) {
-      let value = item[key];
-      if (typeof value === "function") {
-        value = item[key] = resolveSubQueryCallbackV2(
-          q,
-          value
-        );
-        if (value && typeof value === "object" && value instanceof Db) {
-          moveQueryValueToWith(
-            q,
-            (_a = q.q).insertWith ?? (_a.insertWith = {}),
-            value,
-            item,
-            key,
-            rowIndex
-          );
-        }
-      }
-      if (!ctx.columns.has(key) && (shape[key] && !shape[key].data.readonly || shape === anyShape) && value !== void 0) {
-        ctx.columns.set(key, ctx.columns.size);
-        encoders[key] = shape[key]?.data.encode;
-      }
-    } else if (shape[key] instanceof VirtualColumn) {
-      shape[key].create?.(
+    const column = shape[key];
+    if (!column) continue;
+    if (column.data.virtual) {
+      column.create?.(
         q,
         ctx,
         item,
         rowIndex
       );
+      continue;
+    }
+    throwOnReadOnly$1(q, column, key);
+    let value = item[key];
+    if (typeof value === "function") {
+      value = item[key] = resolveSubQueryCallbackV2(
+        q,
+        value
+      );
+      if (value && typeof value === "object" && value instanceof Db) {
+        moveQueryValueToWith(
+          q,
+          (_a = q.q).insertWith ?? (_a.insertWith = {}),
+          value,
+          item,
+          key,
+          rowIndex
+        );
+      }
+    }
+    if (!ctx.columns.has(key) && (column && !column.data.readOnly || shape === anyShape) && value !== void 0) {
+      ctx.columns.set(key, ctx.columns.size);
+      encoders[key] = column?.data.encode;
     }
   }
 };
+const throwOnReadOnly$1 = (q, column, key) => {
+  if (column.data.appReadOnly || column.data.readOnly) {
+    throw new OrchidOrmInternalError(
+      q,
+      "Trying to insert a readonly column",
+      { column: key }
+    );
+  }
+};
 const createCtx = () => ({
   columns: /* @__PURE__ */ new Map(),
   resultAll: void 0
@@ -8930,7 +8933,7 @@ const insert = (self, {
   }
   return self;
 };
-const getFromSelectColumns = (from, obj, many) => {
+const getFromSelectColumns = (q, from, obj, many) => {
   if (!many && !queryTypeWithLimitOne[from.q.returnType]) {
     throw new Error(
       "Cannot create based on a query which returns multiple records"
@@ -8948,12 +8951,16 @@ const getFromSelectColumns = (from, obj, many) => {
   if (obj?.columns) {
     queryColumns.push(...obj.columns);
   }
+  for (const key of queryColumns) {
+    const column = q.shape[key];
+    if (column) throwOnReadOnly$1(from, column, key);
+  }
   return queryColumns;
 };
 const insertFromQuery = (q, from, many, data) => {
   const ctx = createCtx();
   const obj = data && handleOneData(q, data, ctx);
-  const columns = getFromSelectColumns(from, obj, many);
+  const columns = getFromSelectColumns(q, from, obj, many);
   return insert(
     q,
     {
@@ -8972,7 +8979,7 @@ const _queryInsert = (q, data) => {
   const obj = handleOneData(q, data, ctx);
   const values = q.q.values;
   if (values && "from" in values) {
-    obj.columns = getFromSelectColumns(values.from, obj);
+    obj.columns = getFromSelectColumns(q, values.from, obj);
     values.values = obj.values[0];
     obj.values = values;
   }
@@ -9006,7 +9013,7 @@ const _queryDefaults = (q, data) => {
   q.q.defaults = data;
   return q;
 };
-class Create {
+class QueryCreate {
   /**
    * `create` and `insert` create a single record.
    *
@@ -9410,6 +9417,8 @@ class OnConflictQueryBuilder {
   set(set) {
     let resolved;
     for (const key in set) {
+      const column = this.query.shape[key];
+      if (column) throwOnReadOnly$1(this.query, column, key);
       if (typeof set[key] === "function") {
         if (!resolved) resolved = { ...set };
         resolved[key] = set[key]();
@@ -9679,7 +9688,7 @@ class Having {
    */
   having(...args) {
     const q = _clone(this);
-    return pushQueryValueImmutable(
+    return orchidCore.pushQueryValueImmutable(
       q,
       "having",
       args.map((arg) => arg(q).q.expr)
@@ -9695,14 +9704,18 @@ class Having {
    * @param args - SQL expression
    */
   havingSql(...args) {
-    return pushQueryValueImmutable(_clone(this), "having", args);
+    return orchidCore.pushQueryValueImmutable(_clone(this), "having", args);
   }
 }
 
-const before = (q, key, cb) => pushQueryValueImmutable(q, `before${key}`, cb);
+const before = (q, key, cb) => orchidCore.pushQueryValueImmutable(q, `before${key}`, cb);
 const after = (query, key, select, cb, commit) => {
   const q = query;
-  pushQueryValueImmutable(q, `after${key}${commit ? "Commit" : ""}`, cb);
+  orchidCore.pushQueryValueImmutable(
+    q,
+    `after${key}${commit ? "Commit" : ""}`,
+    cb
+  );
   const prop = `after${key}Select`;
   const set = q.q[prop] = new Set(q.q[prop]);
   for (const column of select) {
@@ -9711,13 +9724,19 @@ const after = (query, key, select, cb, commit) => {
   return query;
 };
 const _queryHookBeforeQuery = (q, cb) => {
-  return pushQueryValueImmutable(q, "before", cb);
+  return orchidCore.pushQueryValueImmutable(q, "before", cb);
 };
 const _queryHookAfterQuery = (q, cb) => {
-  return pushQueryValueImmutable(q, "after", cb);
+  return orchidCore.pushQueryValueImmutable(q, "after", cb);
 };
 const _queryHookBeforeCreate = (q, cb) => {
-  return before(q, "Create", (q2) => cb(new QueryHookUtils(q2, "hookCreateSet")));
+  return before(
+    q,
+    "Create",
+    (q2) => cb(
+      new orchidCore.QueryHookUtils(q2, q2.q.columns, "hookCreateSet")
+    )
+  );
 };
 const _queryHookAfterCreate = (q, select, cb) => {
   return after(q, "Create", select, cb);
@@ -9726,7 +9745,15 @@ const _queryHookAfterCreateCommit = (q, select, cb) => {
   return after(q, "Create", select, cb, true);
 };
 const _queryHookBeforeUpdate = (q, cb) => {
-  return before(q, "Update", (q2) => cb(new QueryHookUtils(q2, "hookUpdateSet")));
+  return before(q, "Update", (q2) => {
+    const columns = [];
+    for (const item of q2.q.updateData) {
+      if (typeof item === "object") {
+        columns.push(...Object.keys(item));
+      }
+    }
+    return cb(new orchidCore.QueryHookUtils(q2, columns, "hookUpdateSet"));
+  });
 };
 const _queryHookAfterUpdate = (q, select, cb) => {
   return after(q, "Update", select, cb);
@@ -9735,11 +9762,7 @@ const _queryHookAfterUpdateCommit = (q, select, cb) => {
   return after(q, "Update", select, cb, true);
 };
 const _queryHookBeforeSave = (q, cb) => {
-  return before(
-    before(q, "Create", (q2) => cb(new QueryHookUtils(q2, "hookCreateSet"))),
-    "Update",
-    (q2) => cb(new QueryHookUtils(q2, "hookUpdateSet"))
-  );
+  return _queryHookBeforeUpdate(_queryHookBeforeCreate(q, cb), cb);
 };
 const _queryHookAfterSave = (q, select, cb) => {
   return after(after(q, "Create", select, cb), "Update", select, cb);
@@ -9762,21 +9785,6 @@ const _queryHookAfterDelete = (q, select, cb) => {
 const _queryHookAfterDeleteCommit = (q, select, cb) => {
   return after(q, "Delete", select, cb, true);
 };
-class QueryHookUtils {
-  constructor(query, key) {
-    this.query = query;
-    this.key = key;
-    this.set = (data) => {
-      const set = {};
-      for (const key in data) {
-        if (data[key] !== void 0) {
-          set[key] = data[key];
-        }
-      }
-      pushQueryValueImmutable(this.query, this.key, set);
-    };
-  }
-}
 class QueryHooks {
   /**
    * Run the function before any kind of query.
@@ -9959,7 +9967,7 @@ class QueryHooks {
    */
   catchAfterCommitError(fn) {
     const q = _clone(this);
-    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
+    orchidCore.pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
     return q;
   }
 }
@@ -10641,7 +10649,7 @@ const makeOnItem = (joinTo, joinFrom, args) => ({
   }
 });
 const pushQueryOnForOuter = (q, joinFrom, joinTo, leftColumn, rightColumn) => {
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     ON: {
       joinFrom: joinTo,
       from: leftColumn,
@@ -10652,14 +10660,14 @@ const pushQueryOnForOuter = (q, joinFrom, joinTo, leftColumn, rightColumn) => {
   });
 };
 const pushQueryOn = (q, joinFrom, joinTo, ...on) => {
-  return pushQueryValueImmutable(
+  return orchidCore.pushQueryValueImmutable(
     q,
     "and",
     makeOnItem(joinFrom, joinTo, on)
   );
 };
 const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
-  return pushQueryValueImmutable(q, "or", [
+  return orchidCore.pushQueryValueImmutable(q, "or", [
     makeOnItem(joinFrom, joinTo, on)
   ]);
 };
@@ -10691,7 +10699,7 @@ const _queryJoinOrOn = (q, args) => {
   );
 };
 const _queryJoinOnJsonPathEquals = (q, args) => {
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     ON: args
   });
 };
@@ -10807,6 +10815,15 @@ class MergeQueryMethods {
   }
 }
 
+const throwOnReadOnly = (q, column, key) => {
+  if (column.data.appReadOnly || column.data.readOnly) {
+    throw new OrchidOrmInternalError(
+      q,
+      "Trying to update a readonly column",
+      { column: key }
+    );
+  }
+};
 const _queryChangeCounter = (self, op, data) => {
   const q = self.q;
   q.type = "update";
@@ -10823,11 +10840,19 @@ const _queryChangeCounter = (self, op, data) => {
     map = {};
     for (const key in data) {
       map[key] = { op, arg: data[key] };
+      const column = self.shape[key];
+      if (column) {
+        throwOnReadOnly(self, column, key);
+      }
     }
   } else {
     map = { [data]: { op, arg: 1 } };
+    const column = self.shape[data];
+    if (column) {
+      throwOnReadOnly(self, column, data);
+    }
   }
-  pushQueryValueImmutable(self, "updateData", map);
+  orchidCore.pushQueryValueImmutable(self, "updateData", map);
   return self;
 };
 const update = (self) => {
@@ -10844,17 +10869,18 @@ const update = (self) => {
 const _queryUpdate = (query, arg) => {
   const { q } = query;
   const set = { ...arg };
-  pushQueryValueImmutable(query, "updateData", set);
+  orchidCore.pushQueryValueImmutable(query, "updateData", set);
   const { shape } = q;
   const ctx = {};
   for (const key in arg) {
     const item = shape[key];
-    if (item instanceof VirtualColumn && item.update) {
-      item.update(query, ctx, set);
+    if (!item && shape !== anyShape) {
       delete set[key];
-    } else if ((!shape[key] || shape[key].data.readonly) && shape !== anyShape) {
+    } else if (item.data.virtual) {
+      item.update?.(query, ctx, set);
       delete set[key];
     } else {
+      if (item) throwOnReadOnly(query, item, key);
       let value = set[key];
       if (typeof value === "function") {
         value = resolveSubQueryCallbackV2(
@@ -10880,7 +10906,7 @@ const _queryUpdate = (query, arg) => {
             "with"
           );
         } else {
-          const encode = shape[key].data.encode;
+          const encode = item?.data.encode;
           if (encode) set[key] = encode(value);
         }
       }
@@ -11458,9 +11484,9 @@ class SearchMethods {
     }
     setQueryObjectValueImmutable(q, "sources", arg.as, arg);
     if (arg.order) {
-      pushQueryValueImmutable(q, "order", arg.as);
+      orchidCore.pushQueryValueImmutable(q, "order", arg.as);
     }
-    return pushQueryValueImmutable(q, "and", { SEARCH: arg });
+    return orchidCore.pushQueryValueImmutable(q, "and", { SEARCH: arg });
   }
 }
 
@@ -11550,109 +11576,13 @@ function orCreate(query, data, updateData, mergeData) {
   };
   return query;
 }
-class QueryUpsertOrCreate {
-  /**
-   * `upsert` tries to update a single record, and then it creates the record if it doesn't yet exist.
-   *
-   * `find` or `findBy` must precede `upsert` because it does not work with multiple updates.
-   *
-   * In case more than one row was updated, it will throw `MoreThanOneRowError` and the transaction will be rolled back.
-   *
-   * It can take `update` and `create` objects, then they are used separately for update and create queries.
-   * Or, it can take `data` and `create` objects, `data` will be used for update and be mixed to `create` object.
-   *
-   * `data` and `update` objects are of the same type that's expected by `update` method, `create` object is of type of `create` method argument.
-   *
-   * No values are returned by default, place `select` or `selectAll` before `upsert` to specify returning columns.
-   *
-   * ```ts
-   * await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .upsert({
-   *     data: {
-   *       // update record's name
-   *       name: 'new name',
-   *       // supports sql and nested queries
-   *       fromSQL: () => sql`*SQL expression*`,
-   *       fromQuery: () => db.someTable.create(data).get('column'),
-   *     },
-   *     create: {
-   *       // create a new record with this email and a name 'new name'
-   *       email: 'some@email.com',
-   *       // supports sql and nested queries as well
-   *     },
-   *     create: {
-   *       // create a new record with this email and a name 'new name'
-   *       email: 'some@email.com',
-   *     },
-   *   });
-   *
-   * // the same as above but using `update` and `create`
-   * await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .upsert({
-   *     update: {
-   *       name: 'updated user',
-   *     },
-   *     create: {
-   *       email: 'some@email.com',
-   *       // here we use a different name when creating a record
-   *       name: 'created user',
-   *     },
-   *   });
-   * ```
-   *
-   * The data for `create` may be returned from a function, it won't be called if a record was updated:
-   *
-   * ```ts
-   * await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .upsert({
-   *     update: {
-   *       name: 'updated user',
-   *     },
-   *     create: () => ({
-   *       email: 'some@email.com',
-   *       name: 'created user',
-   *     }),
-   *   });
-   *
-   * // the same as above using `data`
-   * await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .upsert({
-   *     data: {
-   *       name: 'updated user',
-   *     },
-   *     create: () => ({
-   *       email: 'some@email.com',
-   *       // name in `create` is overriding the name from `data`
-   *       name: 'created user',
-   *     }),
-   *   });
-   * ```
-   *
-   * Data from `data` or `update` is passed to the `create` function and can be used:
-   *
-   * ```ts
-   * const user = await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .upsert({
-   *     data: {
-   *       name: 'updated user',
-   *     },
-   *     // `updateData` has the exact type of what is passed to `data`
-   *     create: (updateData) => ({
-   *       email: `${updateData.name}@email.com`,
-   *     }),
-   *   });
-   * ```
-   *
-   * `upsert` works in the exact same way as [orCreate](#orCreate), but with `UPDATE` statement instead of `SELECT`.
-   * it also performs a single query if the record exists, and two queries if there is no record yet.
-   *
-   * @param data - `update` property for the data to update, `create` property for the data to create
-   */
+const QueryOrCreate = {
+  orCreate(data) {
+    return orCreate(_clone(this), data);
+  }
+};
+
+const QueryUpsert = {
   upsert(data) {
     const q = _clone(this);
     let updateData;
@@ -11667,75 +11597,7 @@ class QueryUpsertOrCreate {
     }
     return orCreate(q, data.create, updateData, mergeData);
   }
-  /**
-   * `orCreate` creates a record only if it was not found by conditions.
-   *
-   * `find` or `findBy` must precede `orCreate`.
-   *
-   * It is accepting the same argument as `create` commands.
-   *
-   * No result is returned by default, place `get`, `select`, or `selectAll` before `orCreate` to specify returning columns.
-   *
-   * ```ts
-   * const user = await db.user
-   *   .selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .orCreate({
-   *     email: 'some@email.com',
-   *     name: 'created user',
-   *     // supports sql and nested queries
-   *     fromSQL: () => sql`*SQL expression*`,
-   *     fromQuery: () => db.someTable.create(data).get('column'),
-   *     fromRelated: (q) => q.relatedTable.update(data).get('column'),
-   *   });
-   * ```
-   *
-   * The data can be returned from a function, it won't be called if the record was found:
-   *
-   * ```ts
-   * const user = await User.selectAll()
-   *   .findBy({ email: 'some@email.com' })
-   *   .orCreate(() => ({
-   *     email: 'some@email.com',
-   *     name: 'created user',
-   *   }));
-   * ```
-   *
-   * `orCreate` works by performing just a single query in the case if the record exists, and one additional query when the record does not exist.
-   *
-   * At first, it performs a "find" query, the query cost is exact same as if you didn't use `orCreate`.
-   *
-   * Then, if the record wasn't found, it performs a single query with CTE expressions to try finding it again, for the case it was already created just a moment before,
-   * and then it creates the record if it's still not found. Using such CTE allows to skip using transactions, while still conforming to atomicity.
-   *
-   * ```sql
-   * -- first query
-   * SELECT * FROM "table" WHERE "key" = 'value'
-   *
-   * -- the record could have been created in between these two queries
-   *
-   * -- second query
-   * WITH find_row AS (
-   *   SELECT * FROM "table" WHERE "key" = 'value'
-   * )
-   * WITH insert_row AS (
-   *   INSERT INTO "table" ("key")
-   *   SELECT 'value'
-   *   -- skip the insert if the row already exists
-   *   WHERE NOT EXISTS (SELECT 1 FROM find_row)
-   *   RETURNING *
-   * )
-   * SELECT * FROM find_row
-   * UNION ALL
-   * SELECT * FROM insert_row
-   * ```
-   *
-   * @param data - the same data as for `create`, it may be returned from a callback
-   */
-  orCreate(data) {
-    return orCreate(_clone(this), data);
-  }
-}
+};
 
 class SqlMethod {
   sql(...args) {
@@ -11800,7 +11662,7 @@ class TransformMethods {
    * @param fn - function to transform query result with
    */
   transform(fn) {
-    return pushQueryValueImmutable(_clone(this), "transform", fn);
+    return orchidCore.pushQueryValueImmutable(_clone(this), "transform", fn);
   }
 }
 
@@ -11846,7 +11708,7 @@ class QueryMap {
    * @param fn - function to transform an individual record
    */
   map(fn) {
-    return pushQueryValueImmutable(_clone(this), "transform", {
+    return orchidCore.pushQueryValueImmutable(_clone(this), "transform", {
       map: fn
     });
   }
@@ -12475,7 +12337,7 @@ class QueryMethods {
    * @param arg - window config
    */
   window(arg) {
-    return pushQueryValueImmutable(_clone(this), "window", arg);
+    return orchidCore.pushQueryValueImmutable(_clone(this), "window", arg);
   }
   wrap(query, as) {
     return queryWrap(this, _clone(query), as);
@@ -12530,7 +12392,7 @@ class QueryMethods {
    * @param args - SQL expression
    */
   orderSql(...args) {
-    return pushQueryValueImmutable(
+    return orchidCore.pushQueryValueImmutable(
       _clone(this),
       "order",
       sqlQueryArgsToExpression(args)
@@ -12819,6 +12681,8 @@ class QueryMethods {
     return _chain(this, _clone(rel.query), rel);
   }
 }
+Object.assign(QueryMethods.prototype, QueryUpsert);
+Object.assign(QueryMethods.prototype, QueryOrCreate);
 orchidCore.applyMixins(QueryMethods, [
   AsMethods,
   AggregateMethods,
@@ -12829,7 +12693,7 @@ orchidCore.applyMixins(QueryMethods, [
   WithMethods,
   Union,
   JsonMethods,
-  Create,
+  QueryCreate,
   Update,
   Delete,
   Transaction,
@@ -12841,7 +12705,6 @@ orchidCore.applyMixins(QueryMethods, [
   Then,
   QueryLog,
   QueryHooks,
-  QueryUpsertOrCreate,
   QueryGet,
   MergeQueryMethods,
   SqlMethod,
@@ -13017,6 +12880,7 @@ class Db extends QueryMethods {
     let hasParsers = false;
     let modifyQuery = void 0;
     let prepareSelectAll = false;
+    let hasHookSetters;
     const { snakeCase } = options;
     for (const key in shape) {
       const column = shape[key];
@@ -13052,6 +12916,9 @@ class Db extends QueryMethods {
           column.data.runtimeDefault = encode ? () => encode(def()) : def;
         }
       }
+      if (column.data.setOnCreate || column.data.setOnUpdate || column.data.setOnSave) {
+        hasHookSetters = true;
+      }
     }
     this.q = {
       adapter,
@@ -13126,6 +12993,27 @@ class Db extends QueryMethods {
     if (softDelete) {
       enableSoftDelete(this, table, shape, softDelete, scopes);
     }
+    if (hasHookSetters) {
+      const hooks = {
+        setOnCreate: _queryHookBeforeCreate,
+        setOnUpdate: _queryHookBeforeUpdate,
+        setOnSave: _queryHookBeforeSave
+      };
+      for (const key in shape) {
+        const { data } = shape[key];
+        for (const hookKey in hooks) {
+          const fn = data[hookKey];
+          if (fn) {
+            hooks[hookKey](this, (arg) => {
+              const value = fn(arg);
+              if (value !== void 0) {
+                arg.set({ [key]: value });
+              }
+            });
+          }
+        }
+      }
+    }
   }
   [node_util.inspect.custom]() {
     return `Query<${this.table}>`;
@@ -13478,7 +13366,6 @@ exports.Clear = Clear;
 exports.ColumnRefExpression = ColumnRefExpression;
 exports.ColumnType = ColumnType;
 exports.ComputedColumn = ComputedColumn;
-exports.Create = Create;
 exports.CustomTypeColumn = CustomTypeColumn;
 exports.DateBaseColumn = DateBaseColumn;
 exports.DateColumn = DateColumn;
@@ -13525,13 +13412,13 @@ exports.PathColumn = PathColumn;
 exports.PointColumn = PointColumn;
 exports.PolygonColumn = PolygonColumn;
 exports.PostgisGeographyPointColumn = PostgisGeographyPointColumn;
+exports.QueryCreate = QueryCreate;
 exports.QueryError = QueryError;
 exports.QueryGet = QueryGet;
-exports.QueryHookUtils = QueryHookUtils;
 exports.QueryHooks = QueryHooks;
 exports.QueryLog = QueryLog;
 exports.QueryMethods = QueryMethods;
-exports.QueryUpsertOrCreate = QueryUpsertOrCreate;
+exports.QueryUpsert = QueryUpsert;
 exports.RawSQL = RawSQL;
 exports.RealColumn = RealColumn;
 exports.RefExpression = RefExpression;
@@ -13686,7 +13573,6 @@ exports.pushQueryArrayImmutable = pushQueryArrayImmutable;
 exports.pushQueryOn = pushQueryOn;
 exports.pushQueryOnForOuter = pushQueryOnForOuter;
 exports.pushQueryOrOn = pushQueryOrOn;
-exports.pushQueryValueImmutable = pushQueryValueImmutable;
 exports.pushTableDataCode = pushTableDataCode;
 exports.queryFrom = queryFrom;
 exports.queryFromSql = queryFromSql;