@grest-ts/sql 0.0.6 → 0.0.7

package/src/select/parts/GatewayWhere.ts

@@ -1,31 +1,31 @@
-import {ExecMethods} from "./S7Exec";
-import {OrderByStructure} from "../../Types";
-
-
-export interface GatewayWhereMethods<Entity, Result> {
-
-    where(where: Partial<Entity>): GatewaySelectGroupByMethods<Entity, Result> & GatewaySelectOrderByMethods<Entity, Result> & GatewaySelectLimitMethods<Result> & ExecMethods<Result>
-
-}
-
-export interface GatewaySelectGroupByMethods<Entity, Result> extends GatewaySelectLimitMethods<Result> {
-
-    groupBy(...fields: (keyof Entity)[]): GatewaySelectOrderByMethods<Entity, Result> & GatewaySelectLimitMethods<Result> & ExecMethods<Result>
-
-}
-
-export interface GatewaySelectOrderByMethods<Entity, Result> extends GatewaySelectLimitMethods<Result> {
-
-    orderBy(...fields: OrderByStructure<keyof Entity>): GatewaySelectLimitMethods<Result> & ExecMethods<Result>
-
-}
-
-export interface GatewaySelectLimitMethods<Result> {
-
-    noLimit(): ExecMethods<Result>
-
-    limit(limit: number | [number, number]): ExecMethods<Result>
-
-    limit1(): ExecMethods<Result>
-
+import {ExecMethods} from "./S7Exec";
+import {OrderByStructure} from "../../Types";
+
+
+export interface GatewayWhereMethods<Entity, Result> {
+
+    where(where: Partial<Entity>): GatewaySelectGroupByMethods<Entity, Result> & GatewaySelectOrderByMethods<Entity, Result> & GatewaySelectLimitMethods<Result> & ExecMethods<Result>
+
+}
+
+export interface GatewaySelectGroupByMethods<Entity, Result> extends GatewaySelectLimitMethods<Result> {
+
+    groupBy(...fields: (keyof Entity)[]): GatewaySelectOrderByMethods<Entity, Result> & GatewaySelectLimitMethods<Result> & ExecMethods<Result>
+
+}
+
+export interface GatewaySelectOrderByMethods<Entity, Result> extends GatewaySelectLimitMethods<Result> {
+
+    orderBy(...fields: OrderByStructure<keyof Entity>): GatewaySelectLimitMethods<Result> & ExecMethods<Result>
+
+}
+
+export interface GatewaySelectLimitMethods<Result> {
+
+    noLimit(): ExecMethods<Result>
+
+    limit(limit: number | [number, number]): ExecMethods<Result>
+
+    limit1(): ExecMethods<Result>
+
 }

package/src/select/parts/S0Union.ts

@@ -1,43 +1,43 @@
-import {ExecMethods} from "./S7Exec";
-import {GroupByMethods} from "./S3GroupBy";
-
-export interface UnionMethods<Result> {
-
-    union<Exec, MergedResult = Merge<Result, Exec>>(
-        table: Check<Result, Exec> & Exec
-    ): UnionMethods<MergedResult> & GroupByMethods<MergedResult, {}>
-
-
-    unionAll<Exec, MergedResult = Merge<Result, Exec>>(
-        table: Check<Result, Exec> & Exec
-    ): UnionMethods<MergedResult> & GroupByMethods<MergedResult, {}>
-}
-
-type Check<Result1, Exec> = Exec extends ExecMethods<infer Result2>
-    ? Key1Checker<Result1, Result2> extends never
-        ? Key2Checker<Result1, Result2> extends never
-            ? Exec
-            : Key2Checker<Result1, Result2>
-        : Key1Checker<Result1, Result2>
-    : never
-
-type Key1Checker<Result1, Result2> = {
-    [K in keyof Result1]: K extends keyof Result2
-        ? never
-        : `Missing column '${K extends string ? K : "???"}' on added union table! (...,${K extends string ? K : "???"}) UNION (..., ${K extends string ? K : "???"} <- Missing!)
-                                                                                                                                                                                                                                                                                         `
-    // Empty line is intentional to have only this message as an Error and no obejct comparison.
-}[keyof Result1]
-
-type Key2Checker<Result1, Result2> = {
-    [K in keyof Result2]: K extends keyof Result1
-        ? never
-        : `Column '${K extends string ? K : "???"}' does not exist in previous queries! (...) UNION (...,'${K extends string ? K : "???"}' <--- is a mistake (or add it to previous queries)!)
-                                                                                                                                                                                                                                                                                         `
-    // Empty line is intentional to have only this message as an Error and no obejct comparison.
-}[keyof Result2]
-
-
-type Merge<Result, Exec> = Exec extends ExecMethods<infer Result2> ? {
-    [K in keyof Result]: K extends keyof Result2 ? Result[K] | Result2[K] : never
-} : never;
+import {ExecMethods} from "./S7Exec";
+import {GroupByMethods} from "./S3GroupBy";
+
+export interface UnionMethods<Result> {
+
+    union<Exec, MergedResult = Merge<Result, Exec>>(
+        table: Check<Result, Exec> & Exec
+    ): UnionMethods<MergedResult> & GroupByMethods<MergedResult, {}>
+
+
+    unionAll<Exec, MergedResult = Merge<Result, Exec>>(
+        table: Check<Result, Exec> & Exec
+    ): UnionMethods<MergedResult> & GroupByMethods<MergedResult, {}>
+}
+
+type Check<Result1, Exec> = Exec extends ExecMethods<infer Result2>
+    ? Key1Checker<Result1, Result2> extends never
+        ? Key2Checker<Result1, Result2> extends never
+            ? Exec
+            : Key2Checker<Result1, Result2>
+        : Key1Checker<Result1, Result2>
+    : never
+
+type Key1Checker<Result1, Result2> = {
+    [K in keyof Result1]: K extends keyof Result2
+        ? never
+        : `Missing column '${K extends string ? K : "???"}' on added union table! (...,${K extends string ? K : "???"}) UNION (..., ${K extends string ? K : "???"} <- Missing!)
+                                                                                                                                                                                                                                                                                         `
+    // Empty line is intentional to have only this message as an Error and no obejct comparison.
+}[keyof Result1]
+
+type Key2Checker<Result1, Result2> = {
+    [K in keyof Result2]: K extends keyof Result1
+        ? never
+        : `Column '${K extends string ? K : "???"}' does not exist in previous queries! (...) UNION (...,'${K extends string ? K : "???"}' <--- is a mistake (or add it to previous queries)!)
+                                                                                                                                                                                                                                                                                         `
+    // Empty line is intentional to have only this message as an Error and no obejct comparison.
+}[keyof Result2]
+
+
+type Merge<Result, Exec> = Exec extends ExecMethods<infer Result2> ? {
+    [K in keyof Result]: K extends keyof Result2 ? Result[K] | Result2[K] : never
+} : never;

package/src/select/parts/S0Uses.ts

@@ -1,21 +1,21 @@
-import {AliasedTable, Key, NotUsingWithPart} from "../../Types";
-import {JoinMethods} from "./S1Join";
-
-export interface UsesMethods<Aliases, Tables> {
-
-    // uses<
-    //     Alias extends string,
-    //     TableRef extends `${string} as ${Alias}`
-    // >(
-    //     table: isAliasAlreadyUsed<Aliases, Alias, AliasedTable<Alias, TableRef, any, NotUsingWithPart>>
-    // ): UsesMethods<Aliases & Key<Alias>, Tables & Key<TableRef>>
-
-
-    selectFrom<
-        Alias extends string,
-        TableRef extends `${string} as ${Alias}`
-    >(
-        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
-    ): JoinMethods<Aliases & Key<Alias>, {}, Tables & Key<TableRef>>
-
-}
+import {AliasedTable, Key, NotUsingWithPart} from "../../Types";
+import {JoinMethods} from "./S1Join";
+
+export interface UsesMethods<Aliases, Tables> {
+
+    // uses<
+    //     Alias extends string,
+    //     TableRef extends `${string} as ${Alias}`
+    // >(
+    //     table: isAliasAlreadyUsed<Aliases, Alias, AliasedTable<Alias, TableRef, any, NotUsingWithPart>>
+    // ): UsesMethods<Aliases & Key<Alias>, Tables & Key<TableRef>>
+
+
+    selectFrom<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`
+    >(
+        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
+    ): JoinMethods<Aliases & Key<Alias>, {}, Tables & Key<TableRef>>
+
+}

package/src/select/parts/S0With.ts

@@ -1,21 +1,21 @@
-import {AliasedTable, Key, NotUsingWithPart} from "../../Types";
-import {JoinMethods} from "./S1Join";
-
-export interface WithMethods<AliasesFromWith> {
-
-    // with<
-    //     Alias extends string,
-    //     TableRef extends `${string} as ${Alias}`
-    // >(
-    //     table: isAliasAlreadyUsed<AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, NotUsingWithPart>>
-    // ): WithMethods<AliasesFromWith & Key<Alias>>
-
-    selectFrom<
-        Alias extends string,
-        TableRef extends `${string} as ${Alias}`
-    >(
-        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
-    ): JoinMethods<Key<Alias>, AliasesFromWith, Key<TableRef>>
-
-}
-
+import {AliasedTable, Key, NotUsingWithPart} from "../../Types";
+import {JoinMethods} from "./S1Join";
+
+export interface WithMethods<AliasesFromWith> {
+
+    // with<
+    //     Alias extends string,
+    //     TableRef extends `${string} as ${Alias}`
+    // >(
+    //     table: isAliasAlreadyUsed<AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, NotUsingWithPart>>
+    // ): WithMethods<AliasesFromWith & Key<Alias>>
+
+    selectFrom<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`
+    >(
+        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
+    ): JoinMethods<Key<Alias>, AliasesFromWith, Key<TableRef>>
+
+}
+

package/src/select/parts/S1Join.ts

@@ -1,39 +1,39 @@
-import {AliasedTable, isAliasAlreadyUsed, isTableReferenced, Key, NotUsingWithPart, SQL_BOOL} from "../../Types";
-import {Expr, Over} from "../../SqlExpression";
-import {ColumnsMethods} from "./S2Columns";
-
-export interface JoinMethods<Aliases, AliasesFromWith, Tables> extends ColumnsMethods<{}, Tables> {
-
-    join<
-        Alias extends string,
-        TableRef extends `${string} as ${Alias}`,
-        RefAlias extends NotUsingWithPart | string,
-        ColTableRef extends string
-    >(
-        table: isRefAliasInAliasesFromWith<AliasesFromWith, RefAlias, isAliasAlreadyUsed<Aliases & AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, object, RefAlias>>>,
-        condition: isConditionUsingJoinedTable<TableRef, ColTableRef, isTableReferenced<Tables & Key<TableRef>, Key<ColTableRef>, Expr<ColTableRef, unknown, SQL_BOOL>>>
-    ): JoinMethods<Aliases & Key<Alias>, AliasesFromWith, Tables & Key<TableRef>>
-
-    leftJoin<
-        Alias extends string,
-        TableRef extends `${string} as ${Alias}`,
-        RefAlias extends NotUsingWithPart | string,
-        ColTableRef extends string
-    >(
-        table: isRefAliasInAliasesFromWith<AliasesFromWith, RefAlias, isAliasAlreadyUsed<Aliases & AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, object, RefAlias>>>,
-        condition: isConditionUsingJoinedTable<TableRef, ColTableRef, isTableReferenced<Tables & Key<TableRef>, Key<ColTableRef>, Expr<ColTableRef, unknown, SQL_BOOL>>>
-    ): JoinMethods<Aliases & Key<Alias>, AliasesFromWith, Tables & Key<TableRef>>
-
-    window<
-        WindowName extends string,
-        UsedTablesRef extends string
-    >(
-        name: isAliasAlreadyUsed<Aliases & AliasesFromWith, WindowName, WindowName>,
-        func: (builder: Over<never>) => Over<UsedTablesRef>
-    ): JoinMethods<Aliases & Key<WindowName>, AliasesFromWith, Tables & Key<`(window) as ${WindowName}`>>
-
-}
-
-type isConditionUsingJoinedTable<TableRef, ColTableRef, OUT> = TableRef extends ColTableRef ? OUT : "Join condition should use columns from the joined table!"
-
+import {AliasedTable, isAliasAlreadyUsed, isTableReferenced, Key, NotUsingWithPart, SQL_BOOL} from "../../Types";
+import {Expr, Over} from "../../SqlExpression";
+import {ColumnsMethods} from "./S2Columns";
+
+export interface JoinMethods<Aliases, AliasesFromWith, Tables> extends ColumnsMethods<{}, Tables> {
+
+    join<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+        RefAlias extends NotUsingWithPart | string,
+        ColTableRef extends string
+    >(
+        table: isRefAliasInAliasesFromWith<AliasesFromWith, RefAlias, isAliasAlreadyUsed<Aliases & AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, object, RefAlias>>>,
+        condition: isConditionUsingJoinedTable<TableRef, ColTableRef, isTableReferenced<Tables & Key<TableRef>, Key<ColTableRef>, Expr<ColTableRef, unknown, SQL_BOOL>>>
+    ): JoinMethods<Aliases & Key<Alias>, AliasesFromWith, Tables & Key<TableRef>>
+
+    leftJoin<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+        RefAlias extends NotUsingWithPart | string,
+        ColTableRef extends string
+    >(
+        table: isRefAliasInAliasesFromWith<AliasesFromWith, RefAlias, isAliasAlreadyUsed<Aliases & AliasesFromWith, Alias, AliasedTable<Alias, TableRef, object, object, RefAlias>>>,
+        condition: isConditionUsingJoinedTable<TableRef, ColTableRef, isTableReferenced<Tables & Key<TableRef>, Key<ColTableRef>, Expr<ColTableRef, unknown, SQL_BOOL>>>
+    ): JoinMethods<Aliases & Key<Alias>, AliasesFromWith, Tables & Key<TableRef>>
+
+    window<
+        WindowName extends string,
+        UsedTablesRef extends string
+    >(
+        name: isAliasAlreadyUsed<Aliases & AliasesFromWith, WindowName, WindowName>,
+        func: (builder: Over<never>) => Over<UsedTablesRef>
+    ): JoinMethods<Aliases & Key<WindowName>, AliasesFromWith, Tables & Key<`(window) as ${WindowName}`>>
+
+}
+
+type isConditionUsingJoinedTable<TableRef, ColTableRef, OUT> = TableRef extends ColTableRef ? OUT : "Join condition should use columns from the joined table!"
+
 type isRefAliasInAliasesFromWith<AliasesFromWith, RefAlias, OUT> = RefAlias extends NotUsingWithPart | string & keyof AliasesFromWith ? OUT : `Alias '${RefAlias extends string ? RefAlias : RefAlias extends NotUsingWithPart ? "NOT_REFERENCED" : "???"}' is not defined by any of the with queries!`

package/src/select/parts/S2Columns.ts

@@ -1,68 +1,68 @@
-import {WhereMethods} from "./S2Where";
-import {Expr} from "../../SqlExpression";
-import {AliasedTable, NotUsingWithPart} from "../../Types";
-
-export interface ColumnsMethods<Result, Tables> {
-
-    distinct(): ColumnsMethods<Result, Tables>
-
-    allColumnsFrom<TableRef, Entity, Result2 = Result & Entity>(table: AliasedTable<string, TableRef, Entity, any, NotUsingWithPart>): ColumnsMethods<Result2, Tables> & WhereMethods<Result2, Tables>
-
-    one(): WhereMethods<Result & { one: 1 }, Tables>
-
-    columns<
-        TableRef,
-        Columns extends Expr<TableRef, string, any>[]
-    >(
-        //...columns: Columns - this will enable seeing sources of Result object properties.
-        ...columns: isColumnOkToAdd<Result, Tables, Columns>
-    ): WhereMethods<Result & ExtractObj<Columns>, Tables>
-
-}
-
-// --------------------------------------------------------------------
-
-/**
- * Take array of Col-s and convert to Record<key, value> & ... object.
- */
-export type ExtractObj<Columns extends Expr<any, string, any>[]> = {
-    [K in Columns[number]['nameAs']]: Extract<Columns[number], { nameAs: K }>['type']
-}
-
-
-// --------------------------------------------------------------------
-
-type _checkIfExistsInOtherFields<Rest extends any[], Expr> =
-    Rest extends []
-        ? Expr
-        : Expr extends { nameAs: string } ?
-            Expr["nameAs"] extends (Rest extends { nameAs: infer A }[] ? A : never)
-                ? `'${Expr["nameAs"]}' already exists in columns!`
-                : Expr
-            : Expr extends { nameAs: unknown } ?
-                `Is missing column name. Add .as('name')`
-                : Expr
-
-type _checkIfExistsInResult<Result, Expr> =
-    Expr extends { nameAs: string } ?
-        Expr["nameAs"] extends keyof Result
-            ? `'${Expr["nameAs"]}' already exists in result columns!`
-            : Expr
-        : Expr
-
-type _checkThatTableIsReferenced<Tables, Expr> =
-    Expr extends { tableRef: string } ?
-        Expr["tableRef"] extends keyof Tables
-            ? Expr
-            : `'${Expr["tableRef"]}' is not used in this query!`
-        : Expr
-
-type isColumnOkToAdd<Result, Tables, ColumnExpressions> =
-    ColumnExpressions extends []
-        ? ColumnExpressions
-        : ColumnExpressions extends [...(infer Rest), infer A]
-            ? [...isColumnOkToAdd<Result, Tables, Rest>, _checkIfExistsInOtherFields<Rest, _checkIfExistsInResult<Result, _checkThatTableIsReferenced<Tables, A>>>]
-            : ColumnExpressions;
-
-
-// --------------------------------------------------------------------
+import {WhereMethods} from "./S2Where";
+import {Expr} from "../../SqlExpression";
+import {AliasedTable, NotUsingWithPart} from "../../Types";
+
+export interface ColumnsMethods<Result, Tables> {
+
+    distinct(): ColumnsMethods<Result, Tables>
+
+    allColumnsFrom<TableRef, Entity, Result2 = Result & Entity>(table: AliasedTable<string, TableRef, Entity, any, NotUsingWithPart>): ColumnsMethods<Result2, Tables> & WhereMethods<Result2, Tables>
+
+    one(): WhereMethods<Result & { one: 1 }, Tables>
+
+    columns<
+        TableRef,
+        Columns extends Expr<TableRef, string, any>[]
+    >(
+        //...columns: Columns - this will enable seeing sources of Result object properties.
+        ...columns: isColumnOkToAdd<Result, Tables, Columns>
+    ): WhereMethods<Result & ExtractObj<Columns>, Tables>
+
+}
+
+// --------------------------------------------------------------------
+
+/**
+ * Take array of Col-s and convert to Record<key, value> & ... object.
+ */
+export type ExtractObj<Columns extends Expr<any, string, any>[]> = {
+    [K in Columns[number]['nameAs']]: Extract<Columns[number], { nameAs: K }>['type']
+}
+
+
+// --------------------------------------------------------------------
+
+type _checkIfExistsInOtherFields<Rest extends any[], Expr> =
+    Rest extends []
+        ? Expr
+        : Expr extends { nameAs: string } ?
+            Expr["nameAs"] extends (Rest extends { nameAs: infer A }[] ? A : never)
+                ? `'${Expr["nameAs"]}' already exists in columns!`
+                : Expr
+            : Expr extends { nameAs: unknown } ?
+                `Is missing column name. Add .as('name')`
+                : Expr
+
+type _checkIfExistsInResult<Result, Expr> =
+    Expr extends { nameAs: string } ?
+        Expr["nameAs"] extends keyof Result
+            ? `'${Expr["nameAs"]}' already exists in result columns!`
+            : Expr
+        : Expr
+
+type _checkThatTableIsReferenced<Tables, Expr> =
+    Expr extends { tableRef: string } ?
+        Expr["tableRef"] extends keyof Tables
+            ? Expr
+            : `'${Expr["tableRef"]}' is not used in this query!`
+        : Expr
+
+type isColumnOkToAdd<Result, Tables, ColumnExpressions> =
+    ColumnExpressions extends []
+        ? ColumnExpressions
+        : ColumnExpressions extends [...(infer Rest), infer A]
+            ? [...isColumnOkToAdd<Result, Tables, Rest>, _checkIfExistsInOtherFields<Rest, _checkIfExistsInResult<Result, _checkThatTableIsReferenced<Tables, A>>>]
+            : ColumnExpressions;
+
+
+// --------------------------------------------------------------------

package/src/select/parts/S2Where.ts

@@ -1,51 +1,51 @@
-import {isTableReferenced, Key, SQL_BOOL} from "../../Types";
-import {GroupByMethods} from "./S3GroupBy";
-import {Expr} from "../../SqlExpression";
-import {OrderByMethods} from "./S5OrderBy";
-import {LimitMethods} from "./S6Limit";
-import {ExecMethods} from "./S7Exec";
-
-export interface WhereMethods<Result, Tables> {
-
-    noWhere(): GroupByMethods<Result, Tables> & OrderByMethods<Result, Tables> & LimitMethods<Result> & ExecMethods<Result>
-
-    where<
-        T1 extends string,
-        T2 extends string = never,
-        T3 extends string = never,
-        T4 extends string = never,
-        T5 extends string = never,
-        T6 extends string = never,
-        T7 extends string = never,
-        T8 extends string = never,
-        T9 extends string = never,
-        T10 extends string = never,
-        T11 extends string = never,
-        T12 extends string = never,
-        T13 extends string = never,
-        T14 extends string = never,
-        T15 extends string = never,
-        T = Tables
-    >(
-        c1: C<T, T1>,
-        c2?: C<T, T2>,
-        c3?: C<T, T3>,
-        c4?: C<T, T4>,
-        c5?: C<T, T5>,
-        c6?: C<T, T6>,
-        c7?: C<T, T7>,
-        c8?: C<T, T8>,
-        c9?: C<T, T9>,
-        c10?: C<T, T10>,
-        c11?: C<T, T11>,
-        c12?: C<T, T12>,
-        c13?: C<T, T13>,
-        c14?: C<T, T14>,
-        c15?: C<T, T15>,
-    ): GroupByMethods<Result, Tables> & OrderByMethods<Result, Tables> & LimitMethods<Result> & ExecMethods<Result>
-
-}
-
-type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
-
-
+import {isTableReferenced, Key, SQL_BOOL} from "../../Types";
+import {GroupByMethods} from "./S3GroupBy";
+import {Expr} from "../../SqlExpression";
+import {OrderByMethods} from "./S5OrderBy";
+import {LimitMethods} from "./S6Limit";
+import {ExecMethods} from "./S7Exec";
+
+export interface WhereMethods<Result, Tables> {
+
+    noWhere(): GroupByMethods<Result, Tables> & OrderByMethods<Result, Tables> & LimitMethods<Result> & ExecMethods<Result>
+
+    where<
+        T1 extends string,
+        T2 extends string = never,
+        T3 extends string = never,
+        T4 extends string = never,
+        T5 extends string = never,
+        T6 extends string = never,
+        T7 extends string = never,
+        T8 extends string = never,
+        T9 extends string = never,
+        T10 extends string = never,
+        T11 extends string = never,
+        T12 extends string = never,
+        T13 extends string = never,
+        T14 extends string = never,
+        T15 extends string = never,
+        T = Tables
+    >(
+        c1: C<T, T1>,
+        c2?: C<T, T2>,
+        c3?: C<T, T3>,
+        c4?: C<T, T4>,
+        c5?: C<T, T5>,
+        c6?: C<T, T6>,
+        c7?: C<T, T7>,
+        c8?: C<T, T8>,
+        c9?: C<T, T9>,
+        c10?: C<T, T10>,
+        c11?: C<T, T11>,
+        c12?: C<T, T12>,
+        c13?: C<T, T13>,
+        c14?: C<T, T14>,
+        c15?: C<T, T15>,
+    ): GroupByMethods<Result, Tables> & OrderByMethods<Result, Tables> & LimitMethods<Result> & ExecMethods<Result>
+
+}
+
+type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
+
+

package/src/select/parts/S3GroupBy.ts

@@ -1,23 +1,23 @@
-import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart} from "../../Types";
-import {HavingMethods} from "./S4Having";
-import {Expr} from "../../SqlExpression";
-import {OrderByMethods} from "./S5OrderBy";
-import {LimitMethods} from "./S6Limit";
-
-export interface GroupByMethods<Result, Tables> extends OrderByMethods<Result, Tables>, LimitMethods<Result> {
-    groupBy<
-        TableRef,
-        Columns extends Expr<TableRef, string | unknown, any>[]
-    >(
-        ...items: isColumnOkToUse<Tables, Columns>
-    ): HavingMethods<Result, Tables>
-
-    groupByF<
-        TableRef,
-        Columns extends Expr<TableRef, string | unknown, any>[]
-    >(
-        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
-    ): HavingMethods<Result, Tables>
-}
-
-
+import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart} from "../../Types";
+import {HavingMethods} from "./S4Having";
+import {Expr} from "../../SqlExpression";
+import {OrderByMethods} from "./S5OrderBy";
+import {LimitMethods} from "./S6Limit";
+
+export interface GroupByMethods<Result, Tables> extends OrderByMethods<Result, Tables>, LimitMethods<Result> {
+    groupBy<
+        TableRef,
+        Columns extends Expr<TableRef, string | unknown, any>[]
+    >(
+        ...items: isColumnOkToUse<Tables, Columns>
+    ): HavingMethods<Result, Tables>
+
+    groupByF<
+        TableRef,
+        Columns extends Expr<TableRef, string | unknown, any>[]
+    >(
+        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
+    ): HavingMethods<Result, Tables>
+}
+
+