pqb 0.49.0 → 0.50.0

package/dist/index.mjs

@@ -1941,9 +1941,9 @@ const collectPrimaryKeys = (q) => {
       primaryKeys.push(key);
     }
   }
-  const pKeys = q.internal.primaryKeys;
-  if (pKeys) {
-    primaryKeys.push(...pKeys);
+  const pkey = q.internal.tableData.primaryKey;
+  if (pkey) {
+    primaryKeys.push(...pkey.columns);
   }
   return primaryKeys;
 };
@@ -2224,11 +2224,18 @@ const _join = (query, require, type, first, args) => {
   let joinSubQuery = false;
   first = preprocessJoinArg(query, first);
   if (typeof first === "object") {
+    let isInternalJoin;
+    if ("_internalJoin" in first) {
+      isInternalJoin = true;
+      first = first._internalJoin;
+    }
     if (require && isQueryNone(first)) {
       return _queryNone(query);
     }
     const q = first;
-    joinSubQuery = getIsJoinSubQuery(q);
+    if (!isInternalJoin) {
+      joinSubQuery = getIsJoinSubQuery(q);
+    }
     joinKey = q.q.as || q.table;
     if (joinKey) {
       shape = getShapeFromSelect(q, joinSubQuery && !!q.q.select);
@@ -3715,6 +3722,171 @@ const filterAllResult = (result, tempColumns, hasAfterHook) => {
   return result;
 };
 
+const _queryAs = (self, as) => {
+  const { q } = self;
+  q.as = as;
+  q.aliases = {
+    ...q.aliases,
+    [as]: q.aliases ? _queryResolveAlias(q.aliases, as) : as
+  };
+  return self;
+};
+const _queryResolveAlias = (aliases, as) => {
+  if (!aliases[as]) return as;
+  let suffix = 2;
+  let privateAs;
+  while (aliases[privateAs = as + suffix]) {
+    suffix++;
+  }
+  return privateAs;
+};
+class AsMethods {
+  /**
+   * Sets table alias:
+   *
+   * ```ts
+   * db.table.as('u').select('u.name');
+   *
+   * // Can be used in the join:
+   * db.table.join(Profile.as('p'), 'p.userId', 'user.id');
+   * ```
+   *
+   * @param as - alias for the table of this query
+   */
+  as(as) {
+    return _queryAs(_clone(this), as);
+  }
+}
+
+function queryFrom(self, arg) {
+  const data = self.q;
+  if (typeof arg === "string") {
+    data.as || (data.as = arg);
+    const w = data.withShapes?.[arg];
+    data.shape = w?.shape ?? emptyObject;
+    data.computeds = w?.computeds;
+  } else if (isExpression(arg)) {
+    data.as || (data.as = "t");
+  } else if (Array.isArray(arg)) {
+    const { shape } = data;
+    let clonedParsers = false;
+    for (const item of arg) {
+      if (typeof item === "string") {
+        const w = data.withShapes[item];
+        Object.assign(shape, w.shape);
+        if (w.computeds) data.computeds = { ...data.computeds, ...w.computeds };
+        for (const key in w.shape) {
+          addColumnParserToQuery(
+            self,
+            key,
+            w.shape[key]
+          );
+        }
+      } else if (!isExpression(item)) {
+        Object.assign(shape, getShapeFromSelect(item, true));
+        if (!clonedParsers) {
+          data.parsers = { ...data.parsers };
+          clonedParsers = true;
+        }
+        Object.assign(data.parsers, item.q.parsers);
+      }
+    }
+  } else {
+    const q = arg;
+    data.as || (data.as = q.q.as || q.table || "t");
+    data.shape = getShapeFromSelect(q, true);
+    data.parsers = q.q.parsers;
+    data.batchParsers = q.q.batchParsers;
+  }
+  data.from = arg;
+  data.selectAllColumns = data.scopes = void 0;
+  return self;
+}
+function queryFromSql(self, args) {
+  const data = self.q;
+  data.as || (data.as = "t");
+  data.from = sqlQueryArgsToExpression(args);
+  data.selectAllColumns = void 0;
+  return self;
+}
+class FromMethods {
+  /**
+   * Set the `FROM` value, by default the table name is used.
+   *
+   * `from` determines a set of available tables and columns withing the query,
+   * and thus it must not follow `select`, use `select` only after `from`.
+   *
+   * ```ts
+   * // accepts sub-query:
+   * db.table.from(db.otherTable.select('foo', 'bar'));
+   *
+   * // accepts alias of `WITH` expression:
+   * q.with('withTable', db.table.select('id', 'name'))
+   *   .from('withTable')
+   *   // `select` is after `from`
+   *   .select('id', 'name');
+   * ```
+   *
+   * `from` can accept multiple sources:
+   *
+   * ```ts
+   * db.table
+   *   // add a `WITH` statement called `withTable
+   *   .with('withTable', db.table.select('one'))
+   *   // select from `withTable` and from `otherTable`
+   *   .from('withTable', db.otherTable.select('two'))
+   *   // source names and column names are properly typed when selecting
+   *   .select('withTable.one', 'otherTable.two');
+   * ```
+   *
+   * @param arg - query or name of CTE table
+   */
+  from(arg) {
+    return queryFrom(_clone(this), arg);
+  }
+  /**
+   * Set the `FROM` value with custom SQL:
+   *
+   * ```ts
+   * const value = 123;
+   * db.table.fromSql`value = ${value}`;
+   * ```
+   *
+   * @param args - SQL expression
+   */
+  fromSql(...args) {
+    return queryFromSql(_clone(this), args);
+  }
+  /**
+   * Adds `ONLY` SQL keyword to the `FROM`.
+   * When selecting from a parent table that has a table inheritance,
+   * setting `only` will make it to select rows only from the parent table.
+   *
+   * ```ts
+   * db.table.only();
+   *
+   * // disabling `only` after being enabled
+   * db.table.only().only(false);
+   * ```
+   *
+   * @param only - can be disabled by passing `false` if was enabled previously.
+   */
+  only(only = true) {
+    const q = _clone(this);
+    q.q.only = only;
+    return q;
+  }
+}
+
+function queryWrap(self, query, as = "t") {
+  return _queryAs(queryFrom(query, self), as);
+}
+function cloneQueryBaseUnscoped(query) {
+  const q = query.baseQuery.clone();
+  q.q.or = q.q.and = q.q.scopes = void 0;
+  return q;
+}
+
 const addParserForRawExpression = (q, key, raw) => {
   if (raw.result.value) addColumnParserToQuery(q.q, key, raw.result.value);
 };
@@ -3962,7 +4134,7 @@ const processSelectArg = (q, as, arg, columnAs) => {
           query = value.json(false);
           value.q.coalesceValue = emptyArrSQL;
         } else if (returnType === "pluck") {
-          query = value.q.select ? value.wrap(value.baseQuery.clone()).jsonAgg(value.q.select[0]) : value.json(false);
+          query = value.q.select ? value.wrap(cloneQueryBaseUnscoped(value)).jsonAgg(value.q.select[0]) : value.json(false);
           value.q.coalesceValue = emptyArrSQL;
         } else {
           if (returnType === "value" || returnType === "valueOrThrow") {
@@ -4074,7 +4246,16 @@ const handleComputed = (q, computeds, column) => {
 };
 const getShapeFromSelect = (q, isSubQuery) => {
   const query = q.q;
-  const { select, shape } = query;
+  const { shape } = query;
+  let select;
+  if (query.selectedComputeds) {
+    select = query.select ? [...query.select] : [];
+    for (const key in query.selectedComputeds) {
+      select.push(...query.selectedComputeds[key].deps);
+    }
+  } else {
+    select = query.select;
+  }
   let result;
   if (!select) {
     if (isSubQuery) {
@@ -4133,18 +4314,33 @@ const addColumnToShapeFromSelect = (q, arg, shape, query, result, isSubQuery, ke
       result[key || column] = shape[column];
     } else {
       const it = query.joinedShapes?.[table]?.[column];
-      if (it) result[key || column] = maybeUnNameColumn(it, isSubQuery);
+      if (it)
+        result[key || column] = mapSubSelectColumn(
+          it,
+          isSubQuery
+        );
     }
   } else if (arg === "*") {
     for (const key2 in shape) {
-      result[key2] = maybeUnNameColumn(shape[key2], isSubQuery);
+      result[key2] = mapSubSelectColumn(
+        shape[key2],
+        isSubQuery
+      );
     }
   } else {
-    result[key || arg] = maybeUnNameColumn(shape[arg], isSubQuery);
+    result[key || arg] = mapSubSelectColumn(
+      shape[arg],
+      isSubQuery
+    );
   }
 };
-const maybeUnNameColumn = (column, isSubQuery) => {
-  return isSubQuery && column?.data.name ? setColumnData(column, "name", void 0) : column;
+const mapSubSelectColumn = (column, isSubQuery) => {
+  if (!isSubQuery || !column || !column.data.name && !column.data.explicitSelect) {
+    return column;
+  }
+  const cloned = Object.create(column);
+  cloned.data = { ...column.data, name: void 0, explicitSelect: void 0 };
+  return cloned;
 };
 function _querySelect(q, args) {
   var _a;
@@ -4268,171 +4464,6 @@ function _queryGetOptional(self, arg) {
   return _get(self, "value", arg);
 }
 
-const _queryAs = (self, as) => {
-  const { q } = self;
-  q.as = as;
-  q.aliases = {
-    ...q.aliases,
-    [as]: q.aliases ? _queryResolveAlias(q.aliases, as) : as
-  };
-  return self;
-};
-const _queryResolveAlias = (aliases, as) => {
-  if (!aliases[as]) return as;
-  let suffix = 2;
-  let privateAs;
-  while (aliases[privateAs = as + suffix]) {
-    suffix++;
-  }
-  return privateAs;
-};
-class AsMethods {
-  /**
-   * Sets table alias:
-   *
-   * ```ts
-   * db.table.as('u').select('u.name');
-   *
-   * // Can be used in the join:
-   * db.table.join(Profile.as('p'), 'p.userId', 'user.id');
-   * ```
-   *
-   * @param as - alias for the table of this query
-   */
-  as(as) {
-    return _queryAs(_clone(this), as);
-  }
-}
-
-function queryFrom(self, arg) {
-  const data = self.q;
-  if (typeof arg === "string") {
-    data.as || (data.as = arg);
-    const w = data.withShapes?.[arg];
-    data.shape = w?.shape ?? emptyObject;
-    data.computeds = w?.computeds;
-  } else if (isExpression(arg)) {
-    data.as || (data.as = "t");
-  } else if (Array.isArray(arg)) {
-    const { shape } = data;
-    let clonedParsers = false;
-    for (const item of arg) {
-      if (typeof item === "string") {
-        const w = data.withShapes[item];
-        Object.assign(shape, w.shape);
-        if (w.computeds) data.computeds = { ...data.computeds, ...w.computeds };
-        for (const key in w.shape) {
-          addColumnParserToQuery(
-            self,
-            key,
-            w.shape[key]
-          );
-        }
-      } else if (!isExpression(item)) {
-        Object.assign(shape, getShapeFromSelect(item, true));
-        if (!clonedParsers) {
-          data.parsers = { ...data.parsers };
-          clonedParsers = true;
-        }
-        Object.assign(data.parsers, item.q.parsers);
-      }
-    }
-  } else {
-    const q = arg;
-    data.as || (data.as = q.q.as || q.table || "t");
-    data.shape = getShapeFromSelect(q, true);
-    data.parsers = q.q.parsers;
-    data.batchParsers = q.q.batchParsers;
-  }
-  data.from = arg;
-  data.selectAllColumns = data.scopes = void 0;
-  return self;
-}
-function queryFromSql(self, args) {
-  const data = self.q;
-  data.as || (data.as = "t");
-  data.from = sqlQueryArgsToExpression(args);
-  data.selectAllColumns = void 0;
-  return self;
-}
-class FromMethods {
-  /**
-   * Set the `FROM` value, by default the table name is used.
-   *
-   * `from` determines a set of available tables and columns withing the query,
-   * and thus it must not follow `select`, use `select` only after `from`.
-   *
-   * ```ts
-   * // accepts sub-query:
-   * db.table.from(db.otherTable.select('foo', 'bar'));
-   *
-   * // accepts alias of `WITH` expression:
-   * q.with('withTable', db.table.select('id', 'name'))
-   *   .from('withTable')
-   *   // `select` is after `from`
-   *   .select('id', 'name');
-   * ```
-   *
-   * `from` can accept multiple sources:
-   *
-   * ```ts
-   * db.table
-   *   // add a `WITH` statement called `withTable
-   *   .with('withTable', db.table.select('one'))
-   *   // select from `withTable` and from `otherTable`
-   *   .from('withTable', db.otherTable.select('two'))
-   *   // source names and column names are properly typed when selecting
-   *   .select('withTable.one', 'otherTable.two');
-   * ```
-   *
-   * @param arg - query or name of CTE table
-   */
-  from(arg) {
-    return queryFrom(_clone(this), arg);
-  }
-  /**
-   * Set the `FROM` value with custom SQL:
-   *
-   * ```ts
-   * const value = 123;
-   * db.table.fromSql`value = ${value}`;
-   * ```
-   *
-   * @param args - SQL expression
-   */
-  fromSql(...args) {
-    return queryFromSql(_clone(this), args);
-  }
-  /**
-   * Adds `ONLY` SQL keyword to the `FROM`.
-   * When selecting from a parent table that has a table inheritance,
-   * setting `only` will make it to select rows only from the parent table.
-   *
-   * ```ts
-   * db.table.only();
-   *
-   * // disabling `only` after being enabled
-   * db.table.only().only(false);
-   * ```
-   *
-   * @param only - can be disabled by passing `false` if was enabled previously.
-   */
-  only(only = true) {
-    const q = _clone(this);
-    q.q.only = only;
-    return q;
-  }
-}
-
-function queryWrap(self, query, as = "t") {
-  return _queryAs(queryFrom(query, self), as);
-}
-function cloneQueryBaseUnscoped(query) {
-  const q = query.baseQuery.clone();
-  q.q.or = q.q.and = q.q.scopes = void 0;
-  return q;
-}
-
 class RowToJsonExpression extends Expression {
   constructor(from, one, coalesce) {
     super();
@@ -4470,10 +4501,7 @@ class RowToJsonExpression extends Expression {
 }
 function queryJson(self, coalesce) {
   const inner = self.clone();
-  const q = queryWrap(
-    inner,
-    cloneQueryBaseUnscoped(self)
-  );
+  const q = queryWrap(inner, cloneQueryBaseUnscoped(inner));
   _queryGetOptional(
     q,
     new RowToJsonExpression(
@@ -4912,18 +4940,23 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
       let quotedTable;
       let columnName;
       let col;
-      const index = select.indexOf(".");
-      if (index !== -1) {
-        const tableName = select.slice(0, index);
-        quotedTable = `"${tableName}"`;
-        columnName = select.slice(index + 1);
-        col = table.q.joinedShapes?.[tableName]?.[columnName];
-        sql = col?.data.computed ? col.data.computed.toSQL(ctx, `"${tableName}"`) : `"${tableName}"."${col?.data.name || columnName}"`;
+      if (typeof select === "string") {
+        const index = select.indexOf(".");
+        if (index !== -1) {
+          const tableName = select.slice(0, index);
+          quotedTable = `"${tableName}"`;
+          columnName = select.slice(index + 1);
+          col = table.q.joinedShapes?.[tableName]?.[columnName];
+          sql = col?.data.computed ? col.data.computed.toSQL(ctx, `"${tableName}"`) : `"${tableName}"."${col?.data.name || columnName}"`;
+        } else {
+          quotedTable = quotedAs;
+          columnName = select;
+          col = query.shape[select];
+          sql = simpleColumnToSQL(ctx, query, select, col, quotedAs);
+        }
       } else {
-        quotedTable = quotedAs;
-        columnName = select;
-        col = query.shape[select];
-        sql = simpleColumnToSQL(ctx, query, select, col, quotedAs);
+        columnName = column;
+        sql = select.sql;
       }
       let name = columnName;
       if (selected?.[columnName]) {
@@ -4935,7 +4968,7 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
         while (selected[name = `${column}${i}`]) i++;
         item.as = name;
         sql += ` "${name}"`;
-      } else if (col?.data.name) {
+      } else if (col?.data.name || typeof select === "object") {
         sql += ` "${columnName}"`;
       }
       if (jsonList) jsonList[name] = col;
@@ -5164,6 +5197,7 @@ const queryKeysOfNotSimpleQuery = [
   "for"
 ];
 
+let fromQuery;
 const pushFromAndAs = (ctx, table, data, quotedAs) => {
   let sql = "FROM ";
   const from = getFrom(ctx, table, data, quotedAs);
@@ -5200,8 +5234,15 @@ const pushFromAndAs = (ctx, table, data, quotedAs) => {
     sql += `, ${fn}(${lang}, ${querySql}) "${as}"`;
   }
   ctx.sql.push(sql);
+  if (fromQuery) {
+    const fq = fromQuery;
+    fromQuery = void 0;
+    return fq;
+  }
+  return;
 };
 const getFrom = (ctx, table, data, quotedAs) => {
+  fromQuery = void 0;
   if (data.from) {
     const { from } = data;
     if (Array.isArray(from)) {
@@ -5228,6 +5269,7 @@ const fromToSql = (ctx, data, from, quotedAs) => {
       } else {
         sql = quoteSchemaAndTable(from.q.schema, from.table);
       }
+      fromQuery = from;
     }
   } else {
     sql = quoteSchemaAndTable(data.schema, from);
@@ -5498,6 +5540,7 @@ const toSQL = (table, options) => {
   if (query.with) {
     pushWithSql(ctx, query.with);
   }
+  let fromQuery;
   if (query.type && query.type !== "upsert") {
     const tableName = table.table ?? query.as;
     if (!tableName) throw new Error(`Table is missing for ${query.type}`);
@@ -5547,9 +5590,7 @@ const toSQL = (table, options) => {
     }
     const aliases = query.group ? [] : void 0;
     pushSelectSql(ctx, table, query, quotedAs, aliases);
-    if (table.table || query.from) {
-      pushFromAndAs(ctx, table, query, quotedAs);
-    }
+    fromQuery = (table.table || query.from) && pushFromAndAs(ctx, table, query, quotedAs) || void 0;
     if (query.join) {
       pushJoinSql(
         ctx,
@@ -5588,9 +5629,19 @@ const toSQL = (table, options) => {
   if (query.order) {
     pushOrderBySql(ctx, query, quotedAs, query.order);
   }
-  pushLimitSQL(sql, values, query);
-  if (query.offset) {
-    sql.push(`OFFSET ${addValue(values, query.offset)}`);
+  if (query.useFromLimitOffset) {
+    const q = fromQuery?.q;
+    if (q.limit) {
+      sql.push(`LIMIT ${addValue(values, q.limit)}`);
+    }
+    if (q.offset) {
+      sql.push(`OFFSET ${addValue(values, q.offset)}`);
+    }
+  } else {
+    pushLimitSQL(sql, values, query);
+    if (query.offset && !query.returnsOne) {
+      sql.push(`OFFSET ${addValue(values, query.offset)}`);
+    }
   }
   if (query.for) {
     sql.push("FOR", query.for.type);
@@ -6995,7 +7046,9 @@ const _chain = (fromQuery, toQuery, rel) => {
     if (
       // `select({ q => q.rel })`: on the first relation it doesn't matter if the parent has chainMultiple
       self.q.subQuery > 1 && self.q.chainMultiple
-    ) ; else if (!rel.query.q.returnsOne) {
+    ) {
+      q.returnType = q.returnsOne = q.limit = void 0;
+    } else if (!rel.query.q.returnsOne) {
       q.chainMultiple = true;
     }
   } else {
@@ -10240,7 +10293,7 @@ class JsonMethods {
    * @param coalesce
    */
   json(coalesce) {
-    return queryJson(_clone(this), coalesce);
+    return queryJson(this, coalesce);
   }
 }