pqb 0.11.4 → 0.11.5

package/dist/index.d.ts

@@ -291,7 +291,8 @@ type JoinedShapes = Record<string, ColumnsShapeBase>;
 type CommonQueryData = {
     adapter: Adapter;
     shape: ColumnsShapeBase;
-    handleResult(q: Query, result: QueryResult, isSubQuery?: true): Promise<unknown> | unknown;
+    patchResult?(queryResult: QueryResult): Promise<void>;
+    handleResult(q: Query, result: QueryResult, isSubQuery?: true): unknown;
     returnType: QueryReturnType;
     [relationQueryKey]?: RelationQueryData;
     wrapInTransaction?: boolean;
@@ -1119,10 +1120,10 @@ type UpdateResult<T extends Query> = T['meta']['hasSelect'] extends true ? T : S
 type ChangeCountArg<T extends Query> = keyof T['shape'] | Partial<Record<keyof T['shape'], number>>;
 type UpdateCtx = {
     willSetKeys?: true;
-    updateLater?: Record<string, unknown>;
-    updateLaterPromises?: Promise<void>[];
     returnTypeAll?: true;
     resultAll: Record<string, unknown>[];
+    queries?: ((queryResult: QueryResult) => Promise<void>)[];
+    updateData?: Record<string, unknown>;
 };
 declare class Update {
     update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T>;

package/dist/index.js

@@ -3695,225 +3695,6 @@ class QueryGet {
   }
 }
 
-const queryMethodByReturnType = {
-  all: "query",
-  rows: "arrays",
-  pluck: "arrays",
-  one: "query",
-  oneOrThrow: "query",
-  value: "arrays",
-  valueOrThrow: "arrays",
-  rowCount: "arrays",
-  void: "arrays"
-};
-let queryError = void 0;
-class Then {
-  get then() {
-    queryError = new Error();
-    return maybeWrappedThen;
-  }
-  async catch(fn) {
-    return this.then(void 0, fn);
-  }
-}
-const handleResult = (q, result, isSubQuery) => {
-  return parseResult(
-    q,
-    q.query.parsers,
-    q.query.returnType || "all",
-    result,
-    isSubQuery
-  );
-};
-function maybeWrappedThen(resolve, reject) {
-  const adapter = this.internal.transactionStorage.getStore();
-  if (this.query.wrapInTransaction && !adapter) {
-    return this.transaction(
-      () => new Promise((resolve2, reject2) => {
-        const adapter2 = this.internal.transactionStorage.getStore();
-        return then(this, adapter2, resolve2, reject2);
-      })
-    ).then(resolve, reject);
-  } else {
-    return then(this, adapter || this.query.adapter, resolve, reject);
-  }
-}
-const queriesNames = {};
-let nameI = 0;
-const then = async (q, adapter, resolve, reject) => {
-  let sql;
-  let logData;
-  const localError = queryError;
-  try {
-    let beforeCallbacks;
-    let afterCallbacks;
-    if (q.query.type === "insert") {
-      beforeCallbacks = q.query.beforeCreate;
-      afterCallbacks = q.query.afterCreate;
-    } else if (q.query.type === "update") {
-      beforeCallbacks = q.query.beforeUpdate;
-      afterCallbacks = q.query.afterUpdate;
-    } else if (q.query.type === "delete") {
-      beforeCallbacks = q.query.beforeDelete;
-      afterCallbacks = q.query.afterDelete;
-    }
-    if (beforeCallbacks || q.query.beforeQuery) {
-      await Promise.all(
-        getCallbacks(beforeCallbacks, q.query.beforeQuery).map((cb) => cb(q))
-      );
-    }
-    sql = q.toSql();
-    if (q.query.autoPreparedStatements) {
-      sql.name = queriesNames[sql.text] || (queriesNames[sql.text] = (nameI++).toString(36));
-    }
-    if (q.query.log) {
-      logData = q.query.log.beforeQuery(sql);
-    }
-    const queryResult = await adapter[queryMethodByReturnType[q.query.returnType || "all"]](sql);
-    if (q.query.log) {
-      q.query.log.afterQuery(sql, logData);
-      sql = void 0;
-    }
-    const result = await q.query.handleResult(q, queryResult);
-    if (afterCallbacks || q.query.afterQuery) {
-      await Promise.all(
-        getCallbacks(q.query.afterQuery, afterCallbacks).map(
-          (query) => query(q, result)
-        )
-      );
-    }
-    resolve == null ? void 0 : resolve(result);
-  } catch (err) {
-    let error;
-    if (err instanceof pg.DatabaseError) {
-      error = new q.error();
-      assignError(error, err);
-      error.cause = localError;
-    } else {
-      error = err;
-      if (error instanceof Error) {
-        error.cause = localError;
-      }
-    }
-    if (q.query.log && sql && logData) {
-      q.query.log.onError(error, sql, logData);
-    }
-    reject == null ? void 0 : reject(error);
-  }
-};
-const assignError = (to, from) => {
-  to.message = from.message;
-  to.length = from.length;
-  to.name = from.name;
-  to.severity = from.severity;
-  to.code = from.code;
-  to.detail = from.detail;
-  to.hint = from.hint;
-  to.position = from.position;
-  to.internalPosition = from.internalPosition;
-  to.internalQuery = from.internalQuery;
-  to.where = from.where;
-  to.schema = from.schema;
-  to.table = from.table;
-  to.column = from.column;
-  to.dataType = from.dataType;
-  to.constraint = from.constraint;
-  to.file = from.file;
-  to.line = from.line;
-  to.routine = from.routine;
-  return to;
-};
-const parseResult = (q, parsers, returnType = "all", result, isSubQuery) => {
-  var _a, _b;
-  switch (returnType) {
-    case "all": {
-      if (q.query.throwOnNotFound && result.rows.length === 0)
-        throw new NotFoundError(q);
-      return parsers ? result.rows.map((row) => parseRecord(parsers, row)) : result.rows;
-    }
-    case "one": {
-      const row = result.rows[0];
-      if (!row)
-        return;
-      return parsers ? parseRecord(parsers, row) : row;
-    }
-    case "oneOrThrow": {
-      const row = result.rows[0];
-      if (!row)
-        throw new NotFoundError(q);
-      return parsers ? parseRecord(parsers, row) : row;
-    }
-    case "rows": {
-      return parsers ? parseRows(
-        parsers,
-        result.fields,
-        result.rows
-      ) : result.rows;
-    }
-    case "pluck": {
-      if (parsers == null ? void 0 : parsers.pluck) {
-        if (isSubQuery) {
-          return result.rows.map((row) => parsers.pluck(row));
-        }
-        return result.rows.map((row) => parsers.pluck(row[0]));
-      } else if (isSubQuery) {
-        return result.rows;
-      }
-      return result.rows.map((row) => row[0]);
-    }
-    case "value": {
-      const value = (_a = result.rows[0]) == null ? void 0 : _a[0];
-      return value !== void 0 ? parseValue(value, parsers) : q.query.notFoundDefault;
-    }
-    case "valueOrThrow": {
-      const value = (_b = result.rows[0]) == null ? void 0 : _b[0];
-      if (value === void 0)
-        throw new NotFoundError(q);
-      return parseValue(value, parsers);
-    }
-    case "rowCount": {
-      if (q.query.throwOnNotFound && result.rowCount === 0) {
-        throw new NotFoundError(q);
-      }
-      return result.rowCount;
-    }
-    case "void": {
-      return;
-    }
-  }
-};
-const parseRecord = (parsers, row) => {
-  for (const key in parsers) {
-    if (row[key] !== null && row[key] !== void 0) {
-      row[key] = parsers[key](row[key]);
-    }
-  }
-  return row;
-};
-const parseRows = (parsers, fields, rows) => {
-  fields.forEach((field, i) => {
-    const parser = parsers[field.name];
-    if (parser) {
-      rows.forEach((row) => {
-        row[i] = parser(row[i]);
-      });
-    }
-  });
-  return rows;
-};
-const parseValue = (value, parsers) => {
-  if (value !== null) {
-    const parser = parsers == null ? void 0 : parsers[getValueKey];
-    if (parser) {
-      return parser(value);
-    }
-  }
-  return value;
-};
-const getCallbacks = (first, second) => {
-  return first && second ? [...first, ...second] : first ? first : second;
-};
-
 var __defProp$8 = Object.defineProperty;
 var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
 var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
@@ -3958,7 +3739,7 @@ const addParserForSelectItem = (q, as, key, arg) => {
         addParserToQuery(q.query, key, (item) => {
           const t = rel.query.returnType || "all";
           subQueryResult.rows = t === "value" || t === "valueOrThrow" ? [[item]] : t === "one" || t === "oneOrThrow" ? [item] : item;
-          return parseResult(rel, rel.query.parsers, t, subQueryResult, true);
+          return rel.query.handleResult(rel, subQueryResult, true);
         });
       }
     }
