@grest-ts/sql 0.0.6 → 0.0.8

package/src/select/parts/S4Having.ts

@@ -1,24 +1,24 @@
-import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart, SQL_BOOL} from "../../Types";
-import {Expr} from "../../SqlExpression";
-import {OrderByMethods} from "./S5OrderBy";
-import {LimitMethods} from "./S6Limit";
-import {ExecMethods} from "./S7Exec";
-
-export interface HavingMethods<Result, Tables> extends OrderByMethods<Result, Tables>, LimitMethods<Result>, ExecMethods<Result> {
-    having<
-        TableRef,
-        Columns extends (Expr<TableRef, string | unknown, SQL_BOOL>)[]
-    >(
-        ...col: isColumnOkToUse<Tables, Columns>
-    ): OrderByMethods<Result, Tables>
-
-    havingF<
-        TableRef,
-        Columns extends Expr<TableRef, string | unknown, SQL_BOOL>[]
-    >(
-        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
-    ): OrderByMethods<Result, Tables> & LimitMethods<Result>
-}
-
-
-
+import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart, SQL_BOOL} from "../../Types";
+import {Expr} from "../../SqlExpression";
+import {OrderByMethods} from "./S5OrderBy";
+import {LimitMethods} from "./S6Limit";
+import {ExecMethods} from "./S7Exec";
+
+export interface HavingMethods<Result, Tables> extends OrderByMethods<Result, Tables>, LimitMethods<Result>, ExecMethods<Result> {
+    having<
+        TableRef,
+        Columns extends (Expr<TableRef, string | unknown, SQL_BOOL>)[]
+    >(
+        ...col: isColumnOkToUse<Tables, Columns>
+    ): OrderByMethods<Result, Tables>
+
+    havingF<
+        TableRef,
+        Columns extends Expr<TableRef, string | unknown, SQL_BOOL>[]
+    >(
+        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
+    ): OrderByMethods<Result, Tables> & LimitMethods<Result>
+}
+
+
+

package/src/select/parts/S5OrderBy.ts

@@ -1,21 +1,21 @@
-import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart, OrderByStructure} from "../../Types";
-import {LimitMethods} from "./S6Limit";
-import {Expr} from "../../SqlExpression";
-import {ExecMethods} from "./S7Exec";
-
-export interface OrderByMethods<Result, Tables> extends LimitMethods<Result>, ExecMethods<Result> {
-    orderBy<
-        TableRef,
-        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
-    >(
-        ...items: isColumnOkToUse<Tables, Columns>
-    ): LimitMethods<Result>
-
-    orderByF<
-        TableRef,
-        Columns extends OrderByStructure<Expr<TableRef, string | unknown, string | number>>
-    >(
-        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
-    ): LimitMethods<Result>
-
-}
+import {AliasedTable, isColumnOkToUse, Key, NotUsingWithPart, OrderByStructure} from "../../Types";
+import {LimitMethods} from "./S6Limit";
+import {Expr} from "../../SqlExpression";
+import {ExecMethods} from "./S7Exec";
+
+export interface OrderByMethods<Result, Tables> extends LimitMethods<Result>, ExecMethods<Result> {
+    orderBy<
+        TableRef,
+        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
+    >(
+        ...items: isColumnOkToUse<Tables, Columns>
+    ): LimitMethods<Result>
+
+    orderByF<
+        TableRef,
+        Columns extends OrderByStructure<Expr<TableRef, string | unknown, string | number>>
+    >(
+        func: (columnsTable: AliasedTable<"(columns)", "(columns)", Result, object, NotUsingWithPart>) => isColumnOkToUse<Tables & Key<"(columns)">, Columns>
+    ): LimitMethods<Result>
+
+}

package/src/select/parts/S6Limit.ts

