pqb 0.30.1 → 0.30.2

package/dist/index.d.ts

@@ -796,15 +796,14 @@ declare class Join {
      *   profile: (q) => q.profile,
      * });
      *
-     * // select posts with counts of comments, order by comments count
+     * // select posts with counts of comments, filter and order by comments count
      * // result type is Array<Post & { commentsCount: number }>
      * await db.post
      *   .select('*', {
      *     commentsCount: (q) => q.comments.count(),
      *   })
-     *   .order({
-     *     commentsCount: 'DESC',
-     *   });
+     *   .where({ commentsCount: { gt: 10 } })
+     *   .order({ commentsCount: 'DESC' });
      *
      * // select authors with array of their book titles
      * // result type is Array<Author & { books: string[] }>
@@ -4809,19 +4808,6 @@ declare class MergeQueryMethods {
     merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
 }
 
-declare const queryMethodByReturnType: {
-    [K in QueryReturnType]: 'query' | 'arrays';
-};
-type Resolve = (result: any) => any;
-type Reject = (error: any) => any;
-declare class Then {
-    then: (this: Query, resolve?: Resolve, reject?: Reject) => Promise<unknown>;
-    catch(this: Query, fn: (reason: any) => unknown): Promise<unknown>;
-}
-declare const handleResult: CommonQueryData['handleResult'];
-declare const parseResult: (q: Query, parsers: ColumnsParsers | undefined, returnType: QueryReturnType | undefined, result: QueryResult, isSubQuery?: boolean) => unknown;
-declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
-
 interface SelectSelf {
     shape: QueryColumns;
     relations: RelationsBase;
@@ -4869,12 +4855,20 @@ type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey
     } & (T['meta']['hasSelect'] extends true ? Omit<T['result'], Columns[number]> : unknown)>> : T[K];
 } & QueryMetaHasSelect;
 type SelectAsSelectable<Arg> = {
-    [K in keyof Arg]: Arg[keyof Arg] extends (q: never) => {
+    [K in keyof Arg]: Arg[K] extends (q: never) => {
+        returnType: 'value' | 'valueOrThrow';
         result: QueryColumns;
     } ? {
-        [C in keyof ReturnType<Arg[keyof Arg]>['result'] & string as `${K & string}.${C}`]: {
+        [P in K]: {
+            as: K;
+            column: ReturnType<Arg[K]>['result']['value'];
+        };
+    } : Arg[K] extends (q: never) => {
+        result: QueryColumns;
+    } ? {
+        [C in keyof ReturnType<Arg[K]>['result'] & string as `${K & string}.${C}`]: {
             as: C;
-            column: ReturnType<Arg[keyof Arg]>['result'][C];
+            column: ReturnType<Arg[K]>['result'][C];
         };
     } : never;
 }[keyof Arg];
@@ -6156,6 +6150,11 @@ type QueryHelper<T extends PickQueryMetaShape, Args extends unknown[], Result> =
     result: Result;
 };
 type QueryHelperResult<T extends QueryHelper<Query, unknown[], unknown>> = T['result'];
+type NarrowTypeResult<T extends PickQueryMetaResultReturnType, Narrow> = {
+    [K in keyof T['result']]: K extends keyof Narrow ? {
+        [P in keyof T['result'][K]]: P extends 'outputType' ? Narrow[K] extends T['result'][K]['outputType'] ? Narrow[K] : `narrowType() error: passed type does not exist in '${K & string}'s type union` : T['result'][K][P];
+    } : T['result'][K];
+};
 declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
     name: string;
     result: {
@@ -6182,7 +6181,7 @@ declare const _queryExec: <T extends Query>(q: T) => never;
 declare const _queryFindBy: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOne<WhereResult<T>>;
 declare const _queryFindByOptional: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOneOptional<WhereResult<T>>;
 declare const _queryRows: <T extends Query>(q: T) => SetQueryReturnsRows<T>;
-interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, Then, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods {
+interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods {
 }
 declare class QueryMethods<ColumnTypes> {
     /**
@@ -6698,7 +6697,45 @@ declare class QueryMethods<ColumnTypes> {
      * @param arg - any available column name, such as of a joined table
      */
     ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
+    /**
+     * Narrows a part of the query output type.
+     * Use with caution, type-safety isn't guaranteed with it.
+     * This is similar so using `as` keyword from TypeScript, except that it applies only to a part of the result.
+     *
+     * The syntax `()<{ ... }>()` is enforced by internal limitations.
+     *
+     * ```ts
+     * const rows = db.table
+     *   // filter out records where the `nullableColumn` is null
+     *   .where({ nullableColumn: { not: null } });
+     *   // narrows only a specified column, the rest of result is unchanged
+     *   .narrowType()<{ nullableColumn: string }>()
+     *
+     * // the column had type `string | null`, now it is `string`
+     * rows[0].nullableColumn
+     *
+     * // imagine that table has a enum column kind with variants 'first' | 'second'
+     * // and a boolean `approved`
+     * db.table
+     *   .where({ kind: 'first', approved: true })
+     *   // after applying such `where`, it's safe to narrow the type to receive the literal values
+     *   .narrowType()<{ kind: 'first', approved: true }>();
+     * ```
+     */
+    narrowType<T extends PickQueryMetaResultReturnType>(this: T): <Narrow>() => {
+        [K in keyof T]: K extends 'result' ? NarrowTypeResult<T, Narrow> : K extends 'then' ? QueryThen<GetQueryResult<T, NarrowTypeResult<T, Narrow>>> : T[K];
+    };
+}
+
+declare const queryMethodByReturnType: {
+    [K in QueryReturnType]: 'query' | 'arrays';
+};
+declare class Then {
+    catch(this: Query, fn: (reason: any) => unknown): Promise<unknown>;
 }
+declare const handleResult: CommonQueryData['handleResult'];
+declare const parseResult: (q: Query, parsers: ColumnsParsers | undefined, returnType: QueryReturnType | undefined, result: QueryResult, isSubQuery?: boolean) => unknown;
+declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
 
 declare function queryJson<T>(self: T, coalesce?: boolean): SetQueryReturnsColumnOptional<T, QueryColumn<string>>;
 
@@ -6842,8 +6879,8 @@ declare const queryTypeWithLimitOne: {
     void: true | undefined;
 };
 declare const isQueryReturnsAll: (q: Query) => boolean;
-type QueryReturnsAll<T extends QueryReturnType> = (QueryReturnType extends T ? 'all' : T) extends 'all' ? true : false;
-type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = QueryReturnsAll<T['returnType']> extends true ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : T['returnType'] extends 'void' ? void : never;
+type QueryReturnsAll<T extends QueryReturnType> = QueryReturnType extends T ? true : T extends 'all' ? true : false;
+type GetQueryResult<T extends PickQueryReturnType, Result extends QueryColumns> = QueryReturnsAll<T['returnType']> extends true ? ColumnShapeOutput<Result>[] : T['returnType'] extends 'one' ? ColumnShapeOutput<Result> | undefined : T['returnType'] extends 'oneOrThrow' ? ColumnShapeOutput<Result> : T['returnType'] extends 'value' ? Result['value']['outputType'] | undefined : T['returnType'] extends 'valueOrThrow' ? Result['value']['outputType'] : T['returnType'] extends 'rows' ? ColumnShapeOutput<Result>[keyof Result][][] : T['returnType'] extends 'pluck' ? Result['pluck']['outputType'][] : T['returnType'] extends 'rowCount' ? number : void;
 type AddQuerySelect<T extends PickQueryMetaResultReturnType, Result extends QueryColumns> = {
     [K in keyof T]: K extends 'result' ? {
         [K in (T['meta']['hasSelect'] extends true ? keyof T['result'] : never) | keyof Result]: K extends keyof Result ? Result[K] : K extends keyof T['result'] ? T['result'][K] : never;

package/dist/index.js

@@ -2021,7 +2021,7 @@ const processAnds = (and, ctx, table, query, quotedAs, parens) => {
   return parens && ands.length > 1 ? `(${sql})` : sql;
 };
 const processWhere = (ands, ctx, table, query, data, quotedAs) => {
-  var _a, _b;
+  var _a, _b, _c, _d;
   if (typeof data === "function") {
     const qb = Object.create(table);
     qb.q = getClonedQueryData(query);
@@ -2183,7 +2183,8 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
             column = quotedAs === quoted ? query.shape[name] : (_b = (_a = query.joinedShapes) == null ? void 0 : _a[table2]) == null ? void 0 : _b[name];
             quotedColumn = simpleColumnToSQL(ctx, name, column, quoted);
           } else {
-            quotedColumn = void 0;
+            column = (_d = (_c = query.joinedShapes) == null ? void 0 : _c[key]) == null ? void 0 : _d.value;
+            quotedColumn = `"${key}".r`;
           }
           if (!column || !quotedColumn) {
             throw new Error(`Unknown column ${key} provided to condition`);
@@ -3456,6 +3457,8 @@ const getShapeFromSelect = (q, isSubQuery) => {
             }
           }
         }
+      } else if (orchidCore.isExpression(item)) {
+        result.value = item.result.value;
       }
     }
   }
@@ -7190,15 +7193,14 @@ class Join {
    *   profile: (q) => q.profile,
    * });
    *
-   * // select posts with counts of comments, order by comments count
+   * // select posts with counts of comments, filter and order by comments count
    * // result type is Array<Post & { commentsCount: number }>
    * await db.post
    *   .select('*', {
    *     commentsCount: (q) => q.comments.count(),
    *   })
-   *   .order({
-   *     commentsCount: 'DESC',
-   *   });
+   *   .where({ commentsCount: { gt: 10 } })
+   *   .order({ commentsCount: 'DESC' });
    *
    * // select authors with array of their book titles
    * // result type is Array<Author & { books: string[] }>
@@ -11066,6 +11068,34 @@ class QueryMethods {
     }
     return new RefExpression(column, q.q, arg);
   }
+  /**
+   * Narrows a part of the query output type.
+   * Use with caution, type-safety isn't guaranteed with it.
+   * This is similar so using `as` keyword from TypeScript, except that it applies only to a part of the result.
+   *
+   * The syntax `()<{ ... }>()` is enforced by internal limitations.
+   *
+   * ```ts
+   * const rows = db.table
+   *   // filter out records where the `nullableColumn` is null
+   *   .where({ nullableColumn: { not: null } });
+   *   // narrows only a specified column, the rest of result is unchanged
+   *   .narrowType()<{ nullableColumn: string }>()
+   *
+   * // the column had type `string | null`, now it is `string`
+   * rows[0].nullableColumn
+   *
+   * // imagine that table has a enum column kind with variants 'first' | 'second'
+   * // and a boolean `approved`
+   * db.table
+   *   .where({ kind: 'first', approved: true })
+   *   // after applying such `where`, it's safe to narrow the type to receive the literal values
+   *   .narrowType()<{ kind: 'first', approved: true }>();
+   * ```
+   */
+  narrowType() {
+    return () => this;
+  }
 }
 orchidCore.applyMixins(QueryMethods, [
   QueryBase,