pqb 0.45.4 → 0.46.0

package/dist/index.mjs

@@ -1104,8 +1104,35 @@ const text = {
 };
 const encodeJsonPath = (ctx, path) => addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
 const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${addValue(ctx.values, path)}${options?.vars ? `, ${addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
+const quoteJsonValue = (arg, ctx, quotedAs, IN) => {
+  if (arg && typeof arg === "object") {
+    if (IN && Array.isArray(arg)) {
+      return `(${arg.map((value) => addValue(ctx.values, JSON.stringify(value)) + "::jsonb").join(", ")})`;
+    }
+    if (isExpression(arg)) {
+      return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
+    }
+    if ("toSQL" in arg) {
+      return `to_jsonb((${getSqlText(
+        arg.toSQL({ values: ctx.values })
+      )}))`;
+    }
+  }
+  return addValue(ctx.values, JSON.stringify(arg)) + "::jsonb";
+};
 const json = {
-  ...base,
+  equals: make(
+    (key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NULL` : `${key} = ${quoteJsonValue(value, ctx, quotedAs)}`
+  ),
+  not: make(
+    (key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NOT NULL` : `${key} != ${quoteJsonValue(value, ctx, quotedAs)}`
+  ),
+  in: make(
+    (key, value, ctx, quotedAs) => `${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`
+  ),
+  notIn: make(
+    (key, value, ctx, quotedAs) => `NOT ${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`
+  ),
   jsonPathQueryFirst: Object.assign(
     function(path, options) {
       const { q, columnTypes } = this;
@@ -1919,13 +1946,39 @@ const _queryAll = (q) => {
   q.q.all = true;
   return q;
 };
-const _queryTake = (q) => {
-  q.q.returnType = "oneOrThrow";
-  return q;
+const _queryTake = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "valueOrThrow":
+    case "pluck":
+    case "void":
+      break;
+    case "value": {
+      q.returnType = "valueOrThrow";
+      break;
+    }
+    default: {
+      q.returnType = "oneOrThrow";
+    }
+  }
+  return query;
 };
-const _queryTakeOptional = (q) => {
-  q.q.returnType = "one";
-  return q;
+const _queryTakeOptional = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "value":
+    case "pluck":
+    case "void":
+      break;
+    case "valueOrThrow": {
+      q.returnType = "value";
+      break;
+    }
+    default: {
+      q.returnType = "one";
+    }
+  }
+  return query;
 };
 const _queryExec = (q) => {
   q.q.returnType = "void";
@@ -2109,16 +2162,27 @@ const pushDistinctSql = (ctx, table, distinct, quotedAs) => {
   }
 };
 
+const noneResult = (q, queryData, type) => {
+  if (!type || type === "all" || type === "rows" || type === "pluck") {
+    return [];
+  } else if (type === "one" || type === "value" || type === "void") {
+    return queryData.notFoundDefault;
+  } else if (type === "valueOrThrow" && queryData.returning) {
+    return 0;
+  } else {
+    throw new NotFoundError(q);
+  }
+};
 const noneMethods = {
-  // `then` resolves or rejects based on return type of the query.
+  // `then` resolves or rejects based on a 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?.([]);
-    else if (type === "one" || type === "value" || type === "void") resolve?.();
-    else if (type === "valueOrThrow" && this.q.returning) resolve?.(0);
-    else reject?.(new NotFoundError(this));
+    try {
+      const result = noneResult(this, this.q, this.q.returnType);
+      resolve?.(result);
+    } catch (err) {
+      reject?.(err);
+    }
   },
   // `catch` returns a Promise, so it is chainable with then/catch.
   catch: () => new Promise(noop)
@@ -2127,6 +2191,11 @@ const _queryNone = (q) => {
   if (isQueryNone(q)) return q;
   q = extendQuery(q, noneMethods);
   pushQueryValueImmutable(q, "and", new RawSQL("false"));
+  pushQueryValueImmutable(
+    q,
+    "transform",
+    (_, queryData) => noneResult(q, queryData, queryData.returnType)
+  );
   return q;
 };
 const isQueryNone = (q) => q.then === noneMethods.then;
@@ -2184,7 +2253,9 @@ const _join = (query, require, type, first, args) => {
     args,
     joinSubQuery
   );
-  if (joinKey && "s" in joinArgs && joinArgs.s) {
+  if (require && "r" in joinArgs && isQueryNone(joinArgs.r)) {
+    return _queryNone(query);
+  } else if (joinKey && "s" in joinArgs && joinArgs.s) {
     const j = "j" in joinArgs ? joinArgs.r ?? joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
     const jq = j.q;
     if (jq.select || !jq.selectAllColumns) {
@@ -2211,8 +2282,6 @@ const _join = (query, require, type, first, args) => {
         computeds
       );
     }
-  } else if (require && "r" in joinArgs && isQueryNone(joinArgs.r)) {
-    return _queryNone(query);
   } else {
     addAllShapesAndParsers(
       query,
@@ -2912,12 +2981,13 @@ const runAfterCommit = async (afterCommit, result) => {
   }
 };
 
-const applyBatchTransforms = (query, batches) => {
-  if (query.transform) {
+const applyBatchTransforms = (q, batches) => {
+  if (q.transform) {
     for (const item of batches) {
       item.parent[item.key] = applyTransforms(
-        query.returnType,
-        query.transform,
+        q,
+        q.returnType,
+        q.transform,
         item.data
       );
     }
@@ -3360,7 +3430,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       );
     }
     if (query.transform) {
-      result = applyTransforms(returnType, query.transform, result);
+      result = applyTransforms(query, returnType, query.transform, result);
     }
     return resolve?.(result);
   } catch (err) {
@@ -5917,7 +5987,8 @@ const skipQueryKeysForSubQuery = {
   returnsOne: true,
   aliases: true,
   sqlCache: true,
-  defaults: true
+  defaults: true,
+  transform: true
 };
 const getIsJoinSubQuery = (query) => {
   const {
@@ -11689,25 +11760,31 @@ class QueryMethods {
     return _queryAll(_clone(this));
   }
   /**
-   * Takes a single record, adds `LIMIT 1`.
-   * Throws when not found.
+   * Use `take` to "take" a single record. It adds `LIMIT 1`, throws a `NotFoundError` when not found.
    *
    * ```ts
-   * const result: TableType = await db.table.where({ key: 'value' }).take();
+   * const taken: TableType = await db.table.where({ key: 'value' }).take();
    * ```
+   *
+   * Makes no effect if the query previously has `get`, `pluck`, `exec`.
+   *
+   * Changes `getOptional` to `get`.
    */
   take() {
     return _queryTake(_clone(this));
   }
   /**
-   * Takes a single record, adds `LIMIT 1`.
-   * Returns `undefined` when not found.
+   * Use `takeOptional` to "take" a single record. It adds `LIMIT 1`, returns `undefined` when not found.
    *
    * ```ts
-   * const result: TableType | undefined = await db.table
+   * const takenOptional: TableType | undefined = await db.table
    *   .where({ key: 'value' })
    *   .takeOptional();
    * ```
+   *
+   * Makes no effect if the query previously has `getOptional`, `pluck`, `exec`.
+   *
+   * Changes `get` to `getOptional`.
    */
   takeOptional() {
     return _queryTakeOptional(_clone(this));