pqb 0.56.9 → 0.56.11

package/dist/index.js

@@ -1766,6 +1766,9 @@ const defaultSchemaConfig = {
   narrowType() {
     return this;
   },
+  narrowAllTypes() {
+    return this;
+  },
   dateAsNumber() {
     return this.parse(Date.parse);
   },
@@ -2971,6 +2974,7 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
 const processJoinItem = (ctx, table, query, args, quotedAs) => {
   let target;
   let on;
+  const forbidLateral = "u" in args;
   if ("l" in args) {
     const { aliasValue } = ctx;
     ctx.aliasValue = true;
@@ -2991,7 +2995,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
       target += ` ${joinAs}`;
     }
     if (r && s) {
-      target = `LATERAL ${subJoinToSql(ctx, j, quotedTable, joinAs, true)}`;
+      target = subJoinToSql(ctx, j, quotedTable, !forbidLateral, joinAs, true);
     } else {
       on = whereToSql(ctx, j, j.q, joinAs);
     }
@@ -3001,7 +3005,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
     if ("r" in args) {
       const { s, r } = args;
       if (s) {
-        target = `LATERAL ${subJoinToSql(ctx, r, target, target)}`;
+        target = subJoinToSql(ctx, r, target, !forbidLateral, target);
       } else {
         on = whereToSql(ctx, r, r.q, target);
       }
@@ -3032,14 +3036,14 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
     let joinAs;
     if ("r" in args) {
       const { r } = args;
-      const res = getArgQueryTarget(ctx, q, s, s);
-      target = s ? `LATERAL ${res.target}` : res.target;
+      const res = getArgQueryTarget(ctx, q, s && !forbidLateral, s, s);
+      target = res.target;
       joinAs = res.joinAs;
-      if (!s) {
+      if (!s || forbidLateral) {
         on = whereToSql(ctx, r, r.q, `"${getQueryAs(r)}"`);
       }
     } else {
-      const res = getArgQueryTarget(ctx, q, s);
+      const res = getArgQueryTarget(ctx, q, false, s);
       target = res.target;
       joinAs = res.joinAs;
       if ("a" in args) {
@@ -3068,7 +3072,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
   }
   return { target, on };
 };
-const getArgQueryTarget = (ctx, first, joinSubQuery, cloned) => {
+const getArgQueryTarget = (ctx, first, lateral, joinSubQuery, cloned) => {
   const joinQuery = first.q;
   const quotedFrom = typeof joinQuery.from === "string" ? `"${joinQuery.from}"` : void 0;
   let joinAs = quotedFrom || `"${first.table}"`;
@@ -3076,7 +3080,7 @@ const getArgQueryTarget = (ctx, first, joinSubQuery, cloned) => {
   const addAs = qAs && qAs !== joinAs;
   if (joinSubQuery) {
     return {
-      target: subJoinToSql(ctx, first, joinAs, qAs, cloned),
+      target: subJoinToSql(ctx, first, joinAs, lateral, qAs, cloned),
       joinAs: addAs ? qAs : joinAs
     };
   } else {
@@ -3088,12 +3092,13 @@ const getArgQueryTarget = (ctx, first, joinSubQuery, cloned) => {
     return { target, joinAs };
   }
 };
-const subJoinToSql = (ctx, jq, innerAs, outerAs, cloned) => {
+const subJoinToSql = (ctx, jq, innerAs, lateral, outerAs, cloned) => {
   if (!jq.q.select && jq.q.selectAllColumns) {
     if (!cloned) jq = jq.clone();
     jq.q.select = [new RawSQL(`${innerAs}.*`)];
   }
-  return `(${getSqlText(jq.toSQL(ctx))}) ${outerAs || innerAs}`;
+  const sql = `(${getSqlText(jq.toSQL(ctx))}) ${outerAs || innerAs}`;
+  return lateral ? `LATERAL ${sql}` : sql;
 };
 const processArgs = (args, ctx, query, joinAs, joinShape, quotedAs) => {
   return args.length ? args.length === 1 ? getObjectOrRawConditions(
@@ -3177,7 +3182,26 @@ const skipQueryKeysForSubQuery = {
   returnsOne: true,
   aliases: true,
   defaults: true,
-  transform: true
+  transform: true,
+  throwOnNotFound: true,
+  before: true,
+  after: true,
+  beforeCreate: true,
+  afterCreate: true,
+  afterCreateCommit: true,
+  afterCreateSelect: true,
+  beforeUpdate: true,
+  afterUpdate: true,
+  afterUpdateCommit: true,
+  afterUpdateSelect: true,
+  beforeDelete: true,
+  afterDelete: true,
+  afterDeleteCommit: true,
+  afterDeleteSelect: true,
+  catchAfterCommitErrors: true,
+  log: true,
+  logger: true,
+  autoPreparedStatements: true
 };
 const getIsJoinSubQuery = (query) => {
   const {
@@ -3192,14 +3216,14 @@ const getIsJoinSubQuery = (query) => {
   return false;
 };
 
-const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
+const processJoinArgs = (joinTo, first, args, joinSubQuery, shape, whereExists, forbidLateral) => {
   if (typeof first === "string") {
     if (first in joinTo.relations) {
       const { query: toQuery, joinQuery } = joinTo.relations[first];
       const j = joinQuery(toQuery, joinTo);
       if (typeof args[0] === "function") {
         const r = args[0](
-          makeJoinQueryBuilder(j, j.q.joinedShapes, joinTo)
+          makeJoinQueryBuilder(j, j.q.joinedShapes, joinTo, shape)
         );
         return {
           j: j.merge(r),
@@ -3220,7 +3244,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
       j.table = first;
       j.q = {
         shape: w.shape,
-        computeds: w.computeds,
+        runtimeComputeds: w.computeds,
         adapter: joinToQ.adapter,
         handleResult: joinToQ.handleResult,
         returnType: "all",
@@ -3238,7 +3262,8 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
             ...j.q.joinedShapes,
             ...joinedShapes
           } : joinedShapes,
-          joinTo
+          joinTo,
+          shape
         )
       );
       return {
@@ -3250,7 +3275,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
   }
   const args0 = args.length ? args[0] : orchidCore.returnArg;
   if (typeof args0 === "function") {
-    const q = first;
+    let q = first;
     if (q.joinQueryAfterCallback) {
       let base = q.baseQuery;
       if (q.q.as) {
@@ -3260,14 +3285,17 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
         base,
         joinTo
       );
-      if (query.and) {
-        pushQueryArrayImmutable(q, "and", query.and);
-      }
-      if (query.or) {
-        pushQueryArrayImmutable(q, "or", query.or);
-      }
-      if (query.scopes) {
-        q.q.scopes = { ...q.q.scopes, ...query.scopes };
+      if (query.and || query.or || query.scopes) {
+        q = _clone(q);
+        if (query.and) {
+          pushQueryArrayImmutable(q, "and", query.and);
+        }
+        if (query.or) {
+          pushQueryArrayImmutable(q, "or", query.or);
+        }
+        if (query.scopes) {
+          q.q.scopes = { ...q.q.scopes, ...query.scopes };
+        }
       }
     }
     const joinedShapes = {
@@ -3281,11 +3309,16 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
           ...q.q.joinedShapes,
           ...joinedShapes
         } : joinedShapes,
-        joinTo
+        joinTo,
+        shape
       )
     );
     joinSubQuery || (joinSubQuery = getIsJoinSubQuery(r));
-    return { q: joinSubQuery ? q.merge(r) : q, r, s: joinSubQuery };
+    return {
+      q: joinSubQuery && !forbidLateral ? q.merge(r) : q,
+      r,
+      s: joinSubQuery
+    };
   }
   return {
     q: first,
@@ -3301,12 +3334,15 @@ const preprocessJoinArg = (q, arg) => {
   arg.joinQueryAfterCallback = arg.joinQuery;
   return arg;
 };
-const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo) => {
+const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo, shape) => {
   const q = joinedQuery.baseQuery.clone();
   q.baseQuery = q;
   q.q.as = joinedQuery.q.as;
   q.q.joinedShapes = joinedShapes;
   q.q.joinTo = joinTo;
+  if (shape) {
+    q.q.shape = shape;
+  }
   return q;
 };
 
@@ -3326,14 +3362,23 @@ const noneMethods = {
   // It is `async` so it returns a chainable Promise.
   async then(resolve, reject) {
     try {
-      const result = noneResult(this, this.q, this.q.returnType);
-      resolve?.(result);
+      let result = noneResult(this, this.q, this.q.returnType);
+      if (this.q.transform) {
+        result = orchidCore.applyTransforms(
+          this.q,
+          this.q.returnType,
+          this.q.transform,
+          result
+        );
+      }
+      return resolve?.(result);
     } catch (err) {
-      reject?.(err);
+      return reject?.(err);
     }
   },
-  // `catch` returns a Promise, so it is chainable with then/catch.
-  catch: () => new Promise(orchidCore.noop)
+  catch(reject) {
+    return this.then(void 0, reject);
+  }
 };
 const _queryNone = (q) => {
   if (isQueryNone(q)) return q;
@@ -3480,6 +3525,7 @@ const existsArgs = (self, q, args) => {
     preprocessJoinArg(self, q),
     args,
     false,
+    void 0,
     true
   );
   return [
@@ -4320,7 +4366,7 @@ const getFullColumnTable = (q, column, index, as) => {
   return as && table !== as && orchidCore._checkIfAliased(q, table, as) ? as : table;
 };
 
-const _join = (query, require, type, first, args) => {
+const _joinReturningArgs = (query, require, first, args, forbidLateral) => {
   let joinKey;
   let shape;
   let parsers;
@@ -4335,7 +4381,7 @@ const _join = (query, require, type, first, args) => {
       first = first._internalJoin;
     }
     if (require && isQueryNone(first)) {
-      return _queryNone(query);
+      return;
     }
     const q = first;
     if (!isInternalJoin) {
@@ -4344,9 +4390,9 @@ const _join = (query, require, type, first, args) => {
     joinKey = q.q.as || q.table;
     if (joinKey) {
       shape = getShapeFromSelect(q, joinSubQuery && !!q.q.select);
-      parsers = q.q.parsers;
+      parsers = orchidCore.getQueryParsers(q);
       batchParsers = q.q.batchParsers;
-      computeds = q.q.computeds;
+      computeds = q.q.runtimeComputeds;
       if (joinSubQuery) {
         first = q.clone();
         first.shape = shape;
@@ -4358,9 +4404,9 @@ const _join = (query, require, type, first, args) => {
     if (relation) {
       shape = getShapeFromSelect(relation.query);
       const r = relation.query;
-      parsers = r.q.parsers;
+      parsers = orchidCore.getQueryParsers(r);
       batchParsers = r.q.batchParsers;
-      computeds = r.q.computeds;
+      computeds = r.q.runtimeComputeds;
     } else {
       const w = query.q.withShapes?.[joinKey];
       shape = w?.shape;
@@ -4378,18 +4424,23 @@ const _join = (query, require, type, first, args) => {
     query,
     first,
     args,
-    joinSubQuery
+    joinSubQuery,
+    shape,
+    false,
+    forbidLateral
   );
   if (require && "r" in joinArgs && isQueryNone(joinArgs.r)) {
-    return _queryNone(query);
+    return;
   } else if (joinKey && "s" in joinArgs && joinArgs.s) {
     const j = "j" in joinArgs ? joinArgs.r ?? joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
     const jq = j.q;
     if (jq.select || !jq.selectAllColumns) {
       const { q } = query;
-      const shape2 = getShapeFromSelect(j, true);
-      orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape2);
-      orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, jq.parsers);
+      if ("r" in joinArgs && joinArgs.r) {
+        joinArgs.c = shape = getShapeFromSelect(j, true);
+      }
+      orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
+      orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, orchidCore.getQueryParsers(j));
       if (jq.batchParsers) {
         orchidCore.setObjectValueImmutable(
           jq,
@@ -4398,7 +4449,12 @@ const _join = (query, require, type, first, args) => {
           jq.batchParsers
         );
       }
-      orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, jq.computeds);
+      orchidCore.setObjectValueImmutable(
+        q,
+        "joinedComputeds",
+        joinKey,
+        jq.runtimeComputeds
+      );
     } else {
       addAllShapesAndParsers(
         query,
@@ -4419,6 +4475,13 @@ const _join = (query, require, type, first, args) => {
       computeds
     );
   }
+  return joinArgs;
+};
+const _join = (query, require, type, first, args) => {
+  const joinArgs = _joinReturningArgs(query, require, first, args);
+  if (!joinArgs) {
+    return _queryNone(query);
+  }
   orchidCore.pushQueryValueImmutable(query, "join", {
     type,
     args: joinArgs
@@ -4484,7 +4547,12 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
   if (joinKey) {
     const shape = getShapeFromSelect(arg, true);
     orchidCore.setObjectValueImmutable(q.q, "joinedShapes", joinKey, shape);
-    orchidCore.setObjectValueImmutable(q.q, "joinedParsers", joinKey, arg.q.parsers);
+    orchidCore.setObjectValueImmutable(
+      q.q,
+      "joinedParsers",
+      joinKey,
+      orchidCore.getQueryParsers(arg)
+    );
     if (arg.q.batchParsers) {
       orchidCore.setObjectValueImmutable(
         q.q,
@@ -4495,7 +4563,7 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
     }
   }
   as || (as = getQueryAs(arg));
-  orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.computeds);
+  orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.runtimeComputeds);
   orchidCore.pushQueryValueImmutable(q, "join", {
     type: `${type} LATERAL`,
     args: { l: arg, a: as, i: innerJoinLateral }
@@ -4880,6 +4948,7 @@ class ComputedColumn {
 const computeAtRuntime = (deps, fn) => new ComputedColumn("one", deps, fn);
 const computeBatchAtRuntime = (deps, fn) => new ComputedColumn("many", deps, fn);
 const applyComputedColumns = (q, fn) => {
+  var _a;
   q.computeAtRuntime = computeAtRuntime;
   q.computeBatchAtRuntime = computeBatchAtRuntime;
   const computed = fn(q);
@@ -4887,8 +4956,8 @@ const applyComputedColumns = (q, fn) => {
     let item = computed[key];
     if (typeof item === "function") item = item.call(computed);
     if (item instanceof ComputedColumn) {
-      q.q.computeds = {
-        ...q.q.computeds,
+      q.q.runtimeComputeds = {
+        ...q.q.runtimeComputeds,
         [key]: item
       };
     } else {
@@ -4904,11 +4973,10 @@ const applyComputedColumns = (q, fn) => {
       data.computed = item;
       data.explicitSelect = true;
       data.readOnly = true;
-      addColumnParserToQuery(
-        q.q,
-        key,
-        item.result.value
-      );
+      const parse = item.result.value._parse;
+      if (parse) {
+        ((_a = q.q).defaultParsers ?? (_a.defaultParsers = {}))[key] = parse;
+      }
     }
   }
   q.computeAtRuntime = q.computeBatchAtRuntime = void 0;
@@ -5117,7 +5185,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         )
       );
     }
-    sql = q.toSQL();
+    const localSql = sql = q.toSQL();
     const { hookSelect, delayedRelationSelect } = sql;
     const { returnType = "all" } = query;
     const tempReturnType = hookSelect || returnType === "rows" && q.q.batchParsers || delayedRelationSelect?.value ? "all" : returnType;
@@ -5142,7 +5210,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       if (query.patchResult) {
         await query.patchResult(q, hookSelect, queryResult);
       }
-      result = query.handleResult(q, tempReturnType, queryResult);
+      result = query.handleResult(q, tempReturnType, queryResult, localSql);
     } else {
       const queryMethod = queryMethodByReturnType[tempReturnType];
       const queryBatch = async (batch) => {
@@ -5180,10 +5248,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       if (query.patchResult) {
         await query.patchResult(q, hookSelect, queryResult);
       }
-      result = query.handleResult(q, tempReturnType, queryResult);
-    }
-    if (result && typeof result === "object" && typeof result.then === "function") {
-      result = await result;
+      result = query.handleResult(q, tempReturnType, queryResult, localSql);
     }
     let tempColumns;
     let renames;
@@ -5207,8 +5272,8 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         }
       }
       if (query.selectedComputeds) {
-        const promise = processComputedResult(query, result);
-        if (promise) await promise;
+        const promise2 = processComputedResult(query, result);
+        if (promise2) await promise2;
       }
     }
     const hasAfterHook = afterHooks || afterCommitHooks || query.after;
@@ -5265,19 +5330,15 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       );
       const selectQuery = q2.clone();
       selectQuery.q.type = selectQuery.q.returnType = void 0;
-      ((_a = selectQuery.q).and ?? (_a.and = [])).push(orchidCore.pick(result, primaryKeys));
-      const relationsSelect = delayedRelationSelect.value;
-      let selectAs;
-      if (renames) {
-        selectAs = {};
-        for (const key in renames) {
-          if (key in relationsSelect) {
-            selectAs[renames[key]] = relationsSelect[key];
-          }
-        }
-      } else {
-        selectAs = { ...relationsSelect };
+      const matchSourceTableIds = {};
+      for (const pkey of primaryKeys) {
+        matchSourceTableIds[pkey] = {
+          in: result.map((row) => row[pkey])
+        };
       }
+      ((_a = selectQuery.q).and ?? (_a.and = [])).push(matchSourceTableIds);
+      const relationsSelect = delayedRelationSelect.value;
+      const selectAs = { ...relationsSelect };
       const select = [{ selectAs }];
       const relationKeyAliases = primaryKeys.map((key) => {
         if (key in selectAs) {
@@ -5301,16 +5362,30 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
           Object.assign(row, relationRow);
         }
       }
+      if (renames) {
+        for (const key in relationsSelect) {
+          if (key in renames) {
+            delete renames[key];
+          }
+        }
+      }
     }
+    const promise = parseBatch(q, queryResult, delayedRelationSelect);
+    if (promise) await promise;
     if (hookSelect || tempReturnType !== returnType) {
       if (renames) {
-        for (const a in renames) {
-          for (const record of result) {
-            const value = record[a];
-            record[a] = record[renames[a]];
-            record[renames[a]] = value;
+        const renamedResult = Array.from({
+          length: result.length
+        });
+        for (let i = 0, len = result.length; i < len; ++i) {
+          const record = result[i];
+          const renamedRecord = renamedResult[i] = { ...record };
+          for (const a in renames) {
+            renamedRecord[a] = record[renames[a]];
+            renamedRecord[renames[a]] = record[a];
           }
         }
+        result = renamedResult;
       }
       result = filterResult(
         q,
@@ -5364,68 +5439,46 @@ const execQuery = (adapter, method, sql) => {
     return result;
   });
 };
-const handleResult = (q, returnType, result, isSubQuery) => {
-  const { parsers } = q.q;
+const handleResult = (q, returnType, result, sql, isSubQuery) => {
+  const parsers = orchidCore.getQueryParsers(q, sql.hookSelect);
   switch (returnType) {
     case "all": {
       if (q.q.throwOnNotFound && result.rows.length === 0)
         throw new orchidCore.NotFoundError(q);
-      const promise = parseBatch(q, result);
       const { rows } = result;
       if (parsers) {
         for (const row of rows) {
           parseRecord(parsers, row);
         }
       }
-      return promise ? promise.then(() => rows) : rows;
+      return rows;
     }
     case "one": {
       const { rows } = result;
       if (!rows.length) return;
-      const promise = parseBatch(q, result);
       if (parsers) parseRecord(parsers, rows[0]);
-      return promise ? promise.then(() => rows[0]) : rows[0];
+      return rows[0];
     }
     case "oneOrThrow": {
       const { rows } = result;
       if (!rows.length) throw new orchidCore.NotFoundError(q);
-      const promise = parseBatch(q, result);
       if (parsers) parseRecord(parsers, rows[0]);
-      return promise ? promise.then(() => rows[0]) : rows[0];
+      return rows[0];
     }
     case "rows": {
       const { rows } = result;
-      const promise = parseBatch(q, result);
-      if (promise) {
-        return promise.then(() => {
-          if (parsers) parseRows(parsers, result.fields, rows);
-          return rows;
-        });
-      } else if (parsers) {
+      if (parsers) {
         parseRows(parsers, result.fields, rows);
       }
       return rows;
     }
     case "pluck": {
       const { rows } = result;
-      const promise = parseBatch(q, result);
-      if (promise) {
-        return promise.then(() => {
-          parsePluck(parsers, isSubQuery, rows);
-          return rows;
-        });
-      }
       parsePluck(parsers, isSubQuery, rows);
       return rows;
     }
     case "value": {
       const { rows } = result;
-      const promise = parseBatch(q, result);
-      if (promise) {
-        return promise.then(() => {
-          return rows[0]?.[0] !== void 0 ? parseValue(rows[0][0], parsers) : q.q.notFoundDefault;
-        });
-      }
       return rows[0]?.[0] !== void 0 ? parseValue(rows[0][0], parsers) : q.q.notFoundDefault;
     }
     case "valueOrThrow": {
@@ -5436,13 +5489,6 @@ const handleResult = (q, returnType, result, isSubQuery) => {
         return result.rowCount;
       }
       const { rows } = result;
-      const promise = parseBatch(q, result);
-      if (promise) {
-        return promise.then(() => {
-          if (rows[0]?.[0] === void 0) throw new orchidCore.NotFoundError(q);
-          return parseValue(rows[0][0], parsers);
-        });
-      }
       if (rows[0]?.[0] === void 0) throw new orchidCore.NotFoundError(q);
       return parseValue(rows[0][0], parsers);
     }
@@ -5451,9 +5497,9 @@ const handleResult = (q, returnType, result, isSubQuery) => {
     }
   }
 };
-const parseBatch = (q, queryResult) => {
+const parseBatch = (q, queryResult, delayedRelationSelect) => {
   let promises;
-  if (q.q.batchParsers) {
+  if (q.q.batchParsers && !delayedRelationSelect?.value) {
     for (const parser of q.q.batchParsers) {
       const res = parser.fn(parser.path, queryResult);
       if (res) (promises ?? (promises = [])).push(res);
@@ -5566,44 +5612,46 @@ const filterAllResult = (result, tempColumns, hasAfterHook) => {
   return result;
 };
 
+const addWithParsers = (w, parsers) => {
+  for (const key in w.shape) {
+    const { _parse } = w.shape[key];
+    if (_parse) parsers[key] = _parse;
+  }
+};
 function queryFrom(self, arg) {
   const data = self.q;
   if (typeof arg === "string") {
     data.as || (data.as = arg);
     const w = data.withShapes?.[arg];
     data.shape = w?.shape ?? anyShape;
-    data.computeds = w?.computeds;
-  } else if (orchidCore.isExpression(arg)) {
-    data.as || (data.as = "t");
+    data.runtimeComputeds = w?.computeds;
+    const parsers = {};
+    data.defaultParsers = parsers;
+    if (w) addWithParsers(w, parsers);
   } else if (Array.isArray(arg)) {
     const { shape } = data;
-    let clonedParsers = false;
+    const joinedParsers = {};
     for (const item of arg) {
       if (typeof item === "string") {
         const w = data.withShapes[item];
         Object.assign(shape, w.shape);
-        if (w.computeds) data.computeds = { ...data.computeds, ...w.computeds };
-        for (const key in w.shape) {
-          addColumnParserToQuery(
-            self,
-            key,
-            w.shape[key]
-          );
-        }
+        if (w.computeds)
+          data.runtimeComputeds = { ...data.runtimeComputeds, ...w.computeds };
+        const parsers = {};
+        joinedParsers[item] = parsers;
+        addWithParsers(w, parsers);
       } else if (!orchidCore.isExpression(item)) {
         Object.assign(shape, getShapeFromSelect(item, true));
-        if (!clonedParsers) {
-          data.parsers = { ...data.parsers };
-          clonedParsers = true;
-        }
-        Object.assign(data.parsers, item.q.parsers);
+        const key = getQueryAs(item);
+        joinedParsers[key] = orchidCore.getQueryParsers(item);
       }
     }
+    data.joinedParsers = joinedParsers;
   } else {
     const q = arg;
     data.as || (data.as = q.q.as || q.table || "t");
     data.shape = getShapeFromSelect(q, true);
-    data.parsers = q.q.parsers;
+    data.defaultParsers = orchidCore.getQueryParsers(q);
     data.batchParsers = q.q.batchParsers;
   }
   data.from = arg;
@@ -5716,7 +5764,7 @@ const addParsersForSelectJoined = (q, arg, as = arg) => {
   }
 };
 const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
-  if (typeof arg === "object" || typeof arg === "function") {
+  if (typeof arg === "object") {
     const { q: query } = arg;
     if (query.batchParsers) {
       pushQueryArrayImmutable(
@@ -5728,7 +5776,8 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
         }))
       );
     }
-    if (query.hookSelect || query.parsers || query.transform || query.returnType === "oneOrThrow" || query.returnType === "valueOrThrow" || query.returnType === "one" || query.returnType === "value") {
+    const parsers = orchidCore.isExpression(arg) ? void 0 : orchidCore.getQueryParsers(arg);
+    if (parsers || query.hookSelect || query.transform || query.returnType === "oneOrThrow" || query.returnType === "valueOrThrow" || query.returnType === "one" || query.returnType === "value") {
       orchidCore.pushQueryValueImmutable(q, "batchParsers", {
         path: [key],
         fn: (path, queryResult) => {
@@ -5752,7 +5801,6 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
           collectNestedSelectBatches(batches, rows, path, last);
           switch (returnType) {
             case "all": {
-              const { parsers } = query;
               if (parsers) {
                 for (const { data } of batches) {
                   for (const one of data) {
@@ -5764,7 +5812,6 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
             }
             case "one":
             case "oneOrThrow": {
-              const { parsers } = query;
               if (parsers) {
                 if (returnType === "one") {
                   for (const batch of batches) {
@@ -5795,7 +5842,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
               break;
             }
             case "pluck": {
-              const parse = query.parsers?.pluck;
+              const parse = parsers?.pluck;
               if (parse) {
                 for (const { data } of batches) {
                   for (let i = 0; i < data.length; i++) {
@@ -5808,7 +5855,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
             case "value":
             case "valueOrThrow": {
               const notNullable = !query.getColumn?.data.isNullable;
-              const parse = query.parsers?.[orchidCore.getValueKey];
+              const parse = parsers?.[orchidCore.getValueKey];
               if (parse) {
                 if (returnType === "value") {
                   for (const item of batches) {
@@ -6039,31 +6086,30 @@ const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
   const computeds = q.joinedComputeds?.[table];
   if (computeds?.[column]) {
     const computed = computeds[column];
-    const map = q.hookSelect = new Map(q.hookSelect);
-    for (const column2 of computed.deps) {
-      map.set(column2, { select: `${table}.${column2}` });
-    }
+    orchidCore._addToHookSelectWithTable(query, computed.deps, table);
     orchidCore.setObjectValueImmutable(q, "selectedComputeds", column, computed);
     return;
   }
   return arg;
 };
 const selectColumn = (query, q, key, columnAs, columnAlias) => {
-  if (columnAs && q.parsers) {
-    const parser = q.parsers[key];
-    if (parser) orchidCore.setObjectValueImmutable(q, "parsers", columnAs, parser);
-  }
-  if (q.computeds?.[key]) {
-    const computed = q.computeds[key];
-    const map = query.q.hookSelect = new Map(query.q.hookSelect);
-    for (const key2 of computed.deps) {
-      map.set(key2, { select: key2 });
-    }
-    query.q.selectedComputeds = {
-      ...query.q.selectedComputeds,
-      [columnAlias || key]: computed
-    };
-    return;
+  if (key === "*") {
+    const { defaultParsers } = query.q;
+    if (defaultParsers) {
+      orchidCore.spreadObjectValues(query.q, "parsers", defaultParsers);
+    }
+  } else {
+    const parser = query.q.defaultParsers?.[key];
+    if (parser) orchidCore.setObjectValueImmutable(q, "parsers", columnAs || key, parser);
+    if (q.runtimeComputeds?.[key]) {
+      const computed = q.runtimeComputeds[key];
+      orchidCore._addToHookSelect(query, computed.deps);
+      query.q.selectedComputeds = {
+        ...query.q.selectedComputeds,
+        [columnAlias || key]: computed
+      };
+      return;
+    }
   }
   return key;
 };
@@ -6196,6 +6242,11 @@ function _querySelect(q, args) {
   }
   return pushQueryArrayImmutable(q, "select", selectArgs);
 }
+const _querySelectAll = (query) => {
+  const q = query;
+  q.q.select = ["*"];
+  q.q.parsers = q.q.defaultParsers;
+};
 class Select {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   select(...args) {
@@ -6219,7 +6270,7 @@ class Select {
    */
   selectAll() {
     const q = _clone(this);
-    q.q.select = ["*"];
+    _querySelectAll(q);
     if (q.q.returning) {
       q.q.returnType = q.q.returningMany ? "all" : "oneOrThrow";
       q.q.returning = void 0;
@@ -7076,7 +7127,7 @@ const selectAllSql = (query, quotedAs, jsonList) => {
   if (jsonList) {
     Object.assign(jsonList, query.selectAllShape);
   }
-  return query.join?.length ? query.selectAllColumns?.map((item) => `${quotedAs}.${item}`).join(", ") || `${quotedAs}.*` : query.selectAllColumns?.join(", ") || "*";
+  return query.join?.length || query.updateFrom ? query.selectAllColumns?.map((item) => `${quotedAs}.${item}`).join(", ") || `${quotedAs}.*` : query.selectAllColumns?.join(", ") || "*";
 };
 const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) => {
   const { returnType = "all" } = query.q;
@@ -7147,7 +7198,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
     case "pluck": {
       const { select } = query.q;
       const first = select?.[0];
-      if (!first && query.q.computeds?.[as]) {
+      if (!first && query.q.runtimeComputeds?.[as]) {
         query = queryJson(query);
       } else if (!first) {
         throw new orchidCore.OrchidOrmInternalError(
@@ -7164,7 +7215,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
     }
     case "value":
     case "valueOrThrow":
-      if (!query.q.returning && query.q.computeds?.[as]) {
+      if (!query.q.returning && query.q.runtimeComputeds?.[as]) {
         query = queryJson(query);
       }
       break;
@@ -7276,9 +7327,6 @@ const pushFromAndAs = (ctx, table, data, quotedAs) => {
   let sql = "FROM ";
   const from = getFrom(ctx, table, data, quotedAs);
   sql += from;
-  if (data.as && quotedAs && quotedAs !== from) {
-    sql += ` ${quotedAs}`;
-  }
   for (const as in data.sources) {
     const source = data.sources[as];
     const lang = getSearchLang(ctx, data, source, quotedAs);
@@ -7325,6 +7373,9 @@ const getFrom = (ctx, table, data, quotedAs) => {
     return fromToSql(ctx, data, from, quotedAs);
   }
   let sql = quoteSchemaAndTable(data.schema, table.table);
+  if (data.as && quotedAs && quotedAs !== sql) {
+    sql += ` ${quotedAs}`;
+  }
   if (data.only) sql = `ONLY ${sql}`;
   return sql;
 };
@@ -7333,13 +7384,13 @@ const fromToSql = (ctx, data, from, quotedAs) => {
   let sql;
   if (typeof from === "object") {
     if (orchidCore.isExpression(from)) {
-      sql = from.toSQL(ctx, quotedAs);
+      sql = from.toSQL(ctx, quotedAs) + " " + quotedAs;
     } else {
       only = from.q.only;
       if (!from.table) {
         sql = `(${getSqlText(toSQL(from, ctx))})`;
       } else if (!checkIfASimpleQuery(from)) {
-        sql = `(${getSqlText(toSQL(from, ctx))})`;
+        sql = `(${getSqlText(toSQL(from, ctx))}) ${quotedAs || `"${getQueryAs(from)}"`}`;
       } else {
         sql = quoteSchemaAndTable(from.q.schema, from.table);
       }
@@ -7457,7 +7508,45 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
     }
     ctx.sql.push("SET");
     ctx.sql.push(set.join(", "));
-    pushWhereStatementSql(ctx, table, query, quotedAs);
+    const { updateFrom } = query;
+    let fromWhereSql;
+    if (updateFrom) {
+      const { target, on } = processJoinItem(
+        ctx,
+        table,
+        query,
+        updateFrom,
+        quotedAs
+      );
+      ctx.sql.push(`FROM ${target}`);
+      fromWhereSql = on;
+      if (query.join) {
+        const joinSet = query.join.length > 1 ? /* @__PURE__ */ new Set() : null;
+        for (const item of query.join) {
+          const { target: target2, on: on2 } = processJoinItem(
+            ctx,
+            table,
+            query,
+            item.args,
+            quotedAs
+          );
+          if (joinSet) {
+            const key = `${item.type}${target2}${on2}`;
+            if (joinSet.has(key)) continue;
+            joinSet.add(key);
+          }
+          ctx.sql.push(`${item.type} ${target2} ON true`);
+          if (on2) {
+            fromWhereSql = fromWhereSql ? fromWhereSql + " AND " + on2 : on2;
+          }
+        }
+      }
+    }
+    const mainWhereSql = whereToSql(ctx, table, query, quotedAs);
+    const whereSql = mainWhereSql ? fromWhereSql ? mainWhereSql + " AND " + fromWhereSql : mainWhereSql : fromWhereSql;
+    if (whereSql) {
+      ctx.sql.push("WHERE", whereSql);
+    }
     hookSelect = pushUpdateReturning(
       ctx,
       table,
@@ -8749,7 +8838,7 @@ class WithMethods {
     const shape = getShapeFromSelect(query, true);
     return setQueryObjectValueImmutable(q, "withShapes", name, {
       shape,
-      computeds: query.q.computeds
+      computeds: query.q.runtimeComputeds
     });
   }
   withRecursive(name, ...args) {
@@ -8760,7 +8849,7 @@ class WithMethods {
     arg.q.withShapes = q.q.withShapes;
     let query = typeof baseFn === "function" ? baseFn(arg) : baseFn;
     const shape = getShapeFromSelect(query, true);
-    const withConfig = { shape, computeds: query.q.computeds };
+    const withConfig = { shape, computeds: query.q.runtimeComputeds };
     ((_a = arg.q).withShapes ?? (_a.withShapes = {}))[name] = withConfig;
     const recursive = recursiveFn(arg);
     query = _queryUnion(query, [recursive], options.union ?? "UNION ALL");
@@ -8777,14 +8866,15 @@ class WithMethods {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   withSql(name, ...args) {
     const q = _clone(this);
-    const [options, shape, sql] = args.length === 2 ? [void 0, args[0], args[1]] : args;
+    const [options, shapeFn, sql] = args.length === 2 ? [void 0, args[0], args[1]] : args;
+    const shape = shapeFn(this.columnTypes);
     orchidCore.pushQueryValueImmutable(q, "with", {
       n: name,
-      o: options,
+      o: { ...options, columns: Object.keys(shape) },
       s: sql(q)
     });
     return setQueryObjectValueImmutable(q, "withShapes", name, {
-      shape: shape(this.columnTypes)
+      shape
     });
   }
 }
@@ -9035,7 +9125,7 @@ const createSelect = (q) => {
   if (q.q.returnType === "void" || isSelectingCount(q)) {
     q.q.select = void 0;
   } else if (!q.q.select) {
-    q.q.select = ["*"];
+    _querySelectAll(q);
     q.q.returning = true;
   }
 };
@@ -10881,6 +10971,7 @@ class JsonMethods {
 const mergableObjects = /* @__PURE__ */ new Set([
   "shape",
   "withShapes",
+  "defaultParsers",
   "parsers",
   "defaults",
   "joinedShapes",
@@ -10967,7 +11058,8 @@ const _queryChangeCounter = (self, op, data) => {
   orchidCore.pushQueryValueImmutable(self, "updateData", map);
   return self;
 };
-const _queryUpdate = (query, arg) => {
+const _queryUpdate = (updateSelf, arg) => {
+  const query = updateSelf;
   const { q } = query;
   q.type = "update";
   const returnCount = !q.select;
@@ -10975,6 +11067,7 @@ const _queryUpdate = (query, arg) => {
   orchidCore.pushQueryValueImmutable(query, "updateData", set);
   const { shape } = q;
   const ctx = {};
+  let selectQuery;
   for (const key in arg) {
     const item = shape[key];
     if (!item && shape !== anyShape) {
@@ -10986,8 +11079,12 @@ const _queryUpdate = (query, arg) => {
       if (item) throwOnReadOnly(query, item, key);
       let value = set[key];
       if (typeof value === "function") {
+        if (!selectQuery) {
+          selectQuery = query.clone();
+          selectQuery.q.type = void 0;
+        }
         value = resolveSubQueryCallbackV2(
-          query.baseQuery,
+          selectQuery,
           value
         );
         if (value instanceof Db && value.q.type && value.q.subQuery) {
@@ -11000,14 +11097,7 @@ const _queryUpdate = (query, arg) => {
       }
       if (value !== null && value !== void 0 && !orchidCore.isExpression(value)) {
         if (value instanceof Db) {
-          moveQueryValueToWith(
-            query,
-            q,
-            value,
-            "with",
-            set,
-            key
-          );
+          moveQueryValueToWith(query, q, value, "with", set, key);
         } else {
           const encode = item?.data.encode;
           if (encode) set[key] = encode(value);
@@ -11035,10 +11125,7 @@ const _queryUpdate = (query, arg) => {
           primaryKeys,
           queryResult.rows.map((item) => primaryKeys.map((key) => item[key]))
         );
-        await _queryUpdate(
-          t,
-          ctx.collect.data
-        );
+        await _queryUpdate(t, ctx.collect.data);
         for (const row of queryResult.rows) {
           Object.assign(row, ctx.collect.data);
         }
@@ -11050,7 +11137,9 @@ const _queryUpdate = (query, arg) => {
     q.returnType = "valueOrThrow";
     q.returning = true;
   }
-  throwIfNoWhere(query, "update");
+  if (!q.updateFrom) {
+    throwIfNoWhere(query, "update");
+  }
   return query;
 };
 const _queryUpdateOrThrow = (q, arg) => {
@@ -11288,6 +11377,77 @@ class Update {
   updateOrThrow(arg) {
     return _queryUpdateOrThrow(_clone(this), arg);
   }
+  /**
+   * Use `updateFrom` to update records in one table based on a query result from another table or CTE.
+   *
+   * `updateFrom` accepts the same arguments as {@link Query.join}.
+   *
+   * ```ts
+   * // save all author names to their books by using a relation name:
+   * db.books.updateFrom('author').set({ authorName: (q) => q.ref('author.name') });
+   *
+   * // update from authors that match the condition:
+   * db.books
+   *   .updateFrom((q) => q.author.where({ writingSkills: 'good' }))
+   *   .set({ authorName: (q) => q.ref('author.name') });
+   *
+   * // update from any table using custom `on` conditions:
+   * db.books
+   *   .updateFrom(
+   *     () => db.authors,
+   *     (q) => q.on('authors.id', 'books.authorId'),
+   *   )
+   *   .set({ authorName: (q) => q.ref('author.name') });
+   *
+   * // conditions after `updateFrom` can reference both tables:
+   * db.books
+   *   .updateFrom(() => db.authors)
+   *   .where({
+   *     'authors.id': (q) => q.ref('books.authorId'),
+   *   })
+   *   .set({ authorName: (q) => q.ref('author.name') });
+   *
+   * // can join and use another table in between `updateFrom` and `set`:
+   * db.books
+   *   .updateFrom('author')
+   *   .join('publisher')
+   *   .set({
+   *     authorName: (q) => q.ref('author.name'),
+   *     publisherName: (q) => q.ref('publisher.name'),
+   *   });
+   *
+   * // updating from a CTE
+   * db.books
+   *   .with('a', () =>
+   *     db.authors.where({ writingSkills: 'good' }).select('id', 'name').limit(10),
+   *   )
+   *   .updateFrom('a', (q) => q.on('a.id', 'books.authorId'))
+   *   .set({ authorName: (q) => q.ref('author.name') });
+   * ```
+   */
+  updateFrom(arg, ...args) {
+    const q = _clone(this);
+    const joinArgs = _joinReturningArgs(
+      q,
+      true,
+      arg,
+      args,
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      true
+    );
+    if (!joinArgs) {
+      return _queryNone(q);
+    }
+    joinArgs.u = true;
+    q.q.updateFrom = joinArgs;
+    return q;
+  }
+  /**
+   * Use after {@link updateFrom}
+   */
+  set(arg) {
+    return _queryUpdate(_clone(this), arg);
+  }
   /**
    * Increments a column by `1`, returns a count of updated records by default.
    *
@@ -11616,8 +11776,8 @@ function orCreate(query, data, updateData, mergeData) {
   const { handleResult } = q;
   let result;
   let created = false;
-  q.handleResult = (q2, t, r, s) => {
-    return created ? result : handleResult(q2, t, r, s);
+  q.handleResult = (q2, t, r, s, i) => {
+    return created ? result : handleResult(q2, t, r, s, i);
   };
   q.hookSelect = new Map(q.hookSelect);
   q.patchResult = async (q2, hookSelect, queryResult) => {
@@ -11656,7 +11816,7 @@ function orCreate(query, data, updateData, mergeData) {
       );
       let afterHooks;
       let afterCommitHooks;
-      q22.q.handleResult = (a, t, r, s) => {
+      q22.q.handleResult = (a, t, r, s, i) => {
         if (hasAfterCallback || hasAfterCommitCallback) {
           const fieldName = r.fields[0].name;
           if (r.rows[0][fieldName]) {
@@ -11668,7 +11828,7 @@ function orCreate(query, data, updateData, mergeData) {
           }
           delete r.rows[0][fieldName];
         }
-        result = handleResult(a, t, r, s);
+        result = handleResult(a, t, r, s, i);
         return a.q.hookSelect ? result.map((row) => ({ ...row })) : result;
       };
       q22.q.log = q2.q.log;
@@ -12992,15 +13152,6 @@ class Db extends QueryMethods {
     const self = this;
     const { softDelete } = options;
     const scopes = options.scopes || softDelete ? {} : orchidCore.emptyObject;
-    this.internal = {
-      transactionStorage,
-      scopes,
-      snakeCase: options.snakeCase,
-      noPrimaryKey: options.noPrimaryKey === "ignore",
-      comment: options.comment,
-      nowSQL: options.nowSQL,
-      tableData
-    };
     this.baseQuery = this;
     this.relations = {};
     this.relationQueries = {};
@@ -13010,6 +13161,7 @@ class Db extends QueryMethods {
     let modifyQuery = void 0;
     let prepareSelectAll = false;
     let hasHookSetters;
+    let runtimeDefaultColumns;
     const { snakeCase } = options;
     for (const key in shape) {
       const column = shape[key];
@@ -13035,9 +13187,8 @@ class Db extends QueryMethods {
         modifyQuery = orchidCore.pushOrNewArray(modifyQuery, (q) => mq(q, column));
       }
       if (typeof column.data.default === "function") {
-        const arr = this.internal.runtimeDefaultColumns;
-        if (!arr) this.internal.runtimeDefaultColumns = [key];
-        else arr.push(key);
+        if (!runtimeDefaultColumns) runtimeDefaultColumns = [key];
+        else runtimeDefaultColumns.push(key);
         if (!column.data.runtimeDefault) {
           const {
             data: { default: def, encode }
@@ -13049,6 +13200,16 @@ class Db extends QueryMethods {
         hasHookSetters = true;
       }
     }
+    this.internal = {
+      runtimeDefaultColumns,
+      transactionStorage,
+      scopes,
+      snakeCase: options.snakeCase,
+      noPrimaryKey: options.noPrimaryKey === "ignore",
+      comment: options.comment,
+      nowSQL: options.nowSQL,
+      tableData
+    };
     this.q = {
       adapter,
       shape,
@@ -13056,7 +13217,7 @@ class Db extends QueryMethods {
       logger,
       log: logParamToLogObject(logger, options.log),
       autoPreparedStatements: options.autoPreparedStatements ?? false,
-      parsers: hasParsers ? parsers : void 0,
+      defaultParsers: hasParsers ? parsers : void 0,
       language: options.language,
       schema: options?.schema
     };
@@ -13597,6 +13758,7 @@ exports._queryOr = _queryOr;
 exports._queryOrNot = _queryOrNot;
 exports._queryRows = _queryRows;
 exports._querySelect = _querySelect;
+exports._querySelectAll = _querySelectAll;
 exports._queryTake = _queryTake;
 exports._queryTakeOptional = _queryTakeOptional;
 exports._queryUnion = _queryUnion;