pqb 0.54.0 → 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;
@@ -6240,6 +6231,8 @@ function _querySelect(q, args) {
     q.q.returnType = q.q.returningMany ? "all" : "oneOrThrow";
   } else if (returnType === "value") {
     q.q.returnType = q.q.returningMany ? "all" : "one";
+  } else if (returnType === "void") {
+    q.q.returnType = q.q.returningMany ? "all" : "oneOrThrow";
   }
   const len = args.length;
   if (!len) {
@@ -6429,7 +6422,22 @@ const pushWithSql = (ctx, items) => {
 };
 
 const makeInsertSql = (ctx, q, query, quotedAs) => {
-  const { columns, shape, inCTE } = query;
+  let { columns } = query;
+  const { shape, inCTE, hookCreateSet } = query;
+  const QueryClass = ctx.qb.constructor;
+  let values = query.values;
+  let hookSetSql;
+  if (hookCreateSet) {
+    ({ hookSetSql, columns, values } = processHookSet(
+      ctx,
+      q,
+      values,
+      hookCreateSet,
+      columns,
+      QueryClass,
+      quotedAs
+    ));
+  }
   const quotedColumns = columns.map(
     (column) => `"${shape[column]?.data.name || column}"`
   );
@@ -6444,7 +6452,6 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
       }
     }
   }
-  let values = query.values;
   if (quotedColumns.length === 0) {
     const key = Object.keys(q.shape)[0];
     if (key) {
@@ -6456,12 +6463,11 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     }
   }
   const insertSql = `INSERT INTO ${quotedAs}${quotedColumns.length ? "(" + quotedColumns.join(", ") + ")" : ""}`;
