pqb 0.40.7 → 0.40.9

package/dist/index.d.ts

@@ -384,6 +384,8 @@ interface CommonQueryData {
     outerJoinOverrides?: JoinOverrides;
     schema?: string;
     select?: SelectItem[];
+    selectAllColumns?: string[];
+    selectAllKeys?: RecordUnknown;
     /**
      * column type for query with 'value' or 'valueOrThrow' return type
      * Is needed in {@link getShapeFromSelect} to get shape of sub-select that returns a single value.
@@ -3345,16 +3347,15 @@ type DbTableOptionScopes<Table extends string | undefined, Shape extends QueryCo
     [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => QueryBase;
 };
 type QueryDefaultReturnData<Shape extends QueryColumnsInit> = {
-    [K in DefaultSelectColumns<Shape>[number]]: Shape[K]['outputType'];
+    [K in DefaultSelectColumns<Shape>]: Shape[K]['outputType'];
 }[];
 declare const anyShape: QueryColumnsInit;
 interface Db<Table extends string | undefined = undefined, Shape extends QueryColumnsInit = QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject> extends DbBase<Adapter, Table, Shape, ColumnTypes, ShapeWithComputed>, QueryMethods<ColumnTypes>, QueryBase {
-    result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
+    result: Pick<Shape, DefaultSelectColumns<Shape>>;
     queryBuilder: Db;
     returnType: undefined;
     then: QueryThen<QueryDefaultReturnData<Shape>>;
     windows: Query['windows'];
-    defaultSelectColumns: DefaultSelectColumns<Shape>;
     relations: EmptyObject;
     withData: EmptyObject;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
@@ -3367,6 +3368,7 @@ interface Db<Table extends string | undefined = undefined, Shape extends QueryCo
             [K in keyof Scopes]: true;
         };
         selectable: SelectableFromShape<ShapeWithComputed, Table>;
+        defaultSelect: DefaultSelectColumns<Shape>;
     };
     internal: QueryInternal<{
         [K in keyof PrimaryKeys]: (keyof PrimaryKeys extends K ? never : keyof PrimaryKeys) extends never ? PrimaryKeys[K] : never;
@@ -4764,7 +4766,7 @@ type FromResult<T extends FromQuerySelf, Arg extends MaybeArray<FromArg<T>>> = A
     } : K extends 'result' ? T['withData'][Arg]['shape'] : K extends 'then' ? QueryThen<GetQueryResult<T, T['withData'][Arg]['shape']>> : T[K];
 } : SetQueryTableAlias<T, Arg> : Arg extends PickQueryTableMetaResultInputType ? {
     [K in keyof T]: K extends 'meta' ? {
-        [K in keyof T['meta']]: K extends 'as' ? AliasOrTable<Arg> : K extends 'selectable' ? SelectableFromShape<Arg['result'], AliasOrTable<Arg>> : K extends 'kind' ? 'select' : T['meta'][K];
+        [K in keyof T['meta']]: K extends 'as' ? AliasOrTable<Arg> : K extends 'selectable' ? SelectableFromShape<Arg['result'], AliasOrTable<Arg>> : K extends 'kind' ? 'select' : K extends 'defaultSelect' ? keyof Arg['result'] : T['meta'][K];
     } : K extends 'result' ? Arg['result'] : K extends 'shape' ? Arg['result'] : K extends 'inputType' ? Arg['inputType'] : K extends 'then' ? QueryThen<GetQueryResult<T, Arg['result']>> : T[K];
 } : Arg extends (infer A)[] ? {
     [K in keyof T]: K extends 'meta' ? {
@@ -5022,8 +5024,129 @@ declare class AfterCommitError extends OrchidOrmError {
 }
 declare const _afterCommitError: (result: unknown, hookResults: AfterCommitErrorResult[], catchAfterCommitError: ((error: AfterCommitError) => void) | undefined) => void;
 declare class Transaction {
-    transaction<T extends PickQueryQAndInternal, Result>(this: T, cb: () => Promise<Result>): Promise<Result>;
-    transaction<T extends PickQueryQAndInternal, Result>(this: T, options: IsolationLevel | TransactionOptions, cb: () => Promise<Result>): Promise<Result>;
+    /**
+     * In Orchid ORM the method is `$transaction`, when using `pqb` on its own it is `transaction`.
+     *
+     * `COMMIT` happens automatically after the callback was successfully resolved, and `ROLLBACK` is done automatically if the callback fails.
+     *
+     * Let's consider the case of transferring money from one user to another:
+     *
+     * ```ts
+     * export const transferMoney = async (
+     *   fromId: number,
+     *   toId: number,
+     *   amount: number,
+     * ) => {
+     *   try {
+     *     // db.$transaction returns data that is returned from the callback
+     *     // result here is senderRemainder
+     *     const result = await db.$transaction(async () => {
+     *       const sender = await db.user.find(fromId);
+     *       const senderRemainder = sender.balance - amount;
+     *       if (senderRemainder < 0) {
+     *         throw new Error('Sender does not have enough money');
+     *       }
+     *
+     *       await db.user.find(fromId).decrement({
+     *         balance: amount,
+     *       });
+     *       await db.user.find(toId).increment({
+     *         balance: amount,
+     *       });
+     *
+     *       return senderRemainder;
+     *     });
+     *   } catch (error) {
+     *     // handle transaction error
+     *   }
+     * };
+     * ```
+     *
+     * It performs 3 queries in a single transaction: load sender record, decrement sender's balance, increment receiver's balance.
+     *
+     * If sender or receiver record doesn't exist, it will throw `NotFound` error, and there is an error thrown when sender's balance is too low.
+     * In such case, the transaction will be rolled back and no changes will be applied to the database.
+     *
+     * Internally, ORM relies on [AsyncLocalStorage](https://nodejs.org/api/async_context.html#class-asynclocalstorage) feature of node.js,
+     * it allows passing the transaction object implicitly. So that any query that is done inside of callback, will run inside a transaction.
+     *
+     * ## nested transactions
+     *
+     * Transactions can be nested one in another.
+     * The top level transaction is the real one,
+     * and the nested ones are emulated with [savepoint](https://www.postgresql.org/docs/current/sql-savepoint.html) instead of `BEGIN`
+     * and [release savepoint](https://www.postgresql.org/docs/current/sql-release-savepoint.html) instead of `COMMIT`.
+     *
+     * Use [ensureTransaction](#ensuretransaction) to run all queries in a single transaction.
+     *
+     * ```ts
+     * const result = await db.$transaction(async () => {
+     *   await db.table.create(...one);
+     *
+     *   const result = await db.$transaction(async () => {
+     *     await db.table.create(...two);
+     *     return 123;
+     *   });
+     *
+     *   await db.table.create(...three);
+     *
+     *   return result;
+     * });
+     *
+     * // result is returned from the inner transaction
+     * result === 123;
+     * ```
+     *
+     * If the inner transaction throws an error, and it is caught by `try/catch` of outer transaction,
+     * it performs [rollback to savepoint](https://www.postgresql.org/docs/current/sql-rollback-to.html)
+     * and the outer transaction can continue:
+     *
+     * ```ts
+     * class CustomError extends Error {}
+     *
+     * await db.$transaction(async () => {
+     *   try {
+     *     await db.$transaction(async () => {
+     *       throw new CustomError();
+     *     });
+     *   } catch (err) {
+     *     if (err instanceof CustomError) {
+     *       // ignore this error
+     *       return;
+     *     }
+     *     throw err;
+     *   }
+     *
+     *   // this transaction can continue
+     *   await db.table.create(...data);
+     * });
+     * ```
+     *
+     * If the error in the inner transaction is not caught, all nested transactions are rolled back and aborted.
+     */
+    transaction<Result>(this: PickQueryQAndInternal, cb: () => Promise<Result>): Promise<Result>;
+    transaction<Result>(this: PickQueryQAndInternal, options: IsolationLevel | TransactionOptions, cb: () => Promise<Result>): Promise<Result>;
+    /**
+     * Use the `$ensureTransaction` when you want to ensure the sequence of queries is running in a transaction, but there is no need for Postgres [savepoints](https://www.postgresql.org/docs/current/sql-savepoint.html).
+     *
+     * ```ts
+     * async function updateUserBalance(userId: string, amount: number) {
+     *   await db.$ensureTransaction(async () => {
+     *     await db.transfer.create({ userId, amount })
+     *     await db.user.find(userId).increment({ balance: amount })
+     *   })
+     * }
+     *
+     * async function saveDeposit(userId: string, deposit: { ... }) {
+     *   await db.$ensureTransaction(async () => {
+     *     await db.deposit.create(deposit)
+     *     // transaction in updateUserBalance won't be started
+     *     await updateUserBalance(userId, deposit.amount)
+     *   })
+     * }
+     * ```
+     */
+    ensureTransaction<Result>(this: PickQueryQAndInternal, cb: () => Promise<Result>): Promise<Result>;
 }
 
 type AfterHook<Select extends PropertyKey[], Shape extends QueryColumns> = QueryAfterHook<{
@@ -5243,11 +5366,11 @@ interface SelectAsCheckReturnTypes {
 }
 type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
     [K in keyof T]: K extends 'result' ? ('*' extends Columns[number] ? {
-        [K in Columns[number] | keyof T['shape'] as K extends '*' ? never : T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
+        [K in Columns[number] | T['meta']['defaultSelect'] as K extends '*' ? never : T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     } : {
         [K in Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     }) & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown) : K extends 'then' ? QueryThen<GetQueryResult<T, ('*' extends Columns[number] ? {
-        [K in Exclude<Columns[number], '*'> | keyof T['shape'] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
+        [K in Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     } : {
         [K in Columns[number] as T['meta']['selectable'][K]['as']]: T['meta']['selectable'][K]['column'];
     }) & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
@@ -5270,9 +5393,9 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
         selectable: SelectAsSelectable<Obj>;
     } : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
     {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown) : K extends 'then' ? QueryThen<GetQueryResult<T, {
-        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
+        [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 };
 type SelectAsSelectable<Arg> = {
@@ -7479,7 +7602,6 @@ interface Query extends QueryBase, QueryMethods<unknown> {
     then: QueryThen<unknown>;
     catch: QueryCatch;
     windows: EmptyObject;
-    defaultSelectColumns: string[];
     relations: RelationsBase;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError;
 }

package/dist/index.js

@@ -805,8 +805,8 @@ const columnCode = (type, ctx, key, code, data = type.data, skip) => {
       orchidCore.addCode(code, part);
     }
   }
-  if (data.isHidden)
-    orchidCore.addCode(code, ".hidden()");
+  if (data.explicitSelect)
+    orchidCore.addCode(code, ".select(false)");
   if (data.isNullable)
     orchidCore.addCode(code, ".nullable()");
   if (type.encodeFn && type.encodeFn !== (skip == null ? void 0 : skip.encodeFn))
@@ -2358,7 +2358,7 @@ const getArgQueryTarget = (ctx, first, joinSubQuery, cloned) => {
   }
 };
 const subJoinToSql = (ctx, jq, innerAs, outerAs, cloned) => {
-  if (!jq.q.select && jq.internal.columnsForSelectAll) {
+  if (!jq.q.select && jq.q.selectAllColumns) {
     if (!cloned)
       jq = jq.clone();
     jq.q.select = [new RawSQL(`${innerAs}.*`)];
@@ -2695,7 +2695,7 @@ const _join = (query, require2, type, first, args) => {
   );
   if (joinKey && "s" in joinArgs && joinArgs.s) {
     const j = "j" in joinArgs ? (_b = joinArgs.r) != null ? _b : joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
-    if (j.q.select || !j.internal.columnsForSelectAll) {
+    if (j.q.select || !j.q.selectAllColumns) {
       const shape2 = getShapeFromSelect(j, true);
       setQueryObjectValue(
         query,
@@ -3397,6 +3397,32 @@ class Transaction {
       }
     }
   }
+  /**
+   * Use the `$ensureTransaction` when you want to ensure the sequence of queries is running in a transaction, but there is no need for Postgres [savepoints](https://www.postgresql.org/docs/current/sql-savepoint.html).
+   *
+   * ```ts
+   * async function updateUserBalance(userId: string, amount: number) {
+   *   await db.$ensureTransaction(async () => {
+   *     await db.transfer.create({ userId, amount })
+   *     await db.user.find(userId).increment({ balance: amount })
+   *   })
+   * }
+   *
+   * async function saveDeposit(userId: string, deposit: { ... }) {
+   *   await db.$ensureTransaction(async () => {
+   *     await db.deposit.create(deposit)
+   *     // transaction in updateUserBalance won't be started
+   *     await updateUserBalance(userId, deposit.amount)
+   *   })
+   * }
+   * ```
+   */
+  ensureTransaction(cb) {
+    const trx = this.internal.transactionStorage.getStore();
+    if (trx)
+      return cb();
+    return Transaction.prototype.transaction.call(this, cb);
+  }
 }
 const runAfterCommit = async (afterCommit, result) => {
   if (afterCommit) {
@@ -4689,7 +4715,7 @@ class SelectItemExpression extends orchidCore.Expression {
   }
   // `makeSQL` acts similarly to how select args are handled
   makeSQL(ctx, quotedAs) {
-    return typeof this.item === "string" ? this.item === "*" ? selectAllSql(this.query, this.q, quotedAs) : columnToSql(ctx, this.q, this.q.shape, this.item, quotedAs, true) : this.item.toSQL(ctx, quotedAs);
+    return typeof this.item === "string" ? this.item === "*" ? selectAllSql(this.q, quotedAs) : columnToSql(ctx, this.q, this.q.shape, this.item, quotedAs, true) : this.item.toSQL(ctx, quotedAs);
   }
 }
 
@@ -4823,12 +4849,14 @@ function queryFrom(self, arg) {
     data.batchParsers = q.q.batchParsers;
   }
   data.from = arg;
+  data.selectAllColumns = data.selectAllKeys = void 0;
   return self;
 }
 function queryFromSql(self, args) {
   const data = self.q;
   data.as || (data.as = "t");
   data.from = sqlQueryArgsToExpression(args);
+  data.selectAllColumns = data.selectAllKeys = void 0;
   return self;
 }
 class FromMethods {
@@ -4943,11 +4971,11 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect)
         if (item === "*") {
           if (hookSelect) {
             selected != null ? selected : selected = {};
-            for (const key in table.internal.columnsKeysForSelectAll || query.shape) {
+            for (const key in query.selectAllKeys || query.shape) {
               selected[key] = quotedAs;
             }
           }
-          sql = selectAllSql(table, query, quotedAs);
+          sql = selectAllSql(query, quotedAs);
         } else {
           const index = item.indexOf(".");
           if (index !== -1) {
@@ -5049,15 +5077,15 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect)
       list.push(sql);
     }
   }
-  return list.length ? list.join(", ") : query.select ? "" : selectAllSql(table, query, quotedAs);
+  return list.length ? list.join(", ") : query.select ? "" : selectAllSql(query, quotedAs);
 };
 function selectedObjectToSQL(ctx, quotedAs, item) {
   const sql = item.toSQL(ctx, quotedAs);
   return ctx.aliasValue ? `${sql} r` : sql;
 }
-const selectAllSql = (table, query, quotedAs) => {
+const selectAllSql = (query, quotedAs) => {
   var _a, _b, _c;
-  return ((_a = query.join) == null ? void 0 : _a.length) ? ((_b = table.internal.columnsForSelectAll) == null ? void 0 : _b.map((item) => `${quotedAs}.${item}`).join(", ")) || `${quotedAs}.*` : ((_c = table.internal.columnsForSelectAll) == null ? void 0 : _c.join(", ")) || "*";
+  return ((_a = query.join) == null ? void 0 : _a.length) ? ((_b = query.selectAllColumns) == null ? void 0 : _b.map((item) => `${quotedAs}.${item}`).join(", ")) || `${quotedAs}.*` : ((_c = query.selectAllColumns) == null ? void 0 : _c.join(", ")) || "*";
 };
 const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
   var _a, _b, _c;
@@ -5251,7 +5279,7 @@ const pushWithSql = (ctx, items) => {
 
 const checkIfASimpleQuery = (q) => {
   var _a, _b;
-  if (q.q.returnType && q.q.returnType !== "all" || q.internal.columnsForSelectAll || ((_a = q.q.and) == null ? void 0 : _a.length) || ((_b = q.q.or) == null ? void 0 : _b.length) || q.q.scopes)
+  if (q.q.returnType && q.q.returnType !== "all" || q.q.selectAllColumns || ((_a = q.q.and) == null ? void 0 : _a.length) || ((_b = q.q.or) == null ? void 0 : _b.length) || q.q.scopes)
     return false;
   const keys = Object.keys(q.q);
   return !keys.some((key) => queryKeysOfNotSimpleQuery.includes(key));
@@ -5279,7 +5307,7 @@ const pushFromAndAs = (ctx, table, data, quotedAs) => {
   const from = getFrom(ctx, table, data, quotedAs);
   sql += from;
   if (data.as && quotedAs && quotedAs !== from) {
-    sql += ` AS ${quotedAs}`;
+    sql += ` ${quotedAs}`;
   }
   for (const as in data.sources) {
     const source = data.sources[as];
@@ -9413,16 +9441,17 @@ var __spreadValues$5 = (a, b) => {
     }
   return a;
 };
-const mergableObjects = {
-  shape: true,
-  withShapes: true,
-  parsers: true,
-  defaults: true,
-  joinedShapes: true,
-  joinedParsers: true,
-  joinedBatchParsers: true,
-  selectedComputeds: true
-};
+const mergableObjects = /* @__PURE__ */ new Set([
+  "shape",
+  "withShapes",
+  "parsers",
+  "defaults",
+  "joinedShapes",
+  "joinedParsers",
+  "joinedBatchParsers",
+  "selectedComputeds"
+]);
+const dontMergeArrays = /* @__PURE__ */ new Set(["selectAllColumns", "selectAllKeys"]);
 class MergeQueryMethods {
   merge(q) {
     const query = this.clone();
@@ -9438,8 +9467,10 @@ class MergeQueryMethods {
           break;
         case "object":
           if (Array.isArray(value)) {
-            a[key] = a[key] ? [...a[key], ...value] : value;
-          } else if (mergableObjects[key]) {
+            if (!dontMergeArrays.has(key)) {
+              a[key] = a[key] ? [...a[key], ...value] : value;
+            }
+          } else if (mergableObjects.has(key)) {
             a[key] = a[key] ? __spreadValues$5(__spreadValues$5({}, a[key]), value) : value;
           } else if (key === "union") {
             a[key] = a[key] ? {
@@ -11359,7 +11390,11 @@ class QueryUpsertOrCreate {
     if (!orchidCore.isObjectEmpty(updateData)) {
       _queryUpdate(q, updateData);
     }
-    return orCreate(q, data.create, updateData, mergeData);
+    const c = orCreate(q, data.create, updateData, mergeData);
+    if (!c.q.select) {
+      c.q.returnType = "void";
+    }
+    return c;
   }
   /**
    * `orCreate` creates a record only if it was not found by conditions.
@@ -12660,7 +12695,7 @@ class Db {
     const parsers = {};
     let hasParsers = false;
     let modifyQuery = void 0;
-    let hasCustomName = false;
+    let prepareSelectAll = false;
     const { snakeCase } = options;
     for (const key in shape) {
       const column = shape[key];
@@ -12670,14 +12705,17 @@ class Db {
         parsers[key] = column.parseFn;
       }
       if (column.data.name) {
-        hasCustomName = true;
+        prepareSelectAll = true;
       } else if (snakeCase) {
         const snakeName = orchidCore.toSnakeCase(key);
         if (snakeName !== key) {
-          hasCustomName = true;
+          prepareSelectAll = true;
           column.data.name = snakeName;
         }
       }
+      if (column.data.explicitSelect) {
+        prepareSelectAll = true;
+      }
       const { modifyQuery: mq } = column.data;
       if (mq) {
         modifyQuery = orchidCore.pushOrNewArray(modifyQuery, (q) => mq(q, column));
@@ -12697,17 +12735,6 @@ class Db {
         }
       }
     }
-    if (hasCustomName) {
-      const list = [];
-      for (const key in shape) {
-        const column = shape[key];
-        list.push(
-          column.data.name ? `"${column.data.name}" AS "${key}"` : `"${key}"`
-        );
-      }
-      this.internal.columnsForSelectAll = list;
-      this.internal.columnsKeysForSelectAll = __spreadValues({}, shape);
-    }
     this.q = {
       adapter,
       shape,
@@ -12740,21 +12767,22 @@ class Db {
     const columns = Object.keys(
       shape
     );
-    const { toSQL } = this;
     this.columns = columns;
-    this.defaultSelectColumns = columns.filter(
-      (column) => !shape[column].data.isHidden
-    );
     if (options.computed)
       applyComputedColumns(this, options.computed);
-    const defaultSelect = this.defaultSelectColumns.length === columns.length ? void 0 : this.defaultSelectColumns;
-    this.toSQL = defaultSelect ? function(options2) {
-      const q = this.clone();
-      if (!q.q.select) {
-        q.q.select = defaultSelect;
-      }
-      return toSQL.call(q, options2);
-    } : toSQL;
+    if (prepareSelectAll) {
+      const list = [];
+      for (const key in shape) {
+        const column = shape[key];
+        if (!column.data.explicitSelect) {
+          list.push(
+            column.data.name ? `"${column.data.name}" AS "${key}"` : `"${key}"`
+          );
+        }
+      }
+      this.q.selectAllColumns = list;
+      this.q.selectAllKeys = __spreadValues({}, shape);
+    }
     if (modifyQuery) {
       for (const cb of modifyQuery) {
         cb(this);