@grest-ts/sql 0.0.5

package/src/MysqlTableStructureParser.ts

@@ -0,0 +1,283 @@
+import {escape} from "./escape";
+
+export class MysqlTableStructureParser {
+
+    public static getSchemaRowsQuery(database: string): string {
+        return "SELECT " +
+            "   table_schema as tableSchema, \n" +
+            "   table_name as tableName, \n" +
+            "   is_nullable as isNullable, \n" +
+            "   column_default as columnDefault, \n" +
+            "   column_name as columnName, \n" +
+            "   collation_name as collationName, \n" +
+            "   column_type as columnType, \n" +
+            "   column_key as columnKey, \n" +
+            "   ordinal_position as ordinalPosition, \n" +
+            "   character_octet_length as characterOctetLength, \n" +
+            "   numeric_precision as numericPrecision, \n" +
+            "   numeric_scale as numericScale, \n" +
+            "   data_type as dataType, \n" +
+            "   character_maximum_length as characterMaximumLength, \n" +
+            "   datetime_precision as datetimePrecision, \n" +
+            "   character_set_name as characterSetName, \n" +
+            "   extra as extra, \n" +
+            "   column_comment as columnComment \n" +
+            "FROM INFORMATION_SCHEMA.columns \n" +
+            "WHERE table_schema LIKE " + escape(database) + " " +
+            "ORDER BY table_schema, table_name, ordinal_position ";
+    }
+
+    public static parse(schema: SchemaRow[]): TableStructure[] {
+        const tables: Map<string, TableStructure> = new Map()
+        for (const row of schema) {
+            if (!tables.has(row.tableName)) {
+                tables.set(row.tableName, {name: row.tableName, columns: []})
+            }
+            tables.get(row.tableName).columns.push(this.parseColumn(row));
+        }
+        return Array.from(tables.values()).sort((a, b) => a.name >= b.name ? 1 : -1);
+    }
+
+    private static parseColumn(row: SchemaRow): AnyColumn {
+        const type = row.dataType.toUpperCase() as ColumnDataType;
+        const column: Column = {
+            type: type,
+            name: row.columnName,
+            dataType: row.dataType.toUpperCase(),
+            columnType: row.columnType,
+            tsType: MYSQL_TYPE_TO_TS_TYPE.get(type),
+            isNullable: row.isNullable.toUpperCase().indexOf("YES") >= 0,
+            default: this.parseDefault(row.columnDefault),
+            columnKey: this.parseColumnKey(row.columnKey),
+            extra: row.extra,
+            comment: row.columnComment
+        };
+        if (type === ColumnDataType.MEDIUMTEXT || type === ColumnDataType.TEXT || type === ColumnDataType.LONGTEXT) {
+            const res: ColumnText = {
+                ...column,
+                type: type,
+                characterSetName: row.characterSetName,
+                collationName: row.collationName
+            }
+            return res;
+
+        } else if (type === ColumnDataType.CHAR || type === ColumnDataType.VARCHAR) {
+            const res: ColumnChar = {
+                ...column,
+                type: type,
+                characterSetName: row.characterSetName,
+                collationName: row.collationName,
+                characterMaximumLength: row.characterMaxLength,
+                characterOctetLength: row.characterOctetLength
+            }
+            return res;
+
+        } else if (type === ColumnDataType.TINYINT || type === ColumnDataType.SMALLINT || type === ColumnDataType.INT || type === ColumnDataType.MEDIUMINT
+            || type === ColumnDataType.BIGINT || type === ColumnDataType.DECIMAL || type === ColumnDataType.FLOAT || type === ColumnDataType.BIT) {
+            const typeNum = Number(row.columnType.split("(").pop().split(")").shift());
+            const res: ColumnNumber = {
+                ...column,
+                type: type,
+                typeNum: isNaN(typeNum) ? undefined : typeNum,
+                scale: row.numericScale,
+                precision: row.numericPos,
+                isUnsigned: row.columnType.toUpperCase().indexOf("UNSIGNED") >= 0,
+                isAutoIncrement: row.extra.toUpperCase().indexOf("AUTO_INCREMENT") >= 0
+            }
+            return res;
+
+        } else if (type === ColumnDataType.ENUM) {
+            const res: ColumnEnum = {
+                ...column,
+                type: type,
+                values: row.columnType.match(/'([^']+)'/g).map(e => e.replace(/'/g, "").replace(/"/g, ""))
+            }
+            return res;
+        } else if (type === ColumnDataType.SET) {
+            const res: ColumnSet = {
+                ...column,
+                type: type,
+                values: row.columnType.match(/'([^']+)'/g).map(e => e.replace(/'/g, "").replace(/"/g, ""))
+            }
+            return res;
+        } else {
+            return column as AnyColumn;
+        }
+    }
+
+    private static parseDefault(def: string): string | number {
+        if (!def || def === "NULL") {
+            return null;
+        } else if (!isNaN(Number(def))) {
+            return def;
+        } else {
+            return String(def).split("'").join("");
+        }
+    }
+
+    private static parseColumnKey(columnKey: string): KeyType[] {
+        return columnKey.split(",").map((e) => {
+            const key = e.toUpperCase();
+            if (key === "PRI") {
+                return KeyType.PRIMARY
+            } else if (key === "UNI") {
+                return KeyType.UNIQUE
+            } else if (key === "MUL") {
+                return KeyType.MULTIPLE
+            } else {
+                return null;
+            }
+        }).filter(e => e);
+    }
+}
+
+export interface TableStructure {
+    name: string;
+    columns: AnyColumn[];
+}
+
+export enum ColumnDataType {
+    TINYINT = "TINYINT",
+    SMALLINT = "SMALLINT",
+    MEDIUMINT = "MEDIUMINT",
+    INT = "INT",
+    BIGINT = "BIGINT",
+    DECIMAL = "DECIMAL",
+    FLOAT = "FLOAT",
+    CHAR = "CHAR",
+    VARCHAR = "VARCHAR",
+    MEDIUMTEXT = "MEDIUMTEXT",
+    TEXT = "TEXT",
+    LONGTEXT = "LONGTEXT",
+    TIMESTAMP = "TIMESTAMP",
+    DATETIME = "DATETIME",
+    DATE = "DATE",
+    TIME = "TIME",
+    YEAR = "YEAR",
+    ENUM = "ENUM",
+    SET = "SET",
+    BIT = "BIT",
+    LONGBLOB = "LONGBLOB",
+    JSON = "JSON"
+}
+
+const MYSQL_TYPE_TO_TS_TYPE: Map<ColumnDataType, string> = new Map([
+    [ColumnDataType.TINYINT, "number"],
+    [ColumnDataType.SMALLINT, "number"],
+    [ColumnDataType.MEDIUMINT, "number"],
+    [ColumnDataType.INT, "number"],
+    [ColumnDataType.BIGINT, "number"],
+    [ColumnDataType.DECIMAL, "number"],
+    [ColumnDataType.FLOAT, "number"],
+    [ColumnDataType.CHAR, "string"],
+    [ColumnDataType.VARCHAR, "string"],
+    [ColumnDataType.MEDIUMTEXT, "string"],
+    [ColumnDataType.TEXT, "string"],
+    [ColumnDataType.LONGTEXT, "string"],
+    [ColumnDataType.TIMESTAMP, "string"],
+    [ColumnDataType.DATETIME, "string"],
+    [ColumnDataType.DATE, "string"],
+    [ColumnDataType.TIME, "number"],
+    [ColumnDataType.YEAR, "number"],
+    [ColumnDataType.ENUM, "string"],
+    [ColumnDataType.SET, "string"],
+    [ColumnDataType.BIT, "number"],
+    [ColumnDataType.LONGBLOB, "string"],
+    [ColumnDataType.JSON, "string"]
+])
+
+
+export type AnyColumn = ColumnText | ColumnChar | ColumnNumber | ColumnSet | ColumnEnum | ColumnDateTimeLike
+
+export interface Column {
+    type: ColumnDataType;
+    name: string;
+    tsType: string;
+    dataType: string // Type like INT
+    columnType: string; // Type like INT(11)
+    typeNum?: number | undefined // for INT(11), this would be 11
+    default: string | number;
+    isNullable: boolean;
+    columnKey: KeyType[];
+    extra: string;
+    comment: string;
+}
+
+export interface ColumnDateTimeLike extends Column {
+    type: ColumnDataType.DATE |
+        ColumnDataType.DATETIME |
+        ColumnDataType.TIMESTAMP |
+        ColumnDataType.YEAR
+}
+
+export interface ColumnText extends Column {
+    type: ColumnDataType.CHAR |
+        ColumnDataType.VARCHAR |
+        ColumnDataType.MEDIUMTEXT |
+        ColumnDataType.TEXT |
+        ColumnDataType.LONGTEXT;
+    characterSetName: string;
+    collationName: string;
+}
+
+export interface ColumnChar extends ColumnText {
+    type: ColumnDataType.VARCHAR |
+        ColumnDataType.CHAR;
+    characterMaximumLength: number;
+    characterOctetLength: number;
+}
+
+export interface ColumnNumber extends Column {
+    type:
+        ColumnDataType.TINYINT |
+        ColumnDataType.SMALLINT |
+        ColumnDataType.MEDIUMINT |
+        ColumnDataType.INT |
+        ColumnDataType.BIGINT |
+        ColumnDataType.DECIMAL |
+        ColumnDataType.FLOAT |
+        ColumnDataType.BIT
+    isUnsigned: boolean;
+    isAutoIncrement: boolean;
+    precision: number;
+    scale: number;
+}
+
+export interface ColumnEnum extends Column {
+    type: ColumnDataType.ENUM;
+    values: string[];
+}
+
+export interface ColumnSet extends Column {
+    type: ColumnDataType.SET;
+    values: string[];
+}
+
+export enum KeyType {
+    PRIMARY = "primary",
+    UNIQUE = "unique",
+    MULTIPLE = "multiple"
+}
+
+interface SchemaRow {
+    tableSchema: string;
+    tableName: string;
+    columnName: string;
+    ordinalPosition: number;
+    columnDefault: string;
+    isNullable: string;
+    dataType: string;
+    characterMaxLength: number;
+    characterOctetLength: number;
+    numericPos: number;
+    numericScale: number;
+    dateTimePrecision: number;
+    characterSetName: string;
+    collationName: string;
+    columnType: string;
+    columnKey: string;
+    extra: string;
+    columnComment: string;
+    isGenerated: string;
+    generationExpression: string;
+}