@@ -1,9 +1,9 @@
-import {ExecMethods} from "./S7Exec";
-
-export interface LimitMethods<Result> extends ExecMethods<Result> {
-    noLimit(): ExecMethods<Result>
-
-    limit(limit: number | [number, number]): ExecMethods<Result>
-
-    limit1(): ExecMethods<Result>
-}
+import {ExecMethods} from "./S7Exec";
+
+export interface LimitMethods<Result> extends ExecMethods<Result> {
+    noLimit(): ExecMethods<Result>
+
+    limit(limit: number | [number, number]): ExecMethods<Result>
+
+    limit1(): ExecMethods<Result>
+}

package/src/select/parts/S7Exec.ts

@@ -1,41 +1,41 @@
-import {AliasedTable, NotUsingWithPart, SelectExecutor, SqlSelectQuery} from "../../Types";
-import {Expr} from "../../SqlExpression";
-import {UnionMethods} from "./S0Union";
-
-export interface ExecMethods<Result> extends SqlSelectQuery<Result>, UnionMethods<Result> {
-
-    forUpdate(): ExecMethods<Result>
-
-    asScalar<Alias extends string>(
-        alias: Alias & ScalarSubQueryAllowsOnlyOneColumn<Alias, Result> extends never ? "Scalar subquery allows only 1 column!" : Alias
-    ): Expr<never, Alias, Result[keyof Result]>
-
-    as<Alias extends string>(alias: Alias): AliasedTable<Alias, `(SUBQUERY) as ${Alias}`, Result, object, NotUsingWithPart>
-
-    /**
-     * Example of an executor method.
-     * Notice that it can force existence of other arguments in the exec call. In this case forcing ctx to be added.
-     * async <Result>(sql: string, ctx: Ctx): Promise<Result> => {
-     *     return someDb.query(ctx, sql);
-     * }
-     */
-    exec<Args extends any[]>(executor: SelectExecutor<Result, Args>, ...args: Args): Promise<Result[]>
-
-    /**
-     * Same as exec, but returns one row
-     */
-    execOne<Args extends any[]>(executor: SelectExecutor<Result, Args>, ...args: Args): Promise<Result>
-
-}
-
-/**
- * Basically checks that Result would have only one column defined.
- */
-type ScalarSubQueryAllowsOnlyOneColumn<Result, T, Keys extends keyof any = keyof T> =
-    Keys extends any
-        ? T extends Record<Keys, any>
-            ? Exclude<keyof T, Keys> extends never
-                ? Result
-                : never
-            : never
-        : never;
+import {AliasedTable, NotUsingWithPart, SelectExecutor, SqlSelectQuery} from "../../Types";
+import {Expr} from "../../SqlExpression";
+import {UnionMethods} from "./S0Union";
+
+export interface ExecMethods<Result> extends SqlSelectQuery<Result>, UnionMethods<Result> {
+
+    forUpdate(): ExecMethods<Result>
+
+    asScalar<Alias extends string>(
+        alias: Alias & ScalarSubQueryAllowsOnlyOneColumn<Alias, Result> extends never ? "Scalar subquery allows only 1 column!" : Alias
+    ): Expr<never, Alias, Result[keyof Result]>
+
+    as<Alias extends string>(alias: Alias): AliasedTable<Alias, `(SUBQUERY) as ${Alias}`, Result, object, NotUsingWithPart>
+
+    /**
+     * Example of an executor method.
+     * Notice that it can force existence of other arguments in the exec call. In this case forcing ctx to be added.
+     * async <Result>(sql: string, ctx: Ctx): Promise<Result> => {
+     *     return someDb.query(ctx, sql);
+     * }
+     */
+    exec<Args extends any[]>(executor: SelectExecutor<Result, Args>, ...args: Args): Promise<Result[]>
+
+    /**
+     * Same as exec, but returns one row
+     */
+    execOne<Args extends any[]>(executor: SelectExecutor<Result, Args>, ...args: Args): Promise<Result>
+
+}
+
+/**
+ * Basically checks that Result would have only one column defined.
+ */
+type ScalarSubQueryAllowsOnlyOneColumn<Result, T, Keys extends keyof any = keyof T> =
+    Keys extends any
+        ? T extends Record<Keys, any>
+            ? Exclude<keyof T, Keys> extends never
+                ? Result
+                : never
+            : never
+        : never;

