pqb 0.25.0 → 0.25.1

package/dist/index.js

@@ -98,6 +98,9 @@ function raw(...args) {
   return orchidCore.isTemplateLiteralArgs(args) ? new RawSQL(args) : typeof args[0] === "function" ? new DynamicRawSQL(args[0]) : new RawSQL(args[0].raw, args[0].values);
 }
 const countSelect = [new RawSQL("count(*)")];
+function sqlQueryArgsToExpression(args) {
+  return Array.isArray(args[0]) ? new RawSQL(args) : args[0];
+}
 
 var __defProp$g = Object.defineProperty;
 var __defProps$a = Object.defineProperties;
@@ -2110,31 +2113,28 @@ class AsMethods {
   }
 }
 
-function queryFrom(self, args) {
-  if (Array.isArray(args[0])) {
-    return queryFrom(self, [
-      new RawSQL(args)
-    ]);
-  }
+function queryFrom(self, arg, options) {
   const data = self.q;
-  if (typeof args[0] === "string") {
-    data.as || (data.as = args[0]);
-  } else if (!orchidCore.isExpression(args[0])) {
-    const q = args[0];
+  if (typeof arg === "string") {
+    data.as || (data.as = arg);
+  } else if (!orchidCore.isExpression(arg)) {
+    const q = arg;
     data.as || (data.as = q.q.as || q.table || "t");
-    data.shape = getShapeFromSelect(
-      args[0],
-      true
-    );
+    data.shape = getShapeFromSelect(arg, true);
     data.parsers = q.q.parsers;
   } else {
     data.as || (data.as = "t");
   }
-  const options = args[1];
   if (options == null ? void 0 : options.only) {
     data.fromOnly = options.only;
   }
-  data.from = args[0];
+  data.from = arg;
+  return self;
+}
+function queryFromSql(self, args) {
+  const data = self.q;
+  data.as || (data.as = "t");
+  data.from = sqlQueryArgsToExpression(args);
   return self;
 }
 class From {
@@ -2145,13 +2145,6 @@ class From {
    * // accepts sub-query:
    * db.table.from(Otherdb.table.select('foo', 'bar'));
    *
-   * // accepts raw sql by template literal:
-   * const value = 123;
-   * db.table.from`value = ${value}`;
-   *
-   * // accepts raw sql:
-   * db.table.from(db.table.sql`value = ${value}`);
-   *
    * // accepts alias of `WITH` expression:
    * q.with('foo', Otherdb.table.select('id', 'name')).from('foo');
    * ```
@@ -2164,10 +2157,29 @@ class From {
    * });
    * ```
    *
-   * @param args - query, raw SQL, name of CTE table, or a template string
+   * @param arg - query or name of CTE table
+   * @param options - { only: true } for SQL `ONLY` keyword
    */
-  from(...args) {
+  from(arg, options) {
     return queryFrom(
+      this.clone(),
+      arg,
+      options
+    );
+  }
+  /**
+   * Set the `FROM` value with custom SQL:
+   *
+   * ```ts
+   * const value = 123;
+   * db.table.from`value = ${value}`;
+   * db.table.from(db.table.sql`value = ${value}`);
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  fromSql(...args) {
+    return queryFromSql(
       this.clone(),
       args
     );
@@ -2175,7 +2187,7 @@ class From {
 }
 
 function queryWrap(self, query, as = "t") {
-  return _queryAs(queryFrom(query, [self]), as);
+  return _queryAs(queryFrom(query, self), as);
 }
 
 function queryJson(self, coalesce) {
@@ -6167,12 +6179,6 @@ class Having {
    * // HAVING count(*) >= 10
    * ```
    *
-   * Alternatively, it accepts a raw SQL template:
-   *
-   * ```ts
-   * db.table.having`count(*) >= ${10}`;
-   * ```
-   *
    * Multiple having conditions will be combined with `AND`:
    *
    * ```ts
@@ -6218,11 +6224,23 @@ class Having {
     return pushQueryValue(
       q,
       "having",
-      "raw" in args[0] ? args : args.map(
+      args.map(
         (arg) => arg(q).q.expr
       )
     );
   }
+  /**
+   * Provide SQL expression for the `HAVING` SQL statement:
+   *
+   * ```ts
+   * db.table.having`count(*) >= ${10}`;
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  havingSql(...args) {
+    return pushQueryValue(this.clone(), "having", args);
+  }
 }
 
 const before = (q, key, cb) => pushQueryValue(q, `before${key}`, cb);
@@ -6475,29 +6493,29 @@ class QueryBase {
 }
 
 const _queryWhere = (q, args) => {
-  if (Array.isArray(args[0])) {
-    return pushQueryValue(
-      q,
-      "and",
-      new RawSQL(args)
-    );
-  }
   return pushQueryArray(
     q,
     "and",
     args
   );
 };
+const _queryWhereSql = (q, args) => {
+  return pushQueryValue(
+    q,
+    "and",
+    sqlQueryArgsToExpression(args)
+  );
+};
 const _queryWhereNot = (q, args) => {
-  if (Array.isArray(args[0])) {
-    return pushQueryValue(q, "and", {
-      NOT: new RawSQL(args)
-    });
-  }
   return pushQueryValue(q, "and", {
     NOT: args
   });
 };
+const _queryWhereNotSql = (q, args) => {
+  return pushQueryValue(q, "and", {
+    NOT: sqlQueryArgsToExpression(args)
+  });
+};
 const _queryOr = (q, args) => {
   return pushQueryArray(
     q,
@@ -6580,7 +6598,7 @@ class Where {
    *   },
    *
    *   // where column equals to raw SQL
-   *   column: db.table.sql`raw expression`,
+   *   column: db.table.sql`sql expression`,
    * });
    * ```
    *
@@ -6629,9 +6647,6 @@ class Where {
    * `where` supports raw SQL:
    *
    * ```ts
-   * db.table.where`a = b`;
-   *
-   * // or
    * db.table.where(db.table.sql`a = b`);
    *
    * // or
@@ -6956,6 +6971,29 @@ class Where {
       args
     );
   }
+  /**
+   * Use a custom SQL expression in `WHERE` statement:
+   *
+   * ```ts
+   * db.table.where`a = b`;
+   *
+   * // or
+   * db.table.where(db.table.sql`a = b`);
+   *
+   * // or
+   * import { raw } from 'orchid-orm';
+   *
+   * db.table.where(raw`a = b`);
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  whereSql(...args) {
+    return _queryWhereSql(
+      this.clone(),
+      args
+    );
+  }
   /**
    * `whereNot` takes the same argument as `where`,
    * multiple conditions are combined with `AND`,
@@ -6977,6 +7015,18 @@ class Where {
       args
     );
   }
+  /**
+   * `whereNot` version accepting SQL expression:
+   *
+   * ```ts
+   * db.table.whereNot`sql expression`
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  whereNotSql(...args) {
+    return _queryWhereNotSql(this.clone(), args);
+  }
   /**
    * `orWhere` is accepting the same arguments as {@link where}, joining arguments with `OR`.
    *
@@ -9014,12 +9064,10 @@ class Update {
    * @param args - raw SQL via a template string or by using a `sql` method
    */
   updateRaw(...args) {
-    const q = this.clone();
-    if (Array.isArray(args[0])) {
-      const sql = new RawSQL(args);
-      return _queryUpdateRaw(q, sql);
-    }
-    return _queryUpdateRaw(q, args[0]);
+    return _queryUpdateRaw(
+      this.clone(),
+      sqlQueryArgsToExpression(args)
+    );
   }
   /**
    * To make sure that at least one row was updated use `updateOrThrow`:
@@ -10061,7 +10109,7 @@ class QueryMethods {
    * The `find` method is available only for tables which has exactly one primary key.
    * And also it can accept raw SQL template literal, then the primary key is not required.
    *
-   * Find record by id, throw [NotFoundError](/guide/error-handling.html) if not found:
+   * Finds a record by id, throws {@link NotFoundError} if not found:
    *
    * ```ts
    * await db.table.find(1);
@@ -10074,13 +10122,9 @@ class QueryMethods {
    * `;
    * ```
    *
-   * @param args - primary key value to find by, or a raw SQL
+   * @param value - primary key value to find by
    */
-  find(...args) {
-    let [value] = args;
-    if (Array.isArray(value)) {
-      value = new RawSQL(args);
-    }
+  find(value) {
     const q = this.clone();
     if (value === null || value === void 0) {
       throw new OrchidOrmInternalError(
@@ -10097,22 +10141,54 @@ class QueryMethods {
     );
   }
   /**
-   * Find a single record by the primary key (id), adds `LIMIT 1`, can accept a raw SQL.
+   * Finds a single record with a given SQL, throws {@link NotFoundError} if not found:
+   *
+   * ```ts
+   * await db.user.find`
+   *   age = ${age} AND
+   *   name = ${name}
+   * `;
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  findBySql(...args) {
+    const q = this.clone();
+    return _queryTake(_queryWhereSql(q, args));
+  }
+  /**
+   * Find a single record by the primary key (id), adds `LIMIT 1`.
    * Returns `undefined` when not found.
    *
    * ```ts
    * const result: TableType | undefined = await db.table.find(123);
    * ```
    *
-   * @param args - primary key value to find by, or a raw SQL
+   * @param value - primary key value to find by, or a raw SQL
    */
-  findOptional(...args) {
+  findOptional(value) {
+    return _queryTakeOptional(this.find(value));
+  }
+  /**
+   * Finds a single record with a given SQL.
+   * Returns `undefined` when not found.
+   *
+   * ```ts
+   * await db.user.find`
+   *   age = ${age} AND
+   *   name = ${name}
+   * `;
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  findBySqlOptional(...args) {
     return _queryTakeOptional(
-      this.find(...args)
+      this.findBySql(...args)
     );
   }
   /**
-   * The same as `where(conditions).take()`, it will filter records and add a `LIMIT 1`.
+   * The same as `where(conditions).take()`, takes the same arguments as {@link Where.where}, it will filter records and add a `LIMIT 1`.
    * Throws `NotFoundError` if not found.
    *
    * ```ts
@@ -10246,7 +10322,7 @@ class QueryMethods {
   /**
    * Adds an order by clause to the query.
    *
-   * Takes one or more arguments, each argument can be a column name, an object, or a raw expression.
+   * Takes one or more arguments, each argument can be a column name or an object.
    *
    * ```ts
    * db.table.order('id', 'name'); // ASC by default
@@ -10258,11 +10334,6 @@ class QueryMethods {
    *   name: 'ASC NULLS FIRST',
    *   age: 'DESC NULLS LAST',
    * });
-   *
-   * // order by raw SQL expression:
-   * db.table.order`raw sql`;
-   * // or
-   * db.table.order(db.table.sql`raw sql`);
    * ```
    *
    * `order` can refer to the values returned from `select` sub-queries (unlike `where` which cannot).
@@ -10281,22 +10352,35 @@ class QueryMethods {
    *   });
    * ```
    *
-   * @param args - column name(s), raw SQL, or an object with column names and sort directions.
+   * @param args - column name(s) or an object with column names and sort directions.
    */
   order(...args) {
-    if (Array.isArray(args[0])) {
-      return pushQueryValue(
-        this.clone(),
-        "order",
-        new RawSQL(args)
-      );
-    }
     return pushQueryArray(
       this.clone(),
       "order",
       args
     );
   }
+  /**
+   * Order by SQL expression
+   *
+   * Order by raw SQL expression.
+   *
+   * ```ts
+   * db.table.order`raw sql`;
+   * // or
+   * db.table.order(db.table.sql`raw sql`);
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  orderSql(...args) {
+    return pushQueryValue(
+      this.clone(),
+      "order",
+      sqlQueryArgsToExpression(args)
+    );
+  }
   /**
    * Adds a limit clause to the query.
    *
@@ -11144,6 +11228,8 @@ exports._queryUpdateRaw = _queryUpdateRaw;
 exports._queryWhere = _queryWhere;
 exports._queryWhereIn = _queryWhereIn;
 exports._queryWhereNot = _queryWhereNot;
+exports._queryWhereNotSql = _queryWhereNotSql;
+exports._queryWhereSql = _queryWhereSql;
 exports.addComputedColumns = addComputedColumns;
 exports.addParserForRawExpression = addParserForRawExpression;
 exports.addParserForSelectItem = addParserForSelectItem;
@@ -11197,6 +11283,7 @@ exports.pushQueryOn = pushQueryOn;
 exports.pushQueryOrOn = pushQueryOrOn;
 exports.pushQueryValue = pushQueryValue;
 exports.queryFrom = queryFrom;
+exports.queryFromSql = queryFromSql;
 exports.queryJson = queryJson;
 exports.queryMethodByReturnType = queryMethodByReturnType;
 exports.queryTypeWithLimitOne = queryTypeWithLimitOne;
@@ -11212,6 +11299,7 @@ exports.setParserForSelectedString = setParserForSelectedString;
 exports.setQueryObjectValue = setQueryObjectValue;
 exports.setQueryOperators = setQueryOperators;
 exports.simplifyColumnDefault = simplifyColumnDefault;
+exports.sqlQueryArgsToExpression = sqlQueryArgsToExpression;
 exports.templateLiteralToSQL = templateLiteralToSQL;
 exports.testTransaction = testTransaction;
 exports.throwIfNoWhere = throwIfNoWhere;