pqb 0.13.2 → 0.13.3

package/dist/index.d.ts

@@ -849,8 +849,8 @@ declare abstract class Where extends QueryBase {
     _or<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
     _orNot<T extends Where>(this: T, ...args: WhereArg<T>[]): WhereResult<T>;
-    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): T;
-    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): T;
+    whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
+    whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _whereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _whereIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     orWhereIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
@@ -1903,10 +1903,10 @@ declare class Update {
      * You need to provide `.where`, `.findBy`, or `.find` conditions before calling `.update`.
      * To ensure that the whole table won't be updated by accident, updating without where conditions will result in TypeScript and runtime errors.
      *
-     * If you need to update ALL records, use `where` method without arguments:
+     * Use `all()` to update ALL records without conditions:
      *
      * ```ts
-     * await db.table.where().update({ name: 'new name' });
+     * await db.table.all().update({ name: 'new name' });
      * ```
      *
      * If `.select` and `.where` were specified before the update it will return an array of updated records.
@@ -2088,10 +2088,10 @@ declare class Delete {
      * Need to provide `.where`, `.findBy`, or `.find` conditions before calling `.delete`.
      * To prevent accidental deletion of all records, deleting without where will result in TypeScript and a runtime error.
      *
-     * To delete all records without conditions add an empty `where`:
+     * Use `all()` to delete ALL records without conditions:
      *
      * ```ts
-     * await db.table.where().delete();
+     * await db.table.all().delete();
      * ```
      *
      * ```ts
@@ -2121,7 +2121,7 @@ declare class Delete {
      *
      * ```ts
      * // delete all users who have corresponding profile records:
-     * db.table.join(Profile, 'profile.userId', 'user.id').where().delete();
+     * db.table.join(Profile, 'profile.userId', 'user.id').all().delete();
      * ```
      */
     delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
@@ -2867,8 +2867,6 @@ type QueryHelper<T extends Query, Args extends unknown[], Result> = <Q extends {
 interface QueryMethods extends Omit<AsMethods, 'result'>, Aggregate, Select, From, Join, With, Union, Omit<JsonModifiers, 'result'>, JsonMethods, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Omit<Where, 'result'>, Clear, Having, Window, Then, QueryLog, Omit<QueryHooks, 'result'>, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods, CopyMethods, TransformMethods {
 }
 declare class QueryMethods {
-    windows: EmptyObject;
-    baseQuery: Query;
     /**
      * `.all` is a default behavior, that returns an array of objects:
      *
@@ -2940,6 +2938,31 @@ declare class QueryMethods {
      */
     exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
     _exec<T extends Query>(this: T): SetQueryReturnsVoid<T>;
+    /**
+     * Call `toSql` on a query to get an object with a `text` SQL string and a `values` array of binding values:
+     *
+     * ```ts
+     * const sql = db.table.select('id', 'name').where({ name: 'name' }).toSql();
+     *
+     * expect(sql.text).toBe(
+     *   'SELECT "table"."id", "table"."name" FROM "table" WHERE "table"."name" = $1',
+     * );
+     * expect(sql.values).toEqual(['name']);
+     * ```
+     *
+     * `toSql` is called internally when awaiting a query.
+     *
+     * It is caching the result. Not mutating query methods are resetting the cache, but need to be careful with mutating methods that start with `_` - they won't reset the cache, which may lead to unwanted results.
+     *
+     * `toSql` optionally accepts such parameters:
+     *
+     * ```ts
+     * type ToSqlOptions = {
+     *   clearCache?: true;
+     *   values?: [];
+     * };
+     * ```
+     */
     toSql(this: Query, options?: ToSqlOptions): Sql;
     /**
      * Adds a `DISTINCT` keyword to `SELECT`:
@@ -3388,7 +3411,7 @@ type SetSelect<T extends Pick<Query, 'result' | 'meta'>, Result extends ColumnsS
 type SetQueryReturns<T extends Query, R extends QueryReturnType, Data = GetQueryResult<R, T['result']>> = {
     [K in keyof T]: K extends 'returnType' ? R : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
 };
-type SetQueryReturnsAll<T extends Query> = SetQueryReturns<T, 'all'>;
+type SetQueryReturnsAll<T extends Query> = SetQueryReturns<WhereResult<T>, 'all'>;
 type SetQueryReturnsOneOptional<T extends Query> = SetQueryReturns<T, 'one'>;
 type SetQueryReturnsOne<T extends Query> = SetQueryReturns<T, 'oneOrThrow'>;
 type SetQueryReturnsRows<T extends Query> = SetQueryReturns<T, 'rows'>;

package/dist/index.js

@@ -2029,8 +2029,9 @@ const pushWhereToSql = (sql, ctx, table, query, quotedAs, not) => {
   }
 };
 const whereToSql = (ctx, table, query, quotedAs, not) => {
+  var _a;
   if (query.or) {
-    const ors = query.and ? [query.and, ...query.or] : query.or;
+    const ors = ((_a = query.and) == null ? void 0 : _a.length) ? [query.and, ...query.or] : query.or;
     return ors.map((and) => processAnds(and, ctx, table, query, quotedAs, not)).join(" OR ");
   } else if (query.and) {
     return processAnds(query.and, ctx, table, query, quotedAs, not);
@@ -2603,7 +2604,8 @@ const pushWithSql = (ctx, withData) => {
 };
 
 const checkIfASimpleQuery = (q) => {
-  if (q.query.returnType && q.query.returnType !== "all" || q.internal.columnsForSelectAll)
+  var _a, _b;
+  if (q.query.returnType && q.query.returnType !== "all" || q.internal.columnsForSelectAll || ((_a = q.query.and) == null ? void 0 : _a.length) || ((_b = q.query.or) == null ? void 0 : _b.length))
     return false;
   const keys = Object.keys(q.query);
   return !keys.some((key) => queryKeysOfNotSimpleQuery.includes(key));
@@ -2612,8 +2614,6 @@ const queryKeysOfNotSimpleQuery = [
   "with",
   "as",
   "from",
-  "and",
-  "or",
   "select",
   "distinct",
   "fromOnly",
@@ -4943,10 +4943,10 @@ class Delete {
    * Need to provide `.where`, `.findBy`, or `.find` conditions before calling `.delete`.
    * To prevent accidental deletion of all records, deleting without where will result in TypeScript and a runtime error.
    *
-   * To delete all records without conditions add an empty `where`:
+   * Use `all()` to delete ALL records without conditions:
    *
    * ```ts
-   * await db.table.where().delete();
+   * await db.table.all().delete();
    * ```
    *
    * ```ts
@@ -4976,7 +4976,7 @@ class Delete {
    *
    * ```ts
    * // delete all users who have corresponding profile records:
-   * db.table.join(Profile, 'profile.userId', 'user.id').where().delete();
+   * db.table.join(Profile, 'profile.userId', 'user.id').all().delete();
    * ```
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -7111,10 +7111,10 @@ class Update {
    * You need to provide `.where`, `.findBy`, or `.find` conditions before calling `.update`.
    * To ensure that the whole table won't be updated by accident, updating without where conditions will result in TypeScript and runtime errors.
    *
-   * If you need to update ALL records, use `where` method without arguments:
+   * Use `all()` to update ALL records without conditions:
    *
    * ```ts
-   * await db.table.where().update({ name: 'new name' });
+   * await db.table.all().update({ name: 'new name' });
    * ```
    *
    * If `.select` and `.where` were specified before the update it will return an array of updated records.
@@ -7907,7 +7907,9 @@ class QueryMethods {
     return this.clone()._all();
   }
   _all() {
+    var _a, _b;
     this.query.returnType = "all";
+    (_b = (_a = this.query).and) != null ? _b : _a.and = [];
     return this;
   }
   /**
@@ -7997,6 +7999,31 @@ class QueryMethods {
     this.query.returnType = "void";
     return this;
   }
+  /**
+   * Call `toSql` on a query to get an object with a `text` SQL string and a `values` array of binding values:
+   *
+   * ```ts
+   * const sql = db.table.select('id', 'name').where({ name: 'name' }).toSql();
+   *
+   * expect(sql.text).toBe(
+   *   'SELECT "table"."id", "table"."name" FROM "table" WHERE "table"."name" = $1',
+   * );
+   * expect(sql.values).toEqual(['name']);
+   * ```
+   *
+   * `toSql` is called internally when awaiting a query.
+   *
+   * It is caching the result. Not mutating query methods are resetting the cache, but need to be careful with mutating methods that start with `_` - they won't reset the cache, which may lead to unwanted results.
+   *
+   * `toSql` optionally accepts such parameters:
+   *
+   * ```ts
+   * type ToSqlOptions = {
+   *   clearCache?: true;
+   *   values?: [];
+   * };
+   * ```
+   */
   toSql(options) {
     return toSql(this, options);
   }