package/src/update/UpdateBuilder.ts

@@ -1,96 +1,96 @@
-import {escape, escapeId} from "../escape";
-import {SQL_ENTITY, SQL_EXPRESSION} from "../Symbols";
-import {ExecUpdateMethods, GatewayUpdateOrderByMethods, GatewayUpdateWhereMethods, UpdateLimitMethods, UpdateOrderByMethods, UpdateSetMethods, UpdateWhereMethods} from "./UpdateInterfaces";
-import {AnyExpr, SqlExpression} from "../SqlExpression";
-import {OrderByStructure} from "../Types";
-import {orderByStructureToSqlString, toSql} from "../SqlFunctions";
-
-export class UpdateBuilder<Entity, Tables> implements ExecUpdateMethods,
-    GatewayUpdateWhereMethods<Entity>,
-    GatewayUpdateOrderByMethods<Entity>,
-    UpdateSetMethods<Entity, Tables>,
-    UpdateWhereMethods<Tables>,
-    UpdateOrderByMethods<Tables>,
-    UpdateLimitMethods {
-
-    public readonly [SQL_ENTITY]: { affectedRows: number; }; // never used
-
-    private _tableName: string;
-    private _joins: string[] = [];
-    private _set: string[] = []
-    private readonly _where: string[] = [];
-    private readonly _orderBy: string[] = [];
-    private _limit: string;
-    private _ignore: boolean = false;
-
-    public in(tableName: string, alias?: string) {
-        this._tableName = tableName + (alias ? " as " + escapeId(alias) : "");
-        return this;
-    }
-
-    public ignore() {
-        this._ignore = true;
-        return this
-    }
-
-    public join(table: any): this {
-        this._joins.push(table[SQL_EXPRESSION])
-        return this;
-    }
-
-    public set(obj: any): this {
-        for (const prop in obj) {
-            this._set.push(escapeId(prop) + " = " + toSql(obj[prop]));
-        }
-        return this
-    }
-
-    public where(...cols: any | SqlExpression<any, any, any>): this {
-        for (let i = 0; i < cols.length; i++) {
-            const col = cols[i];
-            if (col instanceof SqlExpression) {
-                this._where.push(col.expression)
-            } else {
-                for (const k in col) {
-                    this._where.push(escapeId(k) + " = " + escape(col[k]))
-                }
-            }
-        }
-        return this
-    }
-
-    public noWhere() {
-        return this;
-    }
-
-    public orderBy(...items: any | OrderByStructure<AnyExpr>): this {
-        this._orderBy.push(...orderByStructureToSqlString(items))
-        return this;
-    }
-
-    public noLimit(): this {
-        return this;
-    }
-
-    public limit1(): this {
-        return this.limit(1);
-    }
-
-    public limit(limit: number | [number, number]): this {
-        if (Array.isArray(limit)) {
-            this._limit = Number(limit[0]) + "," + Number(limit[1]);
-        } else {
-            this._limit = String(Number(limit));
-        }
-        return this;
-    }
-
-    public toSqlString() {
-        return "UPDATE " + (this._ignore ? "IGNORE " : "") + this._tableName + " " +
-            (this._joins.length > 0 ? ", \n" + this._joins.join(",\n") : "") +
-            (this._set.length > 0 ? "SET \n\t" + this._set.join(",\n\t") + " \n" : "") +
-            (this._where.length > 0 ? "WHERE " + this._where.join(" AND ") + " \n" : "") +
-            (this._orderBy.length > 0 ? "ORDER BY " + this._orderBy.join(", ") + " \n" : "") +
-            (this._limit ? "LIMIT " + this._limit : "")
-    }
+import {escape, escapeId} from "../escape";
+import {SQL_ENTITY, SQL_EXPRESSION} from "../Symbols";
+import {ExecUpdateMethods, GatewayUpdateOrderByMethods, GatewayUpdateWhereMethods, UpdateLimitMethods, UpdateOrderByMethods, UpdateSetMethods, UpdateWhereMethods} from "./UpdateInterfaces";
+import {AnyExpr, SqlExpression} from "../SqlExpression";
+import {OrderByStructure} from "../Types";
+import {orderByStructureToSqlString, toSql} from "../SqlFunctions";
+
+export class UpdateBuilder<Entity, Tables> implements ExecUpdateMethods,
+    GatewayUpdateWhereMethods<Entity>,
+    GatewayUpdateOrderByMethods<Entity>,
+    UpdateSetMethods<Entity, Tables>,
+    UpdateWhereMethods<Tables>,
+    UpdateOrderByMethods<Tables>,
+    UpdateLimitMethods {
+
+    public readonly [SQL_ENTITY]: { affectedRows: number; }; // never used
+
+    private _tableName: string;
+    private _joins: string[] = [];
+    private _set: string[] = []
+    private readonly _where: string[] = [];
+    private readonly _orderBy: string[] = [];
+    private _limit: string;
+    private _ignore: boolean = false;
+
+    public in(tableName: string, alias?: string) {
+        this._tableName = tableName + (alias ? " as " + escapeId(alias) : "");
+        return this;
+    }
+
+    public ignore() {
+        this._ignore = true;
+        return this
+    }
+
+    public join(table: any): this {
+        this._joins.push(table[SQL_EXPRESSION])
+        return this;
+    }
+
+    public set(obj: any): this {
+        for (const prop in obj) {
+            this._set.push(escapeId(prop) + " = " + toSql(obj[prop]));
+        }
+        return this
+    }
+
+    public where(...cols: any | SqlExpression<any, any, any>): this {
+        for (let i = 0; i < cols.length; i++) {
+            const col = cols[i];
+            if (col instanceof SqlExpression) {
+                this._where.push(col.expression)
+            } else {
+                for (const k in col) {
+                    this._where.push(escapeId(k) + " = " + escape(col[k]))
+                }
+            }
+        }
+        return this
+    }
+
+    public noWhere() {
+        return this;
+    }
+
+    public orderBy(...items: any | OrderByStructure<AnyExpr>): this {
+        this._orderBy.push(...orderByStructureToSqlString(items))
+        return this;
+    }
+
+    public noLimit(): this {
+        return this;
+    }
+
+    public limit1(): this {
+        return this.limit(1);
+    }
+
+    public limit(limit: number | [number, number]): this {
+        if (Array.isArray(limit)) {
+            this._limit = Number(limit[0]) + "," + Number(limit[1]);
+        } else {
+            this._limit = String(Number(limit));
+        }
+        return this;
+    }
+
+    public toSqlString() {
+        return "UPDATE " + (this._ignore ? "IGNORE " : "") + this._tableName + " " +
+            (this._joins.length > 0 ? ", \n" + this._joins.join(",\n") : "") +
+            (this._set.length > 0 ? "SET \n\t" + this._set.join(",\n\t") + " \n" : "") +
+            (this._where.length > 0 ? "WHERE " + this._where.join(" AND ") + " \n" : "") +
+            (this._orderBy.length > 0 ? "ORDER BY " + this._orderBy.join(", ") + " \n" : "") +
+            (this._limit ? "LIMIT " + this._limit : "")
+    }
 }

package/src/update/UpdateInterfaces.ts

@@ -1,87 +1,87 @@
-import {AliasedTable, isColumnOkToUse, isTableReferenced, Key, NotUsingWithPart, OrderByStructure, SQL_BOOL, SqlQuery} from "../Types";
-import {Expr} from "../SqlExpression";
-
-export interface GatewayUpdateWhereMethods<Entity> {
-
-    where(obj: Partial<Entity>): GatewayUpdateOrderByMethods<Entity>
-
-}
-
-export interface GatewayUpdateOrderByMethods<Entity> extends UpdateLimitMethods {
-
-    orderBy(fields: keyof Entity): UpdateLimitMethods
-
-}
-
-export interface UpdateSetMethods<Entity, Tables> {
-
-    set(value: PartialAndCheckExpr<Entity, Tables>): UpdateWhereMethods<Tables>
-
-    join<
-        Alias extends string,
-        TableRef extends `${string} as ${Alias}`,
-    >(
-        table: AliasedTable<Alias, TableRef, object, object, NotUsingWithPart>
-    ): UpdateSetMethods<Entity, Tables & Key<TableRef>>;
-
-}
-
-type PartialAndCheckExpr<Entity, Tables> = {
-    [P in keyof Entity]?: Entity[P] | Expr<keyof Tables, string, Entity[P]>
-};
-
-export interface UpdateWhereMethods<Tables> {
-
-    noWhere(): UpdateOrderByMethods<Tables>
-
-    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,
-        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>
-    ): UpdateOrderByMethods<Tables>
-
-}
-
-type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
-
-export interface UpdateOrderByMethods<Tables> extends UpdateLimitMethods {
-
-    orderBy<
-        TableRef,
-        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
-    >(
-        ...items: isColumnOkToUse<Tables, Columns>
-    ): UpdateLimitMethods
-
-}
-
-export interface UpdateLimitMethods {
-    noLimit(): ExecUpdateMethods
-
-    limit(limit: number | [number, number]): ExecUpdateMethods
-
-    limit1(): ExecUpdateMethods
-}
-
-export interface ExecUpdateMethods extends SqlQuery<{ affectedRows: number }> {
-
-}
+import {AliasedTable, isColumnOkToUse, isTableReferenced, Key, NotUsingWithPart, OrderByStructure, SQL_BOOL, SqlQuery} from "../Types";
+import {Expr} from "../SqlExpression";
+
+export interface GatewayUpdateWhereMethods<Entity> {
+
+    where(obj: Partial<Entity>): GatewayUpdateOrderByMethods<Entity>
+
+}
+
+export interface GatewayUpdateOrderByMethods<Entity> extends UpdateLimitMethods {
+
+    orderBy(fields: keyof Entity): UpdateLimitMethods
+
+}
+
+export interface UpdateSetMethods<Entity, Tables> {
+
+    set(value: PartialAndCheckExpr<Entity, Tables>): UpdateWhereMethods<Tables>
+
+    join<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, object, object, NotUsingWithPart>
+    ): UpdateSetMethods<Entity, Tables & Key<TableRef>>;
+
+}
+
+type PartialAndCheckExpr<Entity, Tables> = {
+    [P in keyof Entity]?: Entity[P] | Expr<keyof Tables, string, Entity[P]>
+};
+
+export interface UpdateWhereMethods<Tables> {
+
+    noWhere(): UpdateOrderByMethods<Tables>
+
+    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,
+        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>
+    ): UpdateOrderByMethods<Tables>
+
+}
+
+type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
+
+export interface UpdateOrderByMethods<Tables> extends UpdateLimitMethods {
+
+    orderBy<
+        TableRef,
+        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
+    >(
+        ...items: isColumnOkToUse<Tables, Columns>
+    ): UpdateLimitMethods
+
+}
+
+export interface UpdateLimitMethods {
+    noLimit(): ExecUpdateMethods
+
+    limit(limit: number | [number, number]): ExecUpdateMethods
+
+    limit1(): ExecUpdateMethods
+}
+
+export interface ExecUpdateMethods extends SqlQuery<{ affectedRows: number }> {
+
+}