-  if (query.kind !== "object" && query.insertWith) {
+  if ("from" in values && query.insertWith) {
     pushWithSql(ctx, Object.values(query.insertWith).flat());
   }
   const valuesPos = ctx.sql.length + 1;
   ctx.sql.push(insertSql, null);
-  const QueryClass = ctx.qb.constructor;
   if (query.onConflict) {
     ctx.sql.push("ON CONFLICT");
     const { target } = query.onConflict;
@@ -6525,7 +6531,28 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     returning = makeReturningSql(ctx, q, query, quotedAs, 2);
   }
   if (returning.select) ctx.sql.push("RETURNING", returning.select);
-  if (query.kind === "object") {
+  if ("from" in values) {
+    const { from, values: v } = values;
+    const q2 = from.clone();
+    if (v) {
+      orchidCore.pushQueryValueImmutable(
+        q2,
+        "select",
+        new RawSQL(
+          encodeRow(
+            ctx,
+            ctx.values,
+            q2,
+            QueryClass,
+            v,
+            runtimeDefaults,
+            quotedAs
+          )
+        )
+      );
+    }
+    ctx.sql[valuesPos] = getSqlText(toSQL(q2, { values: ctx.values }));
+  } else {
     const valuesSql = [];
     let ctxValues = ctx.values;
     const restValuesLen = ctxValues.length;
@@ -6546,7 +6573,8 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
         QueryClass,
         values[i],
         runtimeDefaults,
-        quotedAs
+        quotedAs,
+        hookSetSql
       );
       if (!inCTE) encodedRow = "(" + encodedRow + ")";
       if (ctxValues.length > MAX_BINDING_PARAMS) {
@@ -6595,32 +6623,127 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     if (inCTE) {
       ctx.sql[valuesPos] += ' WHERE NOT EXISTS (SELECT 1 FROM "f")';
     }
-  } else {
-    const { from, values: v } = values;
-    const q2 = from.clone();
-    if (v) {
-      pushQueryValueImmutable(
-        q2,
-        "select",
-        new RawSQL(
-          encodeRow(
+  }
+  return {
+    hookSelect: returning.hookSelect,
+    text: ctx.sql.join(" "),
+    values: ctx.values
+  };
+};
+const processHookSet = (ctx, q, values, hookCreateSet, columns, QueryClass, quotedAs) => {
+  const hookSet = {};
+  for (const item of hookCreateSet) {
+    Object.assign(hookSet, item);
+  }
+  const addHookSetColumns = Object.keys(hookSet).filter(
+    (key) => !columns.includes(key)
+  );
+  if ("from" in values) {
+    const v = { ...values };
+    const newColumns = [];
+    const originalSelect = v.from.q.select;
+    if (originalSelect) {
+      v.from = _clone(v.from);
+      const select = [];
+      for (const s of originalSelect) {
+        if (typeof s === "string" && !hookSet[s]) {
+          select.push(s);
+          newColumns.push(s);
+        } else if (typeof s === "object" && "selectAs" in s) {
+          const filtered = {};
+          for (const key in s.selectAs) {
+            if (!hookSet[key]) {
+              filtered[key] = s.selectAs[key];
+              newColumns.push(key);
+            }
+          }
+          select.push({ selectAs: filtered });
+        }
+      }
+      v.from.q.select = select;
+    }
+    let row;
+    if (v.values) {
+      const originalRow = v.values;
+      const valuesColumns = columns.slice(-originalRow.length);
+      row = [];
+      valuesColumns.forEach((c, i) => {
+        if (!hookSet[c]) {
+          newColumns.push(c);
+          row.push(originalRow[i]);
+        }
+      });
+    } else {
+      row = [];
+    }
+    v.values = row;
+    columns.forEach((column) => {
+      if (column in hookSet) {
+        newColumns.push(column);
+        const fromHook = {
+          fromHook: encodeValue(
             ctx,
             ctx.values,
-            q2,
+            q,
             QueryClass,
-            v[0],
-            runtimeDefaults,
+            hookSet[column],
             quotedAs
           )
-        )
-      );
+        };
+        row.push(fromHook);
+      }
+    });
+    if (addHookSetColumns) {
+      for (const key of addHookSetColumns) {
+        row.push({
+          fromHook: encodeValue(
+            ctx,
+            ctx.values,
+            q,
+            QueryClass,
+            hookSet[key],
+            quotedAs
+          )
+        });
+      }
+      return {
+        columns: [...newColumns, ...addHookSetColumns],
+        values: v
+      };
     }
-    ctx.sql[valuesPos] = getSqlText(toSQL(q2, { values: ctx.values }));
+    return { columns: newColumns, values: v };
   }
+  columns.forEach((column, i) => {
+    if (column in hookSet) {
+      const fromHook = {
+        fromHook: encodeValue(
+          ctx,
+          ctx.values,
+          q,
+          QueryClass,
+          hookSet[column],
+          quotedAs
+        )
+      };
+      for (const row of values) {
+        row[i] = fromHook;
+      }
+    }
+  });
+  const hookSetSql = addHookSetColumns.map(
+    (key) => encodeValue(
+      ctx,
+      ctx.values,
+      q,
+      QueryClass,
+      hookSet[key],
+      quotedAs
+    )
+  ).join(", ");
   return {
-    hookSelect: returning.hookSelect,
-    text: ctx.sql.join(" "),
-    values: ctx.values
+    hookSetSql,
+    columns: addHookSetColumns ? [...columns, ...addHookSetColumns] : columns,
+    values
   };
 };
 const mergeColumnsSql = (columns, quotedColumns, target, except) => {
@@ -6644,24 +6767,30 @@ const mergeColumnsSql = (columns, quotedColumns, target, except) => {
     `DO UPDATE SET ${quotedColumns[0]} = excluded.${quotedColumns[0]}`
   );
 };
-const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs) => {
-  const arr = row.map((value) => {
-    if (value && typeof value === "object") {
-      if (value instanceof orchidCore.Expression) {
-        return value.toSQL(ctx, quotedAs);
-      } else if (value instanceof QueryClass) {
-        return `(${getSqlText(joinSubQuery(q, value).toSQL(ctx))})`;
-      }
-    }
-    return value === void 0 ? "DEFAULT" : orchidCore.addValue(values, value);
-  });
+const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs, hookSetSql) => {
+  const arr = row.map(
+    (value) => encodeValue(ctx, values, q, QueryClass, value, quotedAs)
+  );
   if (runtimeDefaults) {
     for (const fn of runtimeDefaults) {
       arr.push(orchidCore.addValue(values, fn()));
     }
   }
+  if (hookSetSql) arr.push(hookSetSql);
   return arr.join(", ");
 };
+const encodeValue = (ctx, values, q, QueryClass, value, quotedAs) => {
+  if (value && typeof value === "object") {
+    if (value instanceof orchidCore.Expression) {
+      return value.toSQL(ctx, quotedAs);
+    } else if (value instanceof QueryClass) {
+      return `(${getSqlText(joinSubQuery(q, value).toSQL(ctx))})`;
+    } else if ("fromHook" in value) {
+      return value.fromHook;
+    }
+  }
+  return value === void 0 ? "DEFAULT" : orchidCore.addValue(values, value);
+};
 const hookSelectKeys = [
   null,
   "afterUpdateSelect",
@@ -7240,8 +7369,20 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
     query.schema,
     table.table || query.from
   );
+  let hookSet;
+  if (query.hookUpdateSet) {
+    hookSet = {};
+    for (const item of query.hookUpdateSet) {
+      Object.assign(hookSet, item);
+    }
+  } else {
+    hookSet = orchidCore.emptyObject;
+  }
   const set = [];
-  processData(ctx, table, set, query.updateData, quotedAs);
+  processData(ctx, table, set, query.updateData, hookSet, quotedAs);
+  if (query.hookUpdateSet) {
+    applySet(ctx, table, set, hookSet, orchidCore.emptyObject, quotedAs);
+  }
   if (!set.length) {
     if (!query.select) {
       query.select = countSelect;
@@ -7281,32 +7422,35 @@ const pushUpdateReturning = (ctx, table, query, quotedAs, keyword) => {
   if (s) ctx.sql.push(keyword, s);
   return hookSelect;
 };
-const processData = (ctx, table, set, data, quotedAs) => {
+const processData = (ctx, table, set, data, hookSet, quotedAs) => {
   let append;
-  const QueryClass = ctx.qb.constructor;
   for (const item of data) {
     if (typeof item === "function") {
       const result = item(data);
       if (result) append = orchidCore.pushOrNewArray(append, result);
     } else {
-      const shape = table.q.shape;
-      for (const key in item) {
-        const value = item[key];
-        if (value === void 0) continue;
-        set.push(
-          `"${shape[key].data.name || key}" = ${processValue(
-            ctx,
-            table,
-            QueryClass,
-            key,
-            value,
-            quotedAs
-          )}`
-        );
-      }
+      applySet(ctx, table, set, item, hookSet, quotedAs);
     }
   }
-  if (append) processData(ctx, table, set, append, quotedAs);
+  if (append) processData(ctx, table, set, append, hookSet, quotedAs);
+};
+const applySet = (ctx, table, set, item, hookSet, quotedAs) => {
+  const QueryClass = ctx.qb.constructor;
+  const shape = table.q.shape;
+  for (const key in item) {
+    const value = item[key];
+    if (value === void 0 || key in hookSet) continue;
+    set.push(
+      `"${shape[key].data.name || key}" = ${processValue(
+        ctx,
+        table,
+        QueryClass,
+        key,
+        value,
+        quotedAs
+      )}`
+    );
+  }
 };
 const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
   if (value && typeof value === "object") {
@@ -8649,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)
@@ -8672,36 +8816,48 @@ 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 = () => ({
@@ -8747,7 +8903,7 @@ const handleManyData = (q, data, ctx) => {
 const insert = (self, {
   columns,
   values
-}, kind, many) => {
+}, many) => {
   const { q } = self;
   if (!q.select?.length) {
     q.returning = true;
@@ -8758,7 +8914,6 @@ const insert = (self, {
   q.type = "insert";
   q.columns = columns;
   q.values = values;
-  if (!q.kind) q.kind = kind;
   const { select, returnType } = q;
   if (!select) {
     if (returnType !== "void") {
@@ -8778,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"
@@ -8796,19 +8951,22 @@ 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,
     {
       columns,
-      values: { from, values: obj?.values }
+      values: { from, values: obj?.values[0] }
     },
-    "from",
     many
   );
 };
@@ -8821,11 +8979,11 @@ 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);
-    values.values = obj.values;
+    obj.columns = getFromSelectColumns(q, values.from, obj);
+    values.values = obj.values[0];
     obj.values = values;
   }
-  return insert(q, obj, "object");
+  return insert(q, obj);
 };
 const _queryCreateMany = (q, data) => {
   createSelect(q);
@@ -8833,7 +8991,7 @@ const _queryCreateMany = (q, data) => {
 };
 const _queryInsertMany = (q, data) => {
   const ctx = createCtx();
-  let result = insert(q, handleManyData(q, data, ctx), "object", true);
+  let result = insert(q, handleManyData(q, data, ctx), true);
   if (!data.length) result = result.none();
   return result;
 };
@@ -8855,7 +9013,7 @@ const _queryDefaults = (q, data) => {
   q.q.defaults = data;
   return q;
 };
-class Create {
+class QueryCreate {
   /**
    * `create` and `insert` create a single record.
    *
@@ -9259,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]();
@@ -9528,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)
@@ -9544,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) {
@@ -9560,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", cb);
+  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);
@@ -9575,7 +9745,15 @@ const _queryHookAfterCreateCommit = (q, select, cb) => {
   return after(q, "Create", select, cb, true);
 };
 const _queryHookBeforeUpdate = (q, cb) => {
-  return before(q, "Update", cb);
+  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);
@@ -9584,7 +9762,7 @@ const _queryHookAfterUpdateCommit = (q, select, cb) => {
   return after(q, "Update", select, cb, true);
 };
 const _queryHookBeforeSave = (q, cb) => {
-  return before(before(q, "Create", cb), "Update", cb);
+  return _queryHookBeforeUpdate(_queryHookBeforeCreate(q, cb), cb);
 };
 const _queryHookAfterSave = (q, select, cb) => {
   return after(after(q, "Create", select, cb), "Update", select, cb);
@@ -9789,7 +9967,7 @@ class QueryHooks {
    */
   catchAfterCommitError(fn) {
     const q = _clone(this);
-    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
+    orchidCore.pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
     return q;
   }
 }
@@ -10471,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,
@@ -10482,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)
   ]);
 };
@@ -10521,7 +10699,7 @@ const _queryJoinOrOn = (q, args) => {
   );
 };
 const _queryJoinOnJsonPathEquals = (q, args) => {
-  return pushQueryValueImmutable(q, "and", {
+  return orchidCore.pushQueryValueImmutable(q, "and", {
     ON: args
   });
 };
@@ -10637,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";
@@ -10653,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) => {
@@ -10674,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(
@@ -10710,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);
         }
       }
@@ -11288,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 });
   }
 }
 
@@ -11358,7 +11554,7 @@ function orCreate(query, data, updateData, mergeData) {
       q22.q.log = q2.q.log;
       q22.q.logger = q2.q.logger;
       q22.q.type = "upsert";
-      q22.q.beforeCreate = q2.q.beforeCreate;
+      q22.q.beforeCreate = q2.q.beforeCreate?.map((cb) => () => cb(c));
       if (hasAfterCallback) {
         ((_a = q22.q).afterCreate ?? (_a.afterCreate = [])).push(
           (data2, query2) => afterHooks && Promise.all([...afterHooks].map((fn) => fn(data2, query2)))
@@ -11380,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;
@@ -11497,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) {
@@ -11630,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);
   }
 }
 
@@ -11676,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
     });
   }