@@ -3999,7 +3780,11 @@ const processSelectArg = (q, as, arg, columnAs) => {
       if (parsers) {
         addParserToQuery(q.query, arg, (item) => {
           subQueryResult.rows = [item];
-          return parseResult(q, parsers, "one", subQueryResult, true);
+          const type = q.query.returnType;
+          q.query.returnType = "one";
+          const res = q.query.handleResult(q, subQueryResult, true);
+          q.query.returnType = type;
+          return res;
         });
       }
       return arg;
@@ -4568,7 +4353,7 @@ class ColumnInfoMethods {
     if (column) {
       this.query.column = column;
     }
-    this.query.handleResult = async (_, result) => {
+    this.query.handleResult = (_, result) => {
       if (column) {
         return rowToColumnInfo(result.rows[0]);
       } else {
@@ -4758,6 +4543,228 @@ class Having {
   }
 }
 
+const queryMethodByReturnType = {
+  all: "query",
+  rows: "arrays",
+  pluck: "arrays",
+  one: "query",
+  oneOrThrow: "query",
+  value: "arrays",
+  valueOrThrow: "arrays",
+  rowCount: "arrays",
+  void: "arrays"
+};
+let queryError = void 0;
+class Then {
+  get then() {
+    queryError = new Error();
+    return maybeWrappedThen;
+  }
+  async catch(fn) {
+    return this.then(void 0, fn);
+  }
+}
+const handleResult = (q, result, isSubQuery) => {
+  return parseResult(
+    q,
+    q.query.parsers,
+    q.query.returnType || "all",
+    result,
+    isSubQuery
+  );
+};
+function maybeWrappedThen(resolve, reject) {
+  const adapter = this.internal.transactionStorage.getStore();
+  if (this.query.wrapInTransaction && !adapter) {
+    return this.transaction(
+      () => new Promise((resolve2, reject2) => {
+        const adapter2 = this.internal.transactionStorage.getStore();
+        return then(this, adapter2, resolve2, reject2);
+      })
+    ).then(resolve, reject);
+  } else {
+    return then(this, adapter || this.query.adapter, resolve, reject);
+  }
+}
+const queriesNames = {};
+let nameI = 0;
+const then = async (q, adapter, resolve, reject) => {
+  let sql;
+  let logData;
+  const localError = queryError;
+  try {
+    let beforeCallbacks;
+    let afterCallbacks;
+    if (q.query.type === "insert") {
+      beforeCallbacks = q.query.beforeCreate;
+      afterCallbacks = q.query.afterCreate;
+    } else if (q.query.type === "update") {
+      beforeCallbacks = q.query.beforeUpdate;
+      afterCallbacks = q.query.afterUpdate;
+    } else if (q.query.type === "delete") {
+      beforeCallbacks = q.query.beforeDelete;
+      afterCallbacks = q.query.afterDelete;
+    }
+    if (beforeCallbacks || q.query.beforeQuery) {
+      await Promise.all(
+        getCallbacks(beforeCallbacks, q.query.beforeQuery).map((cb) => cb(q))
+      );
+    }
+    sql = q.toSql();
+    if (q.query.autoPreparedStatements) {
+      sql.name = queriesNames[sql.text] || (queriesNames[sql.text] = (nameI++).toString(36));
+    }
+    if (q.query.log) {
+      logData = q.query.log.beforeQuery(sql);
+    }
+    const queryResult = await adapter[queryMethodByReturnType[q.query.returnType || "all"]](sql);
+    if (q.query.patchResult) {
+      await q.query.patchResult(queryResult);
+    }
+    if (q.query.log) {
+      q.query.log.afterQuery(sql, logData);
+      sql = void 0;
+    }
+    const result = q.query.handleResult(q, queryResult);
+    if (afterCallbacks || q.query.afterQuery) {
+      await Promise.all(
+        getCallbacks(q.query.afterQuery, afterCallbacks).map(
+          (query) => query(q, result)
+        )
+      );
+    }
+    resolve == null ? void 0 : resolve(result);
+  } catch (err) {
+    let error;
+    if (err instanceof pg.DatabaseError) {
+      error = new q.error();
+      assignError(error, err);
+      error.cause = localError;
+    } else {
+      error = err;
+      if (error instanceof Error) {
+        error.cause = localError;
+      }
+    }
+    if (q.query.log && sql && logData) {
+      q.query.log.onError(error, sql, logData);
+    }
+    reject == null ? void 0 : reject(error);
+  }
+};
+const assignError = (to, from) => {
+  to.message = from.message;
+  to.length = from.length;
+  to.name = from.name;
+  to.severity = from.severity;
+  to.code = from.code;
+  to.detail = from.detail;
+  to.hint = from.hint;
+  to.position = from.position;
+  to.internalPosition = from.internalPosition;
+  to.internalQuery = from.internalQuery;
+  to.where = from.where;
+  to.schema = from.schema;
+  to.table = from.table;
+  to.column = from.column;
+  to.dataType = from.dataType;
+  to.constraint = from.constraint;
+  to.file = from.file;
+  to.line = from.line;
+  to.routine = from.routine;
+  return to;
+};
+const parseResult = (q, parsers, returnType = "all", result, isSubQuery) => {
+  var _a, _b;
+  switch (returnType) {
+    case "all": {
+      if (q.query.throwOnNotFound && result.rows.length === 0)
+        throw new NotFoundError(q);
+      return parsers ? result.rows.map((row) => parseRecord(parsers, row)) : result.rows;
+    }
+    case "one": {
+      const row = result.rows[0];
+      if (!row)
+        return;
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case "oneOrThrow": {
+      const row = result.rows[0];
+      if (!row)
+        throw new NotFoundError(q);
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case "rows": {
+      return parsers ? parseRows(
+        parsers,
+        result.fields,
+        result.rows
+      ) : result.rows;
+    }
+    case "pluck": {
+      if (parsers == null ? void 0 : parsers.pluck) {
+        if (isSubQuery) {
+          return result.rows.map((row) => parsers.pluck(row));
+        }
+        return result.rows.map((row) => parsers.pluck(row[0]));
+      } else if (isSubQuery) {
+        return result.rows;
+      }
+      return result.rows.map((row) => row[0]);
+    }
+    case "value": {
+      const value = (_a = result.rows[0]) == null ? void 0 : _a[0];
+      return value !== void 0 ? parseValue(value, parsers) : q.query.notFoundDefault;
+    }
+    case "valueOrThrow": {
+      const value = (_b = result.rows[0]) == null ? void 0 : _b[0];
+      if (value === void 0)
+        throw new NotFoundError(q);
+      return parseValue(value, parsers);
+    }
+    case "rowCount": {
+      if (q.query.throwOnNotFound && result.rowCount === 0) {
+        throw new NotFoundError(q);
+      }
+      return result.rowCount;
+    }
+    case "void": {
+      return;
+    }
+  }
+};
+const parseRecord = (parsers, row) => {
+  for (const key in parsers) {
+    if (row[key] !== null && row[key] !== void 0) {
+      row[key] = parsers[key](row[key]);
+    }
+  }
+  return row;
+};
+const parseRows = (parsers, fields, rows) => {
+  fields.forEach((field, i) => {
+    const parser = parsers[field.name];
+    if (parser) {
+      rows.forEach((row) => {
+        row[i] = parser(row[i]);
+      });
+    }
+  });
+  return rows;
+};
+const parseValue = (value, parsers) => {
+  if (value !== null) {
+    const parser = parsers == null ? void 0 : parsers[getValueKey];
+    if (parser) {
+      return parser(value);
+    }
+  }
+  return value;
+};
+const getCallbacks = (first, second) => {
+  return first && second ? [...first, ...second] : first ? first : second;
+};
+
 var __defProp$5 = Object.defineProperty;
 var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
 var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
@@ -4867,11 +4874,11 @@ const insert = (self, {
   }
   if (returnType === "oneOrThrow" || ((_a = values.from) == null ? void 0 : _a.query.returnType) === "oneOrThrow") {
     const { handleResult } = q.query;
-    q.query.handleResult = async (q2, r, i) => {
+    q.query.handleResult = (q2, r, s) => {
       if (r.rowCount === 0) {
         throw new NotFoundError(q2);
       }
-      return await handleResult(q2, r, i);
+      return handleResult(q2, r, s);
     };
   }
   const requiredColumns = Object.keys(ctx.requiredReturning);
@@ -4887,14 +4894,15 @@ const insert = (self, {
   if (ctx.returnTypeAll) {
     q.query.returnType = "all";
     const { handleResult } = q.query;
-    q.query.handleResult = async (q2, queryResult, i) => {
-      ctx.resultAll = await handleResult(q2, queryResult, i);
+    q.query.handleResult = (q2, queryResult, s) => {
+      ctx.resultAll = handleResult(q2, queryResult, s);
       if (queryMethodByReturnType[returnType] === "arrays") {
         queryResult.rows.forEach(
-          (row, i2) => queryResult.rows[i2] = Object.values(row)
+          (row, i) => queryResult.rows[i] = Object.values(row)
         );
       }
-      return parseResult(q2, q2.query.parsers, returnType, queryResult);
+      q2.query.returnType = returnType;
+      return handleResult(q2, queryResult, s);
     };
   } else {
     q.query.returnType = returnType;
@@ -5791,39 +5799,44 @@ class Update {
     if (!ctx.willSetKeys && checkIfUpdateIsEmpty(query)) {
       delete query.type;
     }
-    if (ctx.updateLater) {
-      if (!((_a = query.select) == null ? void 0 : _a.includes("*"))) {
-        this.primaryKeys.forEach((key) => {
-          var _a2;
-          if (!((_a2 = query.select) == null ? void 0 : _a2.includes(key))) {
-            this._select(key);
+    const { queries } = ctx;
+    if (queries || ctx.returnTypeAll) {
+      query.returnType = "all";
+      if (queries) {
+        if (!((_a = query.select) == null ? void 0 : _a.includes("*"))) {
+          this.primaryKeys.forEach((key) => {
+            var _a2;
+            if (!((_a2 = query.select) == null ? void 0 : _a2.includes(key))) {
+              this._select(key);
+            }
+          });
+        }
+        query.patchResult = async (queryResult) => {
+          await Promise.all(queries.map((fn) => fn(queryResult)));
+          if (ctx.updateData) {
+            const t = this.baseQuery.clone();
+            const keys = this.primaryKeys;
+            t._whereIn(
+              keys,
+              queryResult.rows.map((item) => keys.map((key) => item[key]))
+            );
+            await t._update(ctx.updateData);
+            for (const row of queryResult.rows) {
+              Object.assign(row, ctx.updateData);
+            }
           }
-        });
+        };
       }
-    }
-    if (ctx.updateLater || ctx.returnTypeAll) {
-      query.returnType = "all";
       const { handleResult } = query;
-      query.handleResult = async (q, queryResult, i) => {
-        ctx.resultAll = await handleResult(q, queryResult, i);
-        if (ctx.updateLater) {
-          await Promise.all(ctx.updateLaterPromises);
-          const t = this.baseQuery.clone();
-          const keys = this.primaryKeys;
-          t._whereIn(
-            keys,
-            ctx.resultAll.map((item) => keys.map((key) => item[key]))
-          );
-          await t._update(ctx.updateLater);
-          ctx.resultAll.forEach((item) => Object.assign(item, ctx.updateLater));
-        }
+      query.handleResult = (q, queryResult, s) => {
+        ctx.resultAll = handleResult(q, queryResult);
         if (queryMethodByReturnType[originalReturnType] === "arrays") {
           queryResult.rows.forEach(
-            (row, i2) => queryResult.rows[i2] = Object.values(row)
+            (row, i) => queryResult.rows[i] = Object.values(row)
           );
         }
         q.query.returnType = originalReturnType;
-        return parseResult(q, q.query.parsers, originalReturnType, queryResult);
+        return handleResult(q, queryResult, s);
       };
     }
     return update(this);
@@ -5969,16 +5982,29 @@ class QueryUpsertOrCreate {
     this.query.returnType = "one";
     this.query.wrapInTransaction = true;
     const { handleResult } = this.query;
-    this.query.handleResult = (q, queryResult, i) => {
+    let result;
+    let created = false;
+    this.query.handleResult = (q, r, s) => {
+      return created ? result : handleResult(q, r, s);
+    };
+    this.query.patchResult = async (queryResult) => {
       if (queryResult.rowCount === 0) {
-        return q.create(data);
+        const inner = this.create(data);
+        const { handleResult: handleResult2 } = inner.query;
+        inner.query.handleResult = (q, r, s) => {
+          queryResult = r;
+          const res = handleResult2(q, r, s);
+          result = res;
+          return res;
+        };
+        await inner;
+        created = true;
       } else if (queryResult.rowCount > 1) {
         throw new MoreThanOneRowError(
-          q,
+          this,
           `Only one row was expected to find, found ${queryResult.rowCount} rows.`
         );
       }
-      return handleResult(q, queryResult, i);
     };
     return this;
   }