pqb 0.30.5 → 0.30.7

package/dist/index.js

@@ -2379,25 +2379,14 @@ const subJoinToSql = (ctx, jq, innerAs, outerAs, cloned) => {
   }).text}) ${outerAs || innerAs}`;
 };
 const processArgs = (args, ctx, query, joinAs, joinShape, quotedAs) => {
-  if (args.length === 1) {
-    return getObjectOrRawConditions(
-      ctx,
-      query,
-      args[0],
-      quotedAs,
-      joinAs,
-      joinShape
-    );
-  } else {
-    return getConditionsFor3Or4LengthItem(
-      ctx,
-      query,
-      joinAs,
-      quotedAs,
-      args,
-      joinShape
-    );
-  }
+  return args.length === 1 ? getObjectOrRawConditions(ctx, query, args[0], quotedAs, joinAs, joinShape) : getConditionsFor3Or4LengthItem(
+    ctx,
+    query,
+    joinAs,
+    quotedAs,
+    args,
+    joinShape
+  );
 };
 const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, joinShape) => {
   const [leftColumn, opOrRightColumn, maybeRightColumn] = args;
@@ -2550,7 +2539,9 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
       );
       return { w: first, r, s: joinSubQuery || getIsJoinSubQuery(r) };
     }
-  } else if (typeof args[0] === "function") {
+  }
+  const args0 = args.length ? args[0] : orchidCore.returnArg;
+  if (typeof args0 === "function") {
     const q = first;
     if (q.joinQueryAfterCallback) {
       let base = q.baseQuery;
@@ -2568,7 +2559,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
     const joinedShapes = __spreadProps$4(__spreadValues$c({}, joinTo.q.joinedShapes), {
       [joinTo.q.as || joinTo.table]: joinTo.shape
     });
-    const r = args[0](
+    const r = args0(
       makeJoinQueryBuilder(
         q,
         q.q.joinedShapes ? __spreadValues$c(__spreadValues$c({}, q.q.joinedShapes), joinedShapes) : joinedShapes,
@@ -2593,6 +2584,32 @@ const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo) => {
   return q;
 };
 
+const noneMethods = {
+  // `then` resolves or rejects based on return type of the query.
+  // It is `async` so it returns a chainable Promise.
+  async then(resolve, reject) {
+    const type = this.q.returnType;
+    if (!type || type === "all" || type === "rows" || type === "pluck")
+      resolve == null ? void 0 : resolve([]);
+    else if (type === "one" || type === "value" || type === "void")
+      resolve == null ? void 0 : resolve();
+    else if (type === "rowCount")
+      resolve == null ? void 0 : resolve(0);
+    else
+      reject == null ? void 0 : reject(new NotFoundError(this));
+  },
+  // `catch` returns a Promise, so it is chainable with then/catch.
+  catch: () => new Promise(orchidCore.noop)
+};
+const _queryNone = (q) => {
+  if (isQueryNone(q))
+    return q;
+  q = extendQuery(q, noneMethods);
+  pushQueryValue(q, "and", new RawSQL("false"));
+  return q;
+};
+const isQueryNone = (q) => q.then === noneMethods.then;
+
 var __defProp$b = Object.defineProperty;
 var __defProps$3 = Object.defineProperties;
 var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
@@ -2612,36 +2629,39 @@ var __spreadValues$b = (a, b) => {
   return a;
 };
 var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
-const _join = (q, require2, type, first, args) => {
+const _join = (query, require2, type, first, args) => {
   var _a, _b;
   let joinKey;
   let shape;
   let parsers;
   let joinSubQuery = false;
   if (typeof first === "function") {
-    first = first(q.relations);
+    first = first(query.relations);
     first.joinQueryAfterCallback = first.joinQuery;
   }
   if (typeof first === "object") {
-    const q2 = first;
-    joinSubQuery = getIsJoinSubQuery(q2);
-    joinKey = q2.q.as || q2.table;
+    if (require2 && isQueryNone(first)) {
+      return _queryNone(query);
+    }
+    const q = first;
+    joinSubQuery = getIsJoinSubQuery(q);
+    joinKey = q.q.as || q.table;
     if (joinKey) {
-      shape = getShapeFromSelect(q2, joinSubQuery);
-      parsers = q2.q.parsers;
+      shape = getShapeFromSelect(q, joinSubQuery);
+      parsers = q.q.parsers;
       if (joinSubQuery) {
-        first = q2.clone();
+        first = q.clone();
         first.shape = shape;
       }
     }
   } else {
     joinKey = first;
-    const relation = q.relations[joinKey];
+    const relation = query.relations[joinKey];
     if (relation) {
       shape = getShapeFromSelect(relation.relationConfig.query);
       parsers = relation.relationConfig.query.q.parsers;
     } else {
-      shape = (_a = q.q.withShapes) == null ? void 0 : _a[joinKey];
+      shape = (_a = query.q.withShapes) == null ? void 0 : _a[joinKey];
       if (shape) {
         if (!require2)
           shape = __spreadValues$b({}, shape);
@@ -2657,20 +2677,20 @@ const _join = (q, require2, type, first, args) => {
   }
   if (joinKey) {
     setQueryObjectValue(
-      q,
+      query,
       "joinedShapes",
       joinKey,
       shape
     );
     setQueryObjectValue(
-      q,
+      query,
       "joinedParsers",
       joinKey,
       parsers
     );
   }
   const joinArgs = processJoinArgs(
-    q,
+    query,
     first,
     args,
     joinSubQuery
@@ -2680,20 +2700,22 @@ const _join = (q, require2, type, first, args) => {
     if (j.q.select || !j.internal.columnsForSelectAll) {
       const shape2 = getShapeFromSelect(j, true);
       setQueryObjectValue(
-        q,
+        query,
         "joinedShapes",
         joinKey,
         shape2
       );
       setQueryObjectValue(
-        q,
+        query,
         "joinedParsers",
         joinKey,
         j.q.parsers
       );
     }
+  } else if (require2 && "r" in joinArgs && isQueryNone(joinArgs.r)) {
+    return _queryNone(query);
   }
-  return pushQueryValue(q, "join", {
+  return pushQueryValue(query, "join", {
     type,
     args: joinArgs
   });
@@ -3328,6 +3350,26 @@ const addParserForSelectItem = (q, as, key, arg) => {
           );
         });
       }
+      if (query.returnType === "valueOrThrow" || query.returnType === "oneOrThrow") {
+        pushQueryValue(
+          q,
+          "transform",
+          (data) => {
+            if (Array.isArray(data)) {
+              for (const item of data) {
+                if (item[key] === void 0) {
+                  throw new NotFoundError(q);
+                }
+              }
+            } else {
+              if (data[key] === void 0) {
+                throw new NotFoundError(q);
+              }
+            }
+            return data;
+          }
+        );
+      }
     }
     return arg;
   }
@@ -3344,7 +3386,11 @@ const processSelectArg = (q, as, arg, columnAs) => {
     let value = arg[key];
     if (typeof value === "function") {
       value = resolveSubQueryCallback(q, value);
-      if (!orchidCore.isExpression(value) && value.joinQuery) {
+      if (isQueryNone(value)) {
+        if (value.q.innerJoinLateral) {
+          return;
+        }
+      } else if (!orchidCore.isExpression(value) && value.joinQuery) {
         value = value.joinQuery(value, q);
         let query;
         const returnType = value.q.returnType;
@@ -3501,11 +3547,18 @@ const maybeUnNameColumn = (column, isSubQuery) => {
   return isSubQuery && (column == null ? void 0 : column.data.name) ? orchidCore.setColumnData(column, "name", void 0) : column;
 };
 function _querySelect(q, args) {
-  if (!args.length) {
+  const len = args.length;
+  if (!len) {
     return q;
   }
   const as = q.q.as || q.table;
-  const selectArgs = args.map((item) => processSelectArg(q, as, item));
+  const selectArgs = new Array(len);
+  for (let i = 0; i < len; i++) {
+    selectArgs[i] = processSelectArg(q, as, args[i]);
+    if (!selectArgs[i]) {
+      return _queryNone(q);
+    }
+  }
   return pushQueryArray(q, "select", selectArgs);
 }
 class Select {
@@ -3855,7 +3908,37 @@ const selectAllSql = (table, query, quotedAs) => {
   return ((_a = query.join) == null ? void 0 : _a.length) ? ((_b = table.internal.columnsForSelectAll) == null ? void 0 : _b.map((item) => `${quotedAs}.${item}`).join(", ")) || `${quotedAs}.*` : ((_c = table.internal.columnsForSelectAll) == null ? void 0 : _c.join(", ")) || "*";
 };
 const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
+  var _a;
   const { returnType = "all" } = query.q;
+  if (isQueryNone(query)) {
+    let sql;
+    switch (returnType) {
+      case "one":
+      case "oneOrThrow":
+      case "void":
+        return;
+      case "value":
+      case "valueOrThrow":
+        if (((_a = query.q.expr) == null ? void 0 : _a.result.value) instanceof IntegerBaseColumn) {
+          sql = "0";
+        } else {
+          return;
+        }
+        break;
+      case "all":
+      case "pluck":
+      case "rows":
+        sql = `'[]'::json`;
+        break;
+      case "rowCount":
+        sql = "0";
+        break;
+      default:
+        throw new UnhandledTypeError(query, returnType);
+    }
+    list.push(`${sql} "${as}"`);
+    return;
+  }
   if (query.q.joinedForSelect) {
     let sql;
     switch (returnType) {
@@ -6274,7 +6357,7 @@ class Create {
    *
    * await db.table.create({
    *   // raw SQL
-   *   column1: sql`'John' || ' ' || 'Doe'`,
+   *   column1: (q) => q.sql`'John' || ' ' || 'Doe'`,
    *
    *   // query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -6509,6 +6592,7 @@ class Create {
    * db.table.create(data).onConflictDoNothing();
    *
    * // single column:
+   * // (this requires a composite primary key or unique index, see below)
    * db.table.create(data).onConfict('email').merge();
    *
    * // array of columns:
@@ -6524,6 +6608,34 @@ class Create {
    *   .merge();
    * ```
    *
