pqb 0.40.9 → 0.40.10

package/dist/index.d.ts

@@ -1885,6 +1885,13 @@ interface QueryMetaHasWhere {
         hasWhere: true;
     };
 }
+interface QueryFnReturningSelect {
+    (q: never): {
+        meta: {
+            hasSelect: true;
+        };
+    };
+}
 /**
  * Mutative {@link Where.prototype.where}
  */
@@ -2485,6 +2492,10 @@ declare class Where {
      * // find by a relation name if it's defined
      * db.user.whereExists('account');
      *
+     * // find users who have an account with positive balance
+     * // `accounts` is a relation name
+     * db.user.whereExists((q) => q.accounts.where({ balance: { gt: 0 } }));
+     *
      * // find using a table and a join conditions
      * db.user.whereExists(db.account, 'account.id', 'user.id');
      *
@@ -2492,7 +2503,11 @@ declare class Where {
      * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
      * ```
      */
-    whereExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
+    whereExists<T extends PickQueryMetaShapeRelationsWithData, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): Arg extends QueryFnReturningSelect ? {
+        error: 'Cannot select in whereExists';
+    } : Args[0] extends QueryFnReturningSelect ? {
+        error: 'Cannot select in whereExists';
+    } : WhereResult<T>;
     /**
      * Acts as `whereExists`, but prepends the condition with `OR`:
      *
@@ -3349,6 +3364,16 @@ type DbTableOptionScopes<Table extends string | undefined, Shape extends QueryCo
 type QueryDefaultReturnData<Shape extends QueryColumnsInit> = {
     [K in DefaultSelectColumns<Shape>]: Shape[K]['outputType'];
 }[];
+interface TableMeta<Table extends string | undefined, Shape extends QueryColumnsInit, ShapeWithComputed extends QueryColumnsInit, Scopes extends RecordUnknown | undefined> extends QueryMetaBase<{
+    [K in keyof Scopes]: true;
+}> {
+    kind: 'select';
+    defaults: {
+        [K in keyof Shape as unknown extends Shape[K]['data']['default'] ? never : K]: true;
+    };
+    selectable: SelectableFromShape<ShapeWithComputed, Table>;
+    defaultSelect: DefaultSelectColumns<Shape>;
+}
 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>>;
@@ -3359,17 +3384,7 @@ interface Db<Table extends string | undefined = undefined, Shape extends QueryCo
     relations: EmptyObject;
     withData: EmptyObject;
     error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
-    meta: {
-        kind: 'select';
-        defaults: {
-            [K in keyof Shape as unknown extends Shape[K]['data']['default'] ? never : K]: true;
-        };
-        scopes: {
-            [K in keyof Scopes]: true;
-        };
-        selectable: SelectableFromShape<ShapeWithComputed, Table>;
-        defaultSelect: DefaultSelectColumns<Shape>;
-    };
+    meta: TableMeta<Table, Shape, ShapeWithComputed, Scopes>;
     internal: QueryInternal<{
         [K in keyof PrimaryKeys]: (keyof PrimaryKeys extends K ? never : keyof PrimaryKeys) extends never ? PrimaryKeys[K] : never;
     }[keyof PrimaryKeys], PrimaryKeys | UniqueColumns, {

package/dist/index.js

@@ -2578,6 +2578,13 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, whereExists) => {
     s: joinSubQuery
   };
 };
+const preprocessJoinArg = (q, arg) => {
+  if (typeof arg !== "function")
+    return arg;
+  arg = arg(q.relations);
+  arg.joinQueryAfterCallback = arg.joinQuery;
+  return arg;
+};
 const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo) => {
   const q = joinedQuery.baseQuery.clone();
   q.baseQuery = q;
@@ -2640,10 +2647,7 @@ const _join = (query, require2, type, first, args) => {
   let batchParsers;
   let computeds;
   let joinSubQuery = false;
-  if (typeof first === "function") {
-    first = first(query.relations);
-    first.joinQueryAfterCallback = first.joinQuery;
-  }
+  first = preprocessJoinArg(query, first);
   if (typeof first === "object") {
     if (require2 && isQueryNone(first)) {
       return _queryNone(query);
@@ -9814,7 +9818,13 @@ const _queryWhereIn = (q, and, arg, values, not) => {
   return q;
 };
 const existsArgs = (self, q, args) => {
-  const joinArgs = processJoinArgs(self, q, args, false, true);
+  const joinArgs = processJoinArgs(
+    self,
+    preprocessJoinArg(self, q),
+    args,
+    false,
+    true
+  );
   return [
     {
       EXISTS: joinArgs
@@ -10457,6 +10467,10 @@ class Where {
    * // find by a relation name if it's defined
    * db.user.whereExists('account');
    *
+   * // find users who have an account with positive balance
+   * // `accounts` is a relation name
+   * db.user.whereExists((q) => q.accounts.where({ balance: { gt: 0 } }));
+   *
    * // find using a table and a join conditions
    * db.user.whereExists(db.account, 'account.id', 'user.id');
    *