pqb 0.42.8 → 0.43.0

package/dist/index.d.ts

@@ -5465,10 +5465,7 @@ type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = {
     }) & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
 } & QueryMetaHasSelect;
 type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? {
-    [K in keyof T]: K extends 'meta' ? T['meta'] & {
-        hasSelect: true;
-        selectable: SelectAsSelectable<Obj>;
-    } : K extends 'result' ? {
+    [K in keyof T]: K extends 'meta' ? T['meta'] & SelectAsMeta<Obj> : K extends 'result' ? {
         [K in T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
     } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
         [K in T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
@@ -5477,34 +5474,37 @@ type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckRetur
     [K in keyof Obj]: Obj[K] extends (...args: any[]) => any ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never;
 }[keyof Obj] & string}`;
 type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = {
-    [K in keyof T]: K extends 'meta' ? T['meta'] & {
-        hasSelect: true;
-        selectable: SelectAsSelectable<Obj>;
-    } : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
+    [K in keyof T]: K extends 'meta' ? T['meta'] & SelectAsMeta<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
     {
         [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
     } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, {
         [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['meta']['defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['meta']['selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['meta']['selectable'][K]['column'];
     } & (T['meta']['hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K];
 };
-type SelectAsSelectable<Arg> = {
-    [K in keyof Arg]: Arg[K] extends (q: never) => {
-        returnType: 'value' | 'valueOrThrow';
-        result: QueryColumns;
-    } ? {
-        [P in K]: {
-            as: K;
-            column: ReturnType<Arg[K]>['result']['value'];
-        };
-    } : Arg[K] extends (q: never) => {
-        result: QueryColumns;
-    } ? {
-        [C in keyof ReturnType<Arg[K]>['result'] & string as `${K & string}.${C}`]: {
-            as: C;
-            column: ReturnType<Arg[K]>['result'][C];
-        };
-    } : never;
-}[keyof Arg];
+type SelectAsMeta<Arg> = {
+    hasSelect: true;
+    selectable: {
+        [K in keyof Arg]: Arg[K] extends (q: never) => {
+            result: QueryColumns;
+            returnType: QueryReturnType;
+        } ? ReturnType<Arg[K]>['returnType'] extends 'value' | 'valueOrThrow' ? {
+            [P in K]: {
+                as: K;
+                column: ReturnType<Arg[K]>['result']['value'];
+            };
+        } : {
+            [C in keyof ReturnType<Arg[K]>['result'] & string as `${K & string}.${C}`]: {
+                as: C;
+                column: ReturnType<Arg[K]>['result'][C];
+            };
+        } : Arg[K] extends Expression ? {
+            [P in K]: {
+                as: K;
+                column: Arg[K]['result']['value'];
+            };
+        } : EmptyObject;
+    }[keyof Arg];
+};
 type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['meta']['selectable'] ? T['meta']['selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends (q: never) => IsQuery ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends (q: never) => Expression ? ReturnType<Arg>['result']['value'] : Arg extends (q: never) => IsQuery | Expression ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
 type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShapeToObjectArray<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShapeToPluck<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShapeToNullableObject<Arg['result']> : ColumnsShapeToObject<Arg['result']>;
 declare const addParserForRawExpression: (q: PickQueryQ, key: string | getValueKey, raw: Expression) => void;
@@ -7313,9 +7313,15 @@ declare class QueryMethods<ColumnTypes> {
      *   .group('month');
      * ```
      *
+     * Column aliases in `select` take precedence over table columns,
+     * so if in the query above `db.product` had a column `month`,
+     * the query would work in the exact same way, group by would reference the selected `month` expression.
+     *
      * @param columns - column names or a raw SQL
      */
-    group<T extends PickQueryResult>(this: T, ...columns: GroupArgs<T>): T;
+    group<T extends PickQueryMetaResult>(this: T, ...columns: T['meta']['hasSelect'] extends true ? GroupArgs<T> : {
+        error: 'select is required for group';
+    }[]): T;
     /**
      * Add a window with `window` and use it later by its name for aggregate or window functions:
      *

package/dist/index.js

@@ -5650,11 +5650,18 @@ function queryJson(self, coalesce) {
   return q;
 }
 
-const pushSelectSql = (ctx, table, query, quotedAs) => {
-  const sql = selectToSql(ctx, table, query, quotedAs);
+const pushSelectSql = (ctx, table, query, quotedAs, aliases) => {
+  const sql = selectToSql(
+    ctx,
+    table,
+    query,
+    quotedAs,
+    query.hookSelect,
+    aliases
+  );
   if (sql) ctx.sql.push(sql);
 };
-const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect) => {
+const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect, aliases) => {
   let selected;
   const list = [];
   if (query.select) {
@@ -5696,6 +5703,7 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect)
           }
         }
         list.push(sql);
+        aliases?.push("");
       } else if (item) {
         if ("selectAs" in item) {
           const obj = item.selectAs;
@@ -5705,8 +5713,9 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect)
             if (typeof value === "object") {
               if (orchidCore.isExpression(value)) {
                 list.push(`${value.toSQL(ctx, quotedAs)} "${as}"`);
+                aliases?.push(as);
               } else {
-                pushSubQuerySql(ctx, value, as, list, quotedAs);
+                pushSubQuerySql(ctx, value, as, list, quotedAs, aliases);
               }
             } else if (value) {
               list.push(
@@ -5719,10 +5728,12 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect)
                   true
                 )
               );
+              aliases?.push(as);
             }
           }
         } else {
           list.push(selectedObjectToSQL(ctx, quotedAs, item));
+          aliases?.push("");
         }
       }
     }
@@ -5773,7 +5784,7 @@ function selectedObjectToSQL(ctx, quotedAs, item) {
 const selectAllSql = (query, quotedAs) => {
   return query.join?.length ? query.selectAllColumns?.map((item) => `${quotedAs}.${item}`).join(", ") || `${quotedAs}.*` : query.selectAllColumns?.join(", ") || "*";
 };
-const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
+const pushSubQuerySql = (ctx, query, as, list, quotedAs, aliases) => {
   const { returnType = "all" } = query.q;
   if (isQueryNone(query)) {
     let sql;
@@ -5799,6 +5810,7 @@ const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
         throw new UnhandledTypeError(query, returnType);
     }
     list.push(`${sql} "${as}"`);
+    aliases?.push(as);
     return;
   }
   if (query.q.joinedForSelect) {
@@ -5823,7 +5835,10 @@ const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
       default:
         throw new UnhandledTypeError(query, returnType);
     }
-    if (sql) list.push(`${coalesce(ctx, query, sql, quotedAs)} "${as}"`);
+    if (sql) {
+      list.push(`${coalesce(ctx, query, sql, quotedAs)} "${as}"`);
+      aliases?.push(as);
+    }
     return;
   }
   switch (returnType) {
@@ -6593,7 +6608,8 @@ const makeSQL = (table, options) => {
     if (query.distinct) {
       pushDistinctSql(ctx, table, query.distinct, quotedAs);
     }
-    pushSelectSql(ctx, table, query, quotedAs);
+    const aliases = query.group ? [] : void 0;
+    pushSelectSql(ctx, table, query, quotedAs, aliases);
     if (table.table || query.from) {
       pushFromAndAs(ctx, table, query, quotedAs);
     }
@@ -6609,9 +6625,14 @@ const makeSQL = (table, options) => {
       pushWhereStatementSql(ctx, table, query, quotedAs);
     }
     if (query.group) {
-      const group = query.group.map(
-        (item) => orchidCore.isExpression(item) ? item.toSQL(ctx, quotedAs) : maybeSelectedColumnToSql(ctx, table.q, item, quotedAs)
-      );
+      const group = query.group.map((item) => {
+        if (orchidCore.isExpression(item)) {
+          return item.toSQL(ctx, quotedAs);
+        } else {
+          const i = aliases.indexOf(item);
+          return i !== -1 ? i + 1 : columnToSql(ctx, table.q, table.shape, item, quotedAs);
+        }
+      });
       sql.push(`GROUP BY ${group.join(", ")}`);
     }
     if (query.having) pushHavingSql(ctx, query, quotedAs);
@@ -11722,6 +11743,10 @@ class QueryMethods {
    *   .group('month');
    * ```
    *
+   * Column aliases in `select` take precedence over table columns,
+   * so if in the query above `db.product` had a column `month`,
+   * the query would work in the exact same way, group by would reference the selected `month` expression.
+   *
    * @param columns - column names or a raw SQL
    */
   group(...columns) {