+   * :::info
+   * A primary key or a unique index for a **single** column can be fined on a column:
+   *
+   * ```ts
+   * export class MyTable extends BaseTable {
+   *   columns = this.setColumns((t) => ({
+   *     pkey: t.uuid().primaryKey(),
+   *     unique: t.string().unique(),
+   *   }));
+   * }
+   * ```
+   *
+   * But for composite primary keys or indexes (having multiple columns), define it in a separate function:
+   *
+   * ```ts
+   * export class MyTable extends BaseTable {
+   *   columns = this.setColumns(
+   *     (t) => ({
+   *       one: t.integer(),
+   *       two: t.string(),
+   *       three: t.boolean(),
+   *     }),
+   *     (t) => [t.primaryKey(['one', 'two']), t.unique(['two', 'three'])],
+   *   );
+   * }
+   * ```
+   * :::
+   *
    * You can use the `sql` function exported from your `BaseTable` file in onConflict.
    * It can be useful to specify a condition when you have a partial index:
    *
@@ -8431,6 +8543,9 @@ const _queryOrNot = (q, args) => {
 const _queryWhereIn = (q, and, arg, values, not) => {
   let item;
   if (values) {
+    if ("length" in values && !values.length) {
+      return _queryNone(q);
+    }
     if (Array.isArray(arg)) {
       item = {
         IN: {
@@ -8444,7 +8559,11 @@ const _queryWhereIn = (q, and, arg, values, not) => {
   } else {
     item = {};
     for (const key in arg) {
-      item[key] = { in: arg[key] };
+      const values2 = arg[key];
+      if ("length" in values2 && !values2.length) {
+        return _queryNone(q);
+      }
+      item[key] = { in: values2 };
     }
   }
   if (not)
@@ -8993,6 +9112,15 @@ class Where {
    * ```ts
    * db.table.whereIn(['id', 'name'], sql`((1, 'one'), (2, 'two'))`);
    * ```
+   *
+   * When empty set of values is given, `whereIn` will resolve into a {@link QueryMethods.none} query that has a special behavior.
+   *
+   * ```ts
+   * // following queries resolves into `none`:
+   * db.table.where('id', [])
+   * db.table.where(['id', 'name'], [])
+   * db.table.where({ id: [] })
+   * ```
    */
   whereIn(...args) {
     return _queryWhereIn(
@@ -9305,7 +9433,7 @@ class Update {
    *   column1: 123,
    *
    *   // use raw SQL to update the column
-   *   column2: sql`2 + 2`,
+   *   column2: (q) => q.sql`2 + 2`,
    *
    *   // use query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -9419,7 +9547,7 @@ class Update {
     );
   }
   /**
-   * `updateRaw` is for updating records with raw expression.
+   * `updateSql` is for updating records with raw expression.
    *
    * The behavior is the same as a regular `update` method has:
    * `find` or `where` must precede calling this method,
@@ -9430,14 +9558,14 @@ class Update {
    * const value = 'new name';
    *
    * // update with SQL template string
-   * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
+   * const updatedCount = await db.table.find(1).updateSql`name = ${value}`;
    *
    * // or update with `sql` function:
-   * await db.table.find(1).updateRaw(sql`name = ${value}`);
+   * await db.table.find(1).updateSql(sql`name = ${value}`);
    * ```
    * @param args - raw SQL via a template string or by using a `sql` method
    */
-  updateRaw(...args) {
+  updateSql(...args) {
     return _queryUpdateRaw(
       this.clone(),
       sqlQueryArgsToExpression(args)
@@ -10197,24 +10325,6 @@ class TransformMethods {
   }
 }
 
-const noneMethods = {
-  // `then` resolves or rejects based on return type of the query.
-  // It is `async` so it returns a chainable Promise.
-  async then(resolve, reject) {
-    const type = this.q.returnType;
-    if (!type || type === "all" || type === "rows" || type === "pluck")
-      resolve == null ? void 0 : resolve([]);
-    else if (type === "one" || type === "value" || type === "void")
-      resolve == null ? void 0 : resolve();
-    else if (type === "rowCount")
-      resolve == null ? void 0 : resolve(0);
-    else
-      reject == null ? void 0 : reject(new NotFoundError(this));
-  },
-  // `catch` returns a Promise, so it is chainable with then/catch.
-  catch: () => new Promise(orchidCore.noop)
-};
-
 class ScopeMethods {
   /**
    * See {@link ScopeMethods}
@@ -10998,9 +11108,55 @@ class QueryMethods {
    * await db.table.all().update(data); // -> 0
    * await db.table.all().delete(); // -> 0
    * ```
+   *
+   * When it's being used in sub-selects, it will return empty arrays, `undefined`'s, or `0` for count,
+   * or it will throw if the sub-query require a result:
+   *
+   * ```ts
+   * await db.user.select({
+   *   // returns empty array
+   *   pets: (q) => q.pets.none(),
+   *   // returns `undefined`
+   *   firstPet: (q) => q.pets.none().takeOptional(),
+   *   // throws NotFound error
+   *   requriedFirstPet: (q) => q.pets.none().take(),
+   *   // returns `undefined`
+   *   firstPetName: (q) => q.pets.none().getOptional('name'),
+   *   // throws NotFound error
+   *   requiredFirstPetName: (q) => q.pets.none().get('name'),
+   *   // returns empty array
+   *   petsNames: (q) => q.pets.none().pluck('name'),
+   *   // returns 0
+   *   petsCount: (q) => q.pets.none().count(),
+   * });
+   * ```
+   *
+   * When the `none` query is being used for joins that require match, the host query will return an empty result:
+   *
+   * ```ts
+   * // all the following queries will resolve into empty arrays
+   *
+   * await db.user.select({
+   *   pets: (q) => q.pets.join().none(),
+   * });
+   *
+   * await db.user.join((q) => q.pets.none());
+   *
+   * await db.user.join('pets', (q) => q.none());
+   * ```
+   *
+   * When it's being used in `leftJoin` or `fullJoin`, it implicitly adds `ON false` into the join's SQL.
+   *
+   * ```ts
+   * // this query can return user records
+   * await db.user.leftJoin('pets', (q) => q.none());
+   *
+   * // this query won't return user records, because of the added where condition
+   * await db.user.leftJoin('pets', (q) => q.none()).where({ 'pets.name': 'Kitty' });
+   * ```
    */
   none() {
-    return this.then === noneMethods.then ? this : extendQuery(this, noneMethods);
+    return _queryNone(this);
   }
   /**
    * `modify` allows modifying the query with your function: