@grest-ts/sql 0.0.6 → 0.0.8

package/src/delete/DeleteInterfaces.ts

@@ -1,70 +1,70 @@
-import {isColumnOkToUse, isTableReferenced, Key, OrderByStructure, SQL_BOOL, SqlQuery} from "../Types";
-import {Expr} from "../SqlExpression";
-
-export interface GatewayDeleteWhereMethods<Entity> {
-
-    where(c1: Partial<Entity>): GatewayDeleteOrderByMethods<Entity>
-}
-
-export interface GatewayDeleteOrderByMethods<Entity> extends DeleteLimitMethods {
-
-    orderBy(fields: keyof Entity): DeleteLimitMethods
-
-}
-
-export interface DeleteWhereMethods<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>
-    ): DeleteOrderByMethods<Tables> & DeleteLimitMethods
-
-}
-
-type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
-
-export interface DeleteOrderByMethods<Tables> extends DeleteLimitMethods {
-    orderBy<
-        TableRef,
-        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
-    >(
-        ...items: isColumnOkToUse<Tables, Columns>
-    ): DeleteLimitMethods
-}
-
-
-export interface DeleteLimitMethods {
-    noLimit(): ExecDeleteMethods
-
-    limit(limit: number | [number, number]): ExecDeleteMethods
-
-    limit1(): ExecDeleteMethods
-}
-
-
-export interface ExecDeleteMethods extends SqlQuery<{ affectedRows: number }> {
-
-    toString(lvl?: number): string
-
-}
-
+import {isColumnOkToUse, isTableReferenced, Key, OrderByStructure, SQL_BOOL, SqlQuery} from "../Types";
+import {Expr} from "../SqlExpression";
+
+export interface GatewayDeleteWhereMethods<Entity> {
+
+    where(c1: Partial<Entity>): GatewayDeleteOrderByMethods<Entity>
+}
+
+export interface GatewayDeleteOrderByMethods<Entity> extends DeleteLimitMethods {
+
+    orderBy(fields: keyof Entity): DeleteLimitMethods
+
+}
+
+export interface DeleteWhereMethods<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>
+    ): DeleteOrderByMethods<Tables> & DeleteLimitMethods
+
+}
+
+type C<Tables, T extends string> = isTableReferenced<Tables, Key<T>, Expr<T, unknown, SQL_BOOL>>
+
+export interface DeleteOrderByMethods<Tables> extends DeleteLimitMethods {
+    orderBy<
+        TableRef,
+        Columns extends OrderByStructure<Expr<TableRef, string | unknown, any>>
+    >(
+        ...items: isColumnOkToUse<Tables, Columns>
+    ): DeleteLimitMethods
+}
+
+
+export interface DeleteLimitMethods {
+    noLimit(): ExecDeleteMethods
+
+    limit(limit: number | [number, number]): ExecDeleteMethods
+
+    limit1(): ExecDeleteMethods
+}
+
+
+export interface ExecDeleteMethods extends SqlQuery<{ affectedRows: number }> {
+
+    toString(lvl?: number): string
+
+}
+

package/src/escape.ts

@@ -1,52 +1,52 @@
-import {PrepareQueryArgument} from "./Types";
-import sql from "sqlstring";
-
-export function escape(value: string | number | (string | number)[] | PrepareQueryArgument): string {
-    return (sql as any).escape(value);
-}
-
-const mysqlReservedKeywords = new Set([
-    "ADD", "ALL", "ALTER", "ANALYZE", "AND", "AS", "ASC", "AUTO_INCREMENT",
-    "BETWEEN", "BIGINT", "BINARY", "BLOB", "BOTH", "BY", "CALL", "CASCADE",
-    "CASE", "CHANGE", "CHAR", "CHARACTER", "CHECK", "COLLATE", "COLUMN",
-    "CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS",
-    "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR",
-    "DATABASE", "DATABASES", "DAY_HOUR", "DAY_MICROSECOND", "DAY_MINUTE",
-    "DAY_SECOND", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DELAYED", "DELETE",
-    "DESC", "DESCRIBE", "DETERMINISTIC", "DISTINCT", "DISTINCTROW", "DIV",
-    "DOUBLE", "DROP", "DUAL", "EACH", "ELSE", "ELSEIF", "ENCLOSED", "ESCAPED",
-    "EXISTS", "EXIT", "EXPLAIN", "FALSE", "FETCH", "FLOAT", "FLOAT4", "FLOAT8",
-    "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT", "GRANT", "GROUP", "HAVING",
-    "HIGH_PRIORITY", "HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "IF",
-    "IGNORE", "IN", "INDEX", "INFILE", "INNER", "INOUT", "INSENSITIVE", "INSERT",
-    "INT", "INT1", "INT2", "INT3", "INT4", "INT8", "INTEGER", "INTERVAL", "INTO",
-    "IS", "ITERATE", "JOIN", "KEY", "KEYS", "KILL", "LEADING", "LEAVE", "LEFT",
-    "LIKE", "LIMIT", "LINES", "LOAD", "LOCALTIME", "LOCALTIMESTAMP", "LOCK", "LONG",
-    "LONGBLOB", "LONGTEXT", "LOOP", "LOW_PRIORITY", "MATCH", "MEDIUMBLOB",
-    "MEDIUMINT", "MEDIUMTEXT", "MIDDLEINT", "MINUTE_MICROSECOND", "MINUTE_SECOND",
-    "MOD", "MODIFIES", "NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL", "NUMERIC",
-    "ON", "OPTIMIZE", "OPTION", "OPTIONALLY", "OR", "ORDER", "OUT", "OUTER",
-    "OUTFILE", "PRECISION", "PRIMARY", "PROCEDURE", "PURGE", "RANGE", "READ",
-    "READS", "REAL", "REFERENCES", "REGEXP", "RELEASE", "RENAME", "REPEAT",
-    "REPLACE", "REQUIRE", "RESTRICT", "RETURN", "REVOKE", "RIGHT", "RLIKE",
-    "SCHEMA", "SCHEMAS", "SECOND_MICROSECOND", "SELECT", "SENSITIVE", "SEPARATOR",
-    "SET", "SHOW", "SMALLINT", "SPATIAL", "SPECIFIC", "SQL", "SQLEXCEPTION",
-    "SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT",
-    "SSL", "STARTING", "STRAIGHT_JOIN", "TABLE", "TERMINATED", "THEN", "TINYBLOB",
-    "TINYINT", "TINYTEXT", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION",
-    "UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "UTC_DATE",
-    "UTC_TIME", "UTC_TIMESTAMP", "VALUES", "VARBINARY", "VARCHAR", "VARCHARACTER",
-    "VARYING", "WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "YEAR_MONTH",
-    "ZEROFILL", "ROWS"
-]);
-
-export function escapeId(value: string): string {
-    // We could skip/remove this check, but it makes prettier SQL queries as 99% of strings here do not need escaping.
-    if (typeof value === "string"
-        && /^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)
-        && !mysqlReservedKeywords.has(value.toUpperCase())) {
-        return value;
-    } else {
-        return (sql as any).escapeId(value);
-    }
+import {PrepareQueryArgument} from "./Types";
+import sql from "sqlstring";
+
+export function escape(value: string | number | (string | number)[] | PrepareQueryArgument): string {
+    return (sql as any).escape(value);
+}
+
+const mysqlReservedKeywords = new Set([
+    "ADD", "ALL", "ALTER", "ANALYZE", "AND", "AS", "ASC", "AUTO_INCREMENT",
+    "BETWEEN", "BIGINT", "BINARY", "BLOB", "BOTH", "BY", "CALL", "CASCADE",
+    "CASE", "CHANGE", "CHAR", "CHARACTER", "CHECK", "COLLATE", "COLUMN",
+    "CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS",
+    "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR",
+    "DATABASE", "DATABASES", "DAY_HOUR", "DAY_MICROSECOND", "DAY_MINUTE",
+    "DAY_SECOND", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DELAYED", "DELETE",
+    "DESC", "DESCRIBE", "DETERMINISTIC", "DISTINCT", "DISTINCTROW", "DIV",
+    "DOUBLE", "DROP", "DUAL", "EACH", "ELSE", "ELSEIF", "ENCLOSED", "ESCAPED",
+    "EXISTS", "EXIT", "EXPLAIN", "FALSE", "FETCH", "FLOAT", "FLOAT4", "FLOAT8",
+    "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT", "GRANT", "GROUP", "HAVING",
+    "HIGH_PRIORITY", "HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "IF",
+    "IGNORE", "IN", "INDEX", "INFILE", "INNER", "INOUT", "INSENSITIVE", "INSERT",
+    "INT", "INT1", "INT2", "INT3", "INT4", "INT8", "INTEGER", "INTERVAL", "INTO",
+    "IS", "ITERATE", "JOIN", "KEY", "KEYS", "KILL", "LEADING", "LEAVE", "LEFT",
+    "LIKE", "LIMIT", "LINES", "LOAD", "LOCALTIME", "LOCALTIMESTAMP", "LOCK", "LONG",
+    "LONGBLOB", "LONGTEXT", "LOOP", "LOW_PRIORITY", "MATCH", "MEDIUMBLOB",
+    "MEDIUMINT", "MEDIUMTEXT", "MIDDLEINT", "MINUTE_MICROSECOND", "MINUTE_SECOND",
+    "MOD", "MODIFIES", "NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL", "NUMERIC",
+    "ON", "OPTIMIZE", "OPTION", "OPTIONALLY", "OR", "ORDER", "OUT", "OUTER",
+    "OUTFILE", "PRECISION", "PRIMARY", "PROCEDURE", "PURGE", "RANGE", "READ",
+    "READS", "REAL", "REFERENCES", "REGEXP", "RELEASE", "RENAME", "REPEAT",
+    "REPLACE", "REQUIRE", "RESTRICT", "RETURN", "REVOKE", "RIGHT", "RLIKE",
+    "SCHEMA", "SCHEMAS", "SECOND_MICROSECOND", "SELECT", "SENSITIVE", "SEPARATOR",
+    "SET", "SHOW", "SMALLINT", "SPATIAL", "SPECIFIC", "SQL", "SQLEXCEPTION",
+    "SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT",
+    "SSL", "STARTING", "STRAIGHT_JOIN", "TABLE", "TERMINATED", "THEN", "TINYBLOB",
+    "TINYINT", "TINYTEXT", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION",
+    "UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "UTC_DATE",
+    "UTC_TIME", "UTC_TIMESTAMP", "VALUES", "VARBINARY", "VARCHAR", "VARCHARACTER",
+    "VARYING", "WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "YEAR_MONTH",
+    "ZEROFILL", "ROWS"
+]);
+
+export function escapeId(value: string): string {
+    // We could skip/remove this check, but it makes prettier SQL queries as 99% of strings here do not need escaping.
+    if (typeof value === "string"
+        && /^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)
+        && !mysqlReservedKeywords.has(value.toUpperCase())) {
+        return value;
+    } else {
+        return (sql as any).escapeId(value);
+    }
 }

package/src/index.ts

@@ -1,6 +1,6 @@
-export * from './SQL';
-export * from './SqlFunctions';
-export * from './SqlExpression';
-export * from './Types';
-export * from './MysqlTable';
+export * from './SQL';
+export * from './SqlFunctions';
+export * from './SqlExpression';
+export * from './Types';
+export * from './MysqlTable';
 export * from './MysqlTableStructureParser';

package/src/insert/InsertBuilder.ts

@@ -1,76 +1,76 @@
-import {escape, escapeId} from "../escape";
-import {ExecInsertMethods, InsertSetMethods} from "./InsertInterfaces";
-import {SQL_ENTITY, SQL_EXPRESSION} from "../Symbols";
-
-export class InsertBuilder<Entity> implements ExecInsertMethods, InsertSetMethods<Entity> {
-
-    public readonly [SQL_ENTITY]: undefined; // never used
-
-    private _ignore: boolean = false;
-    private _tableName: string;
-
-    private _set: string[] = []
-
-    private _valueNames: Set<string>;
-    private _valuesObjects: any[];
-
-    private _select: string;
-
-
-    public to(tableName: string) {
-        this._tableName = tableName;
-        return this;
-    }
-
-    public ignore() {
-        this._ignore = true;
-        return this;
-    }
-
-    public select(query: any) {
-        this._select = query[SQL_EXPRESSION];
-        return this;
-    }
-
-    public set(obj: any) {
-        for (const prop in obj) {
-            this._set.push(escapeId(prop) + " = " + escape(obj[prop]));
-        }
-        return this;
-    }
-
-    public values(objects: any[]) {
-        this._valueNames = new Set();
-        for (let i = 0; i < objects.length; i++) {
-            for (const prop in objects[i]) {
-                this._valueNames.add(prop);
-            }
-        }
-        this._valuesObjects = objects;
-        return this;
-    }
-
-    private toValuesString() {
-        const valueNames = Array.from(this._valueNames.values());
-        const fields = "(" + valueNames.map(e => escapeId(e)).join(", ") + ") VALUES \n";
-        const cols: string[] = [];
-        for (let i = 0; i < this._valuesObjects.length; i++) {
-            const obj = this._valuesObjects[i];
-            const col: string[] = [];
-            for (let v = 0; v < valueNames.length; v++) {
-                const value = obj[valueNames[v]];
-                col.push(value === undefined ? "NULL" : escape(value))
-            }
-            cols.push("(" + col.join(", ") + ")");
-            col.length = 0;
-        }
-        return fields + cols.join(",\n");
-    }
-
-    public toSqlString() {
-        return "INSERT " + (this._ignore ? "IGNORE " : "") + "INTO " + this._tableName + " " +
-            (this._set.length > 0 ? "SET \n " + this._set.join(",\n") + "\n" : "") +
-            (this._valueNames?.size > 0 ? "" + this.toValuesString() : "") +
-            (this._select ? this._select : "")
-    }
+import {escape, escapeId} from "../escape";
+import {ExecInsertMethods, InsertSetMethods} from "./InsertInterfaces";
+import {SQL_ENTITY, SQL_EXPRESSION} from "../Symbols";
+
+export class InsertBuilder<Entity> implements ExecInsertMethods, InsertSetMethods<Entity> {
+
+    public readonly [SQL_ENTITY]: undefined; // never used
+
+    private _ignore: boolean = false;
+    private _tableName: string;
+
+    private _set: string[] = []
+
+    private _valueNames: Set<string>;
+    private _valuesObjects: any[];
+
+    private _select: string;
+
+
+    public to(tableName: string) {
+        this._tableName = tableName;
+        return this;
+    }
+
+    public ignore() {
+        this._ignore = true;
+        return this;
+    }
+
+    public select(query: any) {
+        this._select = query[SQL_EXPRESSION];
+        return this;
+    }
+
+    public set(obj: any) {
+        for (const prop in obj) {
+            this._set.push(escapeId(prop) + " = " + escape(obj[prop]));
+        }
+        return this;
+    }
+
+    public values(objects: any[]) {
+        this._valueNames = new Set();
+        for (let i = 0; i < objects.length; i++) {
+            for (const prop in objects[i]) {
+                this._valueNames.add(prop);
+            }
+        }
+        this._valuesObjects = objects;
+        return this;
+    }
+
+    private toValuesString() {
+        const valueNames = Array.from(this._valueNames.values());
+        const fields = "(" + valueNames.map(e => escapeId(e)).join(", ") + ") VALUES \n";
+        const cols: string[] = [];
+        for (let i = 0; i < this._valuesObjects.length; i++) {
+            const obj = this._valuesObjects[i];
+            const col: string[] = [];
+            for (let v = 0; v < valueNames.length; v++) {
+                const value = obj[valueNames[v]];
+                col.push(value === undefined ? "NULL" : escape(value))
+            }
+            cols.push("(" + col.join(", ") + ")");
+            col.length = 0;
+        }
+        return fields + cols.join(",\n");
+    }
+
+    public toSqlString() {
+        return "INSERT " + (this._ignore ? "IGNORE " : "") + "INTO " + this._tableName + " " +
+            (this._set.length > 0 ? "SET \n " + this._set.join(",\n") + "\n" : "") +
+            (this._valueNames?.size > 0 ? "" + this.toValuesString() : "") +
+            (this._select ? this._select : "")
+    }
 }

package/src/insert/InsertInterfaces.ts

@@ -1,16 +1,16 @@
-import {AliasedTable, IsAMatchingB, NotUsingWithPart, SqlQuery} from "../Types";
-
-export interface ExecInsertMethods extends SqlQuery<{ insertId: number }> {
-
-}
-
-export interface InsertSetMethods<Entity> {
-
-    set(value: Entity): ExecInsertMethods
-
-    values(value: Entity[]): ExecInsertMethods
-
-    select<Result>(value: IsAMatchingB<Result, Entity, AliasedTable<string, string, Result, object, NotUsingWithPart>>): ExecInsertMethods
-}
-
-
+import {AliasedTable, IsAMatchingB, NotUsingWithPart, SqlQuery} from "../Types";
+
+export interface ExecInsertMethods extends SqlQuery<{ insertId: number }> {
+
+}
+
+export interface InsertSetMethods<Entity> {
+
+    set(value: Entity): ExecInsertMethods
+
+    values(value: Entity[]): ExecInsertMethods
+
+    select<Result>(value: IsAMatchingB<Result, Entity, AliasedTable<string, string, Result, object, NotUsingWithPart>>): ExecInsertMethods
+}
+
+