pqb 0.11.31 → 0.11.32

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { Sql, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, QueryResultRow, AdapterBase, QueryInput, ColumnsParsers, getValueKey, StringKey, ColumnOutput, QueryThen, QueryCatch, NullableColumn, EmptyTuple, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, SetOptional, Spread, CoalesceString, QueryCommon, BaseNumberData, Code, ColumnWithDefault, numberTypeMethods, BaseStringData, PrimaryKeyColumn, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, JSONTypeAny, record, ArrayMethodsData, arrayMethods, ForeignKeyTable, name, ColumnNameOfTable, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
+import { Sql, QueryBaseCommon, ColumnsShapeBase, QueryInternal, QueryMetaBase, EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, QueryResultRow, AdapterBase, QueryInput, ColumnsParsers, getValueKey, StringKey, ColumnOutput, QueryThen, QueryCatch, NullableColumn, EmptyTuple, ColumnTypesBase, ColumnShapeOutput, DefaultSelectColumns, DbBase, SetOptional, MergeObjects, CoalesceString, QueryCommon, Spread, BaseNumberData, Code, ColumnWithDefault, numberTypeMethods, BaseStringData, PrimaryKeyColumn, DateTypeMethods, DateColumnData, EncodeColumn, ParseColumn, JSONTypeAny, record, ArrayMethodsData, arrayMethods, ForeignKeyTable, name, ColumnNameOfTable, ColumnDataBase, BaseOperators, ValidationContext, MessageParam } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -1436,15 +1436,10 @@ declare class QueryGet {
     _getOptional<T extends Query, Arg extends GetArg<T>>(this: T, arg: Arg): GetOptionalResult<T, Arg>;
 }
 
-type MergeQuery<T extends Query, Q extends Query, ReturnType extends QueryReturnType = QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'], Data = T['meta']['hasSelect'] extends true ? GetQueryResult<ReturnType, Spread<[T['result'], Q['result']]>> : GetQueryResult<ReturnType, Q['result']>> = Omit<T, 'result' | 'returnType' | 'then' | 'catch' | 'selectable' | 'windows' | 'withData'> & {
-    meta: Q['meta'];
-    result: T['meta']['hasSelect'] extends true ? Spread<[T['result'], Q['result']]> : Q['result'];
-    returnType: ReturnType;
-    then: QueryThen<Data>;
-    catch: QueryCatch<Data>;
-    selectable: T['selectable'] & Q['selectable'];
-    windows: T['windows'] & Q['windows'];
-    withData: T['withData'] & Q['withData'];
+type MergeQuery<T extends Query, Q extends Query, ReturnType extends QueryReturnType = QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'], Result extends ColumnsShapeBase = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? {
+    [K in keyof T['result'] | keyof Q['result']]: K extends keyof Q['result'] ? Q['result'][K] : T['result'][K];
+} : T['result'] : Q['result'], Data = GetQueryResult<ReturnType, Result>> = {
+    [K in keyof T]: K extends 'meta' ? MergeObjects<T['meta'], Q['meta']> : K extends 'result' ? Result : K extends 'returnType' ? ReturnType : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : K extends 'selectable' ? T['selectable'] & Q['selectable'] : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
 };
 declare class MergeQueryMethods {
     merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
@@ -1510,6 +1505,9 @@ type OrderArg<T extends Query, Key extends PropertyKey = keyof T['selectable'] |
 } | RawExpression;
 type OrderArgs<T extends Query> = OrderArg<T>[] | [TemplateStringsArray, ...unknown[]];
 type FindArgs<T extends Query> = [T['shape'][T['singlePrimaryKey']]['type'] | RawExpression] | [TemplateStringsArray, ...unknown[]];