@@ -12305,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);
@@ -12360,7 +12392,7 @@ class QueryMethods {
    * @param args - SQL expression
    */
   orderSql(...args) {
-    return pushQueryValueImmutable(
+    return orchidCore.pushQueryValueImmutable(
       _clone(this),
       "order",
       sqlQueryArgsToExpression(args)
@@ -12649,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,
@@ -12659,7 +12693,7 @@ orchidCore.applyMixins(QueryMethods, [
   WithMethods,
   Union,
   JsonMethods,
-  Create,
+  QueryCreate,
   Update,
   Delete,
   Transaction,
@@ -12671,7 +12705,6 @@ orchidCore.applyMixins(QueryMethods, [
   Then,
   QueryLog,
   QueryHooks,
-  QueryUpsertOrCreate,
   QueryGet,
   MergeQueryMethods,
   SqlMethod,
@@ -12847,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];
@@ -12882,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,
@@ -12956,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}>`;
@@ -13308,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;
@@ -13355,12 +13412,13 @@ exports.PathColumn = PathColumn;
 exports.PointColumn = PointColumn;
 exports.PolygonColumn = PolygonColumn;
 exports.PostgisGeographyPointColumn = PostgisGeographyPointColumn;
+exports.QueryCreate = QueryCreate;
 exports.QueryError = QueryError;
 exports.QueryGet = QueryGet;
 exports.QueryHooks = QueryHooks;
 exports.QueryLog = QueryLog;
 exports.QueryMethods = QueryMethods;
-exports.QueryUpsertOrCreate = QueryUpsertOrCreate;
+exports.QueryUpsert = QueryUpsert;
 exports.RawSQL = RawSQL;
 exports.RealColumn = RealColumn;
 exports.RefExpression = RefExpression;
@@ -13515,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;