package/src/SQL.ts

@@ -0,0 +1,244 @@
+import {SelectBuilder} from "./select/SelectBuilder";
+import {AliasedTable, DbTableDefinition, Key, NotUsingWithPart, PrepareQueryArgument, SqlQuery} from "./Types";
+import {SQL_ALIAS, SQL_ENTITY, SQL_EXPRESSION} from "./Symbols";
+import {escape, escapeId} from "./escape";
+import {MysqlTable} from "./MysqlTable";
+import {JoinMethods} from "./select/parts/S1Join";
+import {UsesMethods} from "./select/parts/S0Uses";
+import {WithMethods} from "./select/parts/S0With";
+import {ExecMethods} from "./select/parts/S7Exec";
+import {DeleteBuilder} from "./delete/DeleteBuilder";
+import {DeleteWhereMethods} from "./delete/DeleteInterfaces";
+import {InsertBuilder} from "./insert/InsertBuilder";
+import {InsertSetMethods} from "./insert/InsertInterfaces";
+import {UpdateSetMethods} from "./update/UpdateInterfaces";
+import {UpdateBuilder} from "./update/UpdateBuilder";
+
+export class SQL {
+
+
+    public static insertInto<
+        Entity,
+        EditEntity,
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, Entity, EditEntity, NotUsingWithPart>): InsertSetMethods<EditEntity> {
+        return new InsertBuilder().to(table[SQL_EXPRESSION]);
+    }
+
+    public static insertIgnoreInto<
+        Entity,
+        EditEntity,
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, Entity, EditEntity, NotUsingWithPart>
+    ): InsertSetMethods<EditEntity> {
+        return new InsertBuilder().to(table[SQL_EXPRESSION]).ignore();
+    }
+
+    public static update<
+        Entity,
+        EditEntity,
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, Entity, EditEntity, NotUsingWithPart>
+    ): UpdateSetMethods<Entity, Key<TableRef>> {
+        return new UpdateBuilder().in(table[SQL_EXPRESSION], table[SQL_ALIAS]);
+    }
+
+    public static updateIgnore<
+        Entity,
+        EditEntity,
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, Entity, EditEntity, NotUsingWithPart>
+    ): UpdateSetMethods<Entity, Key<TableRef>> {
+        return new UpdateBuilder().in(table[SQL_EXPRESSION], table[SQL_ALIAS]).ignore()
+    }
+
+    public static deleteFrom<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+    >(
+        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
+    ): DeleteWhereMethods<Key<TableRef>> {
+        return new DeleteBuilder().from(table[SQL_EXPRESSION], table[SQL_ALIAS]);
+    }
+
+    public static selectFrom<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`
+    >(
+        table: AliasedTable<Alias, TableRef, object, object, string | NotUsingWithPart>
+    ): JoinMethods<Key<Alias>, {}, Key<TableRef>> {
+        return new SelectBuilder().selectFrom(table)
+    }
+
+    /**
+     * Start building a select query that most probably will be used as a scalar subquery.
+     *
+     * for example:
+     * SELECT
+     *    (SELECT id FROM child WHERE child.id = parent.id ) <--- scalar subquery
+     * FROM parent
+     *
+     * In the uses part you add parent table refererence.
+     */
+    public static uses<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>
+    ): UsesMethods<Key<Alias1>, Key<TableRef1>>
+    public static uses<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+    ): UsesMethods<Key<Alias1> & Key<Alias2>, Key<TableRef1> & Key<TableRef2>>
+    public static uses<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+        Alias3 extends string, TableRef3 extends `${string} as ${Alias3}`
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+        table3: AliasedTable<Alias3, TableRef3, object, object, NotUsingWithPart>,
+    ): UsesMethods<Key<Alias1> & Key<Alias2> & Key<Alias3>, Key<TableRef1> & Key<TableRef2> & Key<TableRef3>>
+    public static uses<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+        Alias3 extends string, TableRef3 extends `${string} as ${Alias3}`,
+        Alias4 extends string, TableRef4 extends `${string} as ${Alias4}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+        table3: AliasedTable<Alias3, TableRef3, object, object, NotUsingWithPart>,
+        table4: AliasedTable<Alias4, TableRef4, object, object, NotUsingWithPart>,
+    ): UsesMethods<Key<Alias1> & Key<Alias2> & Key<Alias3> & Key<Alias4>, Key<TableRef1> & Key<TableRef2> & Key<TableRef3> & Key<TableRef4>>
+    public static uses(table1: any, table2?: any, table3?: any, table4?: any) {
+        return new SelectBuilder();
+    }
+
+    /**
+     * Start building a select query that uses WITH queries.
+     *
+     * for example:
+     * WITH user2 AS (
+     *      SELECT id FROM user <-- this query AliasedTable is argument to this method. ( SQL.select()...as("user2") )
+     * )
+     * SELECT *
+     * FROM user2
+     *
+     * With a
+     */
+    public static with<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>
+    ): WithMethods<Key<Alias1>>
+    public static with<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+    ): WithMethods<Key<Alias1> & Key<Alias2>>
+    public static with<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+        Alias3 extends string, TableRef3 extends `${string} as ${Alias3}`
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+        table3: AliasedTable<Alias3, TableRef3, object, object, NotUsingWithPart>,
+    ): WithMethods<Key<Alias1> & Key<Alias2> & Key<Alias3>>
+    public static with<
+        Alias1 extends string, TableRef1 extends `${string} as ${Alias1}`,
+        Alias2 extends string, TableRef2 extends `${string} as ${Alias2}`,
+        Alias3 extends string, TableRef3 extends `${string} as ${Alias3}`,
+        Alias4 extends string, TableRef4 extends `${string} as ${Alias4}`,
+    >(
+        table1: AliasedTable<Alias1, TableRef1, object, object, NotUsingWithPart>,
+        table2: AliasedTable<Alias2, TableRef2, object, object, NotUsingWithPart>,
+        table3: AliasedTable<Alias3, TableRef3, object, object, NotUsingWithPart>,
+        table4: AliasedTable<Alias4, TableRef4, object, object, NotUsingWithPart>,
+    ): WithMethods<Key<Alias1> & Key<Alias2> & Key<Alias3> & Key<Alias4>>
+    public static with(...tables: any[]) {
+        return new SelectBuilder().with(...tables);
+    }
+
+    /**
+     * Creates a prepared query.
+     *
+     * Prepared query is a fixed query that will be prebuilt for higher performance. It will only replace arguments in a prebuilt SQL query string.
+     * Main drawback of this is that query has to be static and can't have anything dynamic in it.
+     *
+     * This is not Mysql prepared statement, it is only preparing and caching a string of the SQL query.
+     *
+     * Usage
+     *
+     * const prepared = SQL.prepare( ( args:{id: number} ) => {
+     *     const c = MyDb.user("c");
+     *     return SQL.select().from(c)...where( c.id.eq(args.id).noLimit()
+     * })
+     *
+     * exec(prepared({id: 10}))
+     *
+     */
+    public static prepare<PrepareQueryArguments extends { [key: string]: any }, Result>(func: (args: PrepareQueryArguments) => ExecMethods<Result>): (args: PrepareQueryArguments) => SqlQuery<Result> {
+        let sqlQuery: string = undefined;
+        const seenArguments: Map<string, string> = new Map();
+        const getSqlString = () => {
+            if (sqlQuery === undefined) {
+                const p: PrepareQueryArguments = new Proxy({}, {
+                    get(_: {}, p: string): PrepareQueryArgument {
+                        if (!/^[A-Za-z]+$/.test(p)) {
+                            throw new Error("Invalid prepare query argument named '" + p + "'. Can only contain ascii letters!")
+                        }
+                        const variable = "<<|_arg:|>>" + p + "<<|:_arg|>>";
+                        seenArguments.set(p, variable);
+                        return {__prepare_argument: true, expression: variable};
+                    }
+                }) as any
+                sqlQuery = func(p).toSqlString();
+            }
+            return sqlQuery;
+        }
+        return (args: PrepareQueryArguments) => {
+            return {
+                [SQL_ENTITY]: undefined,
+                toSqlString: (): string => {
+                    let usedQuery = getSqlString();
+                    seenArguments.forEach((variable, key) => {
+                        usedQuery = usedQuery.replace(variable, escape(args[key]));
+                    })
+                    return usedQuery
+                },
+            }
+        }
+    }
+
+    /**
+     * Create a reference for a query that is used in WITH part and you want to use it in from(X) or join(X) call.
+     */
+    public static createRef<
+        Alias extends string,
+        TableRef extends `${string} as ${Alias}`,
+        Entity,
+        EditEntity,
+        NewAlias extends string
+    >(table: AliasedTable<Alias, TableRef, Entity, EditEntity, NotUsingWithPart>, newAlias: NewAlias): AliasedTable<NewAlias, `${Alias} as ${NewAlias}`, Entity, EditEntity, Alias> {
+        const definition: DbTableDefinition<Entity> = {} as any;
+        for (const k in table) {
+            (definition as any)[k] = (table as any)[k];
+        }
+        return MysqlTable.defineDbTable(escapeId(table[SQL_ALIAS]), newAlias, definition) as any;
+    }
+
+}
+