pqb 0.42.9 → 0.43.1

package/dist/index.d.ts

@@ -2835,13 +2835,15 @@ declare namespace TableData {
          * - SET DEFAULT Set all the referencing columns, or a specified subset of the referencing columns, to their default values. A subset of columns can only be specified for ON DELETE actions. (There must be a row in the referenced table matching the default values, if they are not null, or the operation will fail.)
          */
         type Action = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
-        interface Options {
-            name?: string;
+        interface BaseOptions {
             match?: Match;
             onUpdate?: Action;
             onDelete?: Action;
             dropMode?: TableData.DropMode;
         }
+        interface Options extends BaseOptions {
+            name?: string;
+        }
     }
     export {  };
 }
@@ -2971,7 +2973,7 @@ declare const tableDataMethods: TableDataMethods<string>;
 declare const parseTableData: (dataFn?: TableDataFn<unknown, any>) => TableData;
 declare const parseTableDataInput: (tableData: TableData, item: TableDataInput) => void;
 
-interface NumberColumnData extends BaseNumberData {
+interface NumberColumnData extends BaseNumberData, ColumnData {
     identity?: TableData.Identity;
 }
 interface SerialColumnData extends NumberColumnData {
@@ -5465,10 +5467,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 +5476,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 +7315,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:
      *
@@ -8464,7 +8472,7 @@ declare const columnForeignKeysToCode: (foreignKeys: TableData.ColumnReferences[
 declare const foreignKeyArgumentToCode: ({ fnOrTable, foreignColumns, options, }: TableData.ColumnReferences, migration: boolean | undefined) => Codes;
 declare const columnIndexesToCode: (items: Exclude<ColumnData['indexes'], undefined>) => Codes;
 declare const columnExcludesToCode: (items: Exclude<ColumnData['excludes'], undefined>) => Codes;
-declare const columnCheckToCode: (ctx: ColumnToCodeCtx, { sql, name }: ColumnDataCheckBase, columnName: string) => string;
+declare const columnCheckToCode: (ctx: ColumnToCodeCtx, checks: ColumnDataCheckBase[]) => string;
 declare const identityToCode: (identity: TableData.Identity, dataType?: string) => Codes;
 declare const columnCode: (type: ColumnType, ctx: ColumnToCodeCtx, key: string, code: Code) => Code;
 

package/dist/index.js

@@ -812,8 +812,10 @@ const columnExcludesToCode = (items) => {
   }
   return code;
 };
-const columnCheckToCode = (ctx, { sql, name }, columnName) => {
-  return `.check(${sql.toCode(ctx.t)}${name && name !== `${ctx.table}_${columnName}_check` ? `, { name: '${name}' }` : ""})`;
+const columnCheckToCode = (ctx, checks) => {
+  return checks.map(
+    ({ sql, name }) => `.check(${sql.toCode(ctx.t)}${name ? `, '${name}'` : ""})`
+  ).join("");
 };
 const identityToCode = (identity, dataType) => {
   const code = [];
@@ -897,8 +899,8 @@ const columnCode = (type, ctx, key, code) => {
     }
   }
   if (data.comment) orchidCore.addCode(code, `.comment(${orchidCore.singleQuote(data.comment)})`);
-  if (data.check) {
-    orchidCore.addCode(code, columnCheckToCode(ctx, data.check, name));
+  if (data.checks) {
+    orchidCore.addCode(code, columnCheckToCode(ctx, data.checks));
   }
   if (data.errors) {
     for (const part of orchidCore.columnErrorMessagesToCode(data.errors)) {
@@ -5650,11 +5652,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 +5705,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 +5715,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 +5730,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 +5786,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 +5812,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 +5837,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 +6610,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 +6627,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 +11745,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) {