+type QueryHelper<T extends Query, Args extends unknown[], Result> = <Q extends {
+    [K in keyof T]: K extends 'then' ? QueryThen<unknown> : K extends 'result' ? ColumnsShapeBase : T[K];
+}>(q: Q, ...args: Args) => Result extends Query ? MergeQuery<Q, Result> : Result;
 interface QueryMethods extends Omit<AsMethods, 'result'>, Aggregate, Select, From, Join, With, Union, Json, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, Clear, Having, Window, Then, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods, CopyMethods {
 }
 declare class QueryMethods {
@@ -1562,6 +1560,44 @@ declare class QueryMethods {
         restartIdentity?: boolean;
         cascade?: boolean;
     }): SetQueryReturnsVoid<T>;
+    /**
+     * Use `makeHelper` to make a query helper - a function where you can modify the query, and reuse this function across different places.
+     *
+     * ```ts
+     * const defaultAuthorSelect = db.author.makeHelper((q) => {
+     *   return q.select('firstName', 'lastName');
+     * });
+     *
+     * // this will select id, firstName, lastName with a correct TS type
+     * // and return a single record
+     * const result = await defaultAuthorSelect(db.author.select('id').find(1));
+     * ```
+     *
+     * Such helper is available for relation queries inside `select`:
+     *
+     * ```ts
+     * await db.book.select({
+     *   author: (book) => defaultAuthorSelect(book.author),
+     * });
+     * ```
+     *
+     * Helper can accept additional arguments:
+     *
+     * ```ts
+     * const selectFollowing = db.user.makeHelper((q, currentUser: { id: number }) => {
+     *   return q.select({
+     *     following: (q) =>
+     *       q.followers.where({ followerId: currentUser.id }).exists(),
+     *   });
+     * });
+     *
+     * // select some columns and the `following` boolean field from users
+     * await selectFollowing(db.user.select('id', 'name'), currentUser);
+     * ```
+     *
+     * @param fn - helper function
+     */
+    makeHelper<T extends Query, Args extends unknown[], Result>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
 }
 
 type AggregateArg<T extends Query> = Expression<T> | Record<string, Expression<T>> | [Expression<T>, string];

package/dist/index.js

@@ -3658,11 +3658,22 @@ class Adapter {
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   query(query, types2) {
-    return performQuery(this.pool, query, types2, this.schema);
+    return performQuery(
+      this.pool,
+      query,
+      types2,
+      this.schema
+    );
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   arrays(query, types2) {
-    return performQuery(this.pool, query, types2, this.schema, "array");
+    return performQuery(
+      this.pool,
+      query,
+      types2,
+      this.schema,
+      "array"
+    );
   }
   async transaction(begin, cb) {
     const client = await this.pool.connect();
@@ -6582,6 +6593,46 @@ class QueryMethods {
     }
     return this._exec();
   }
+  /**
+   * Use `makeHelper` to make a query helper - a function where you can modify the query, and reuse this function across different places.
+   *
+   * ```ts
+   * const defaultAuthorSelect = db.author.makeHelper((q) => {
+   *   return q.select('firstName', 'lastName');
+   * });
+   *
+   * // this will select id, firstName, lastName with a correct TS type
+   * // and return a single record
+   * const result = await defaultAuthorSelect(db.author.select('id').find(1));
+   * ```
+   *
+   * Such helper is available for relation queries inside `select`:
+   *
+   * ```ts
+   * await db.book.select({
+   *   author: (book) => defaultAuthorSelect(book.author),
+   * });
+   * ```
+   *
+   * Helper can accept additional arguments:
+   *
+   * ```ts
+   * const selectFollowing = db.user.makeHelper((q, currentUser: { id: number }) => {
+   *   return q.select({
+   *     following: (q) =>
+   *       q.followers.where({ followerId: currentUser.id }).exists(),
+   *   });
+   * });
+   *
+   * // select some columns and the `following` boolean field from users
+   * await selectFollowing(db.user.select('id', 'name'), currentUser);
+   * ```
+   *
+   * @param fn - helper function
+   */
+  makeHelper(fn) {
+    return fn;
+  }
 }
 orchidCore.applyMixins(QueryMethods, [
   QueryBase,