@entity-access/entity-access 1.0.1

package/src/drivers/sql-server/SqlServerDriver.ts

@@ -0,0 +1,215 @@
+/* eslint-disable no-console */
+import QueryCompiler from "../../compiler/QueryCompiler.js";
+import Migrations from "../../migrations/Migrations.js";
+import { BaseDriver, IDbConnectionString, IDbReader, IQuery, IRecord, disposableSymbol, toQuery } from "../base/BaseDriver.js";
+import sql from "mssql";
+import SqlServerQueryCompiler from "./SqlServerQueryCompiler.js";
+import SqlServerSqlMethodTransformer from "../../compiler/sql-server/SqlServerSqlMethodTransformer.js";
+import SqlServerAutomaticMigrations from "../../migrations/sql-server/SqlServerAutomaticMigrations.js";
+import { SqlServerLiteral } from "./SqlServerLiteral.js";
+import usingAsync from "../../common/usingAsync.js";
+import TimedCache from "../../common/cache/TimedCache.js";
+
+export type ISqlServerConnectionString = sql.config;
+
+const namedPool = new TimedCache<string, sql.ConnectionPool>();
+
+export default class SqlServerDriver extends BaseDriver {
+
+    get compiler(): QueryCompiler {
+        return this.sqlQueryCompiler;
+    }
+
+    private sqlQueryCompiler = new SqlServerQueryCompiler();
+    private transaction: sql.Transaction;
+
+    constructor(private readonly config: ISqlServerConnectionString) {
+        super({
+            database: config.database,
+            host: config.server ??= (config as any).host,
+            port: config.port,
+            password: config.password,
+            user: config.user,
+            ... config,
+        });
+    }
+
+    public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
+        command = toQuery(command);
+        let rq = await this.newRequest();
+
+        if (command) {
+            let id = 1;
+            for (const iterator of command.values) {
+                command.text = command.text.replace(/\$/, "@p");
+                rq = rq.input("p" + id++, iterator);
+            }
+        }
+
+        return new SqlReader(rq, command);
+    }
+    public async executeQuery(command: IQuery, signal?: AbortSignal): Promise<any> {
+        let rq = await this.newRequest();
+        command = toQuery(command);
+
+        if (command) {
+            let id = 1;
+            for (const iterator of command.values) {
+                command.text = command.text.replace(/\$/, "@p");
+                rq = rq.input(`p${id++}`, iterator);
+            }
+        }
+
+        try {
+            console.log(command.text);
+            const r = await rq.query(command.text);
+            return { rows: r.recordset ?? [r.output], updated: r.rowsAffected [0]};
+        } catch (error) {
+            error = `Failed executing ${command.text}\r\n${error.stack ?? error}`;
+            console.error(error);
+            throw new Error(error);
+        }
+    }
+
+    public ensureDatabase() {
+        const create = async () => {
+            const defaultDb = "master";
+
+            const db = this.config.database;
+            this.config.database = defaultDb;
+
+            const connection = await this.newRequest();
+            // @ts-expect-error readonly
+            this.config = { ... this.config };
+            this.config.database = db;
+
+            const createSql = `IF NOT EXISTS (SELECT name FROM master.dbo.sysdatabases WHERE name = ${SqlServerLiteral.escapeLiteral(db)}) BEGIN
+                CREATE DATABASE ${db};
+            END`;
+            try {
+                await connection.query(createSql);
+            } catch(error) {
+                throw new Error(`Failed executing: ${createSql}\r\n${error.stack ?? error}`);
+            }
+        };
+        const value = create();
+        Object.defineProperty(this, "ensureDatabase", {
+            value: () => value,
+        });
+        return value;
+    }
+
+    public async runInTransaction<T = any>(fx?: () => Promise<T>): Promise<T> {
+        this.transaction = new sql.Transaction(await this.newConnection());
+        let rolledBack = false;
+        try {
+            this.transaction.on("rollback", (aborted) => rolledBack = aborted);
+            await this.transaction.begin();
+            const r = await fx();
+            await this.transaction.commit();
+            return r;
+        } catch (error) {
+            if (!rolledBack) {
+                try {
+                    await this.transaction.rollback();
+                } catch {
+                    // rolledBack isn't true sometimes...
+                }
+            }
+            throw new Error(error.stack ?? error);
+        } finally {
+            this.transaction = void 0;
+        }
+    }
+
+    public automaticMigrations(): Migrations {
+        return new SqlServerAutomaticMigrations();
+    }
+
+    protected async newRequest() {
+
+        if (this.transaction) {
+            return this.transaction.request();
+        }
+        return (await this.newConnection()).request();
+    }
+
+    private newConnection() {
+        const key = this.config.server + "//" + this.config.database + "/" + this.config.user;
+        return namedPool.getOrCreateAsync(this.config.server + "://" + this.config.database,
+            () => {
+                const pool = new sql.ConnectionPool(this.config);
+                const oldClose = pool.close;
+                pool.close = ((c) => {
+                    namedPool.delete(key);
+                    return oldClose.call(pool, c);
+                }) as any;
+                return pool.connect();
+            }, 15000, (x) => x.close());
+
+    }
+
+}
+
+class SqlReader implements IDbReader {
+
+    private pending: any[] = [];
+    private error: any = null;
+    private count: number = 0;
+    private ended = false;
+    private processPendingRows: (... a: any[]) => any;
+
+    constructor(
+        private rq: sql.Request,
+        private command: { text: string, values?: any[]}) {}
+
+    async *next(min?: number, s?: AbortSignal) {
+        const command = this.command;
+        const rq = this.rq;
+        s?.addEventListener("abort", () => {
+            rq.cancel();
+        });
+
+        rq.stream = true;
+
+        rq.on("row", (row) => {
+            this.pending.push(row);
+            this.count++;
+            this.processPendingRows();
+        });
+
+        rq.on("error", (e) => {
+            this.error = new Error(`Failed executing ${command.text}\r\n${e.stack ?? e}`);
+            this.processPendingRows();
+        });
+
+        rq.on("done", () => {
+            this.ended = true;
+            this.processPendingRows();
+        });
+
+        console.log(`Executing ${(command as any).text}`);
+        void rq.query((command as any).text);
+
+        do {
+            if (this.pending.length > 0){
+                const copy = this.pending;
+                this.pending = [];
+                yield *copy;
+            }
+            if (this.ended) {
+                break;
+            }
+            await new Promise<any>((resolve, reject) => {
+                this.processPendingRows = resolve;
+            });
+        }  while(true);
+    }
+    dispose(): Promise<any> {
+        return Promise.resolve();
+    }
+    [disposableSymbol]?(): void {
+        this.dispose()?.catch((error) => console.error(error));
+    }
+
+}

package/src/drivers/sql-server/SqlServerLiteral.ts

@@ -0,0 +1,12 @@
+const escapeLiteral = (name: string) => {
+    name = JSON.stringify(name).replace(/\'/g, "\\'");
+    return `N'${name.substring(1, name.length - 1)}'`;
+};
+
+const quotedLiteral = (name: string) => `[${name}]`;
+
+export const SqlServerLiteral = {
+
+    escapeLiteral,
+    quotedLiteral
+};

package/src/drivers/sql-server/SqlServerQueryCompiler.ts

@@ -0,0 +1,25 @@
+import QueryCompiler from "../../compiler/QueryCompiler.js";
+import SqlServerSqlMethodTransformer from "../../compiler/sql-server/SqlServerSqlMethodTransformer.js";
+import ArrowToExpression from "../../query/parser/ArrowToExpression.js";
+import ExpressionToSqlServer from "./ExpressionToSqlServer.js";
+import { SqlServerLiteral } from "./SqlServerLiteral.js";
+
+export default class SqlServerQueryCompiler extends QueryCompiler {
+
+    constructor({
+        arrowToExpression = ArrowToExpression,
+        expressionToSql = ExpressionToSqlServer,
+        quotedLiteral = SqlServerLiteral.quotedLiteral,
+        escapeLiteral = SqlServerLiteral.escapeLiteral,
+        sqlMethodTransformer = SqlServerSqlMethodTransformer
+    }: Partial<QueryCompiler> = {}) {
+        super({
+            arrowToExpression,
+            expressionToSql,
+            quotedLiteral,
+            escapeLiteral,
+            sqlMethodTransformer
+        });
+    }
+
+}

package/src/entity-query/EntityType.ts

@@ -0,0 +1,116 @@
+import type { IColumn, IEntityRelation } from "../decorators/IColumn.js";
+import { IClassOf } from "../decorators/IClassOf.js";
+import { Query } from "../query/Query.js";
+import NameParser from "../decorators/parser/MemberParser.js";
+import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import { QuotedLiteral, TableLiteral } from "../query/ast/Expressions.js";
+import InstanceCache from "../common/cache/InstanceCache.js";
+
+
+/**
+ * DbQuery represents sql equivalent table with columns...
+ */
+export default class EntityType {
+
+    public readonly typeClass: IClassOf<any>;
+
+    public readonly name: string;
+    public readonly schema: string;
+
+
+    public readonly columns: IColumn[] = [];
+
+    public readonly relations: IEntityRelation[] = [];
+
+    public readonly keys: IColumn[] = [];
+
+    public readonly nonKeys: IColumn[] = [];
+
+    @InstanceCache
+    public get fullyQualifiedName() {
+        return this.schema
+            ? TableLiteral.create({
+                schema: QuotedLiteral.create({literal: this.schema}) ,
+                name: QuotedLiteral.create({ literal: this.name })
+            })
+            : QuotedLiteral.create({ literal: this.name });
+    }
+
+    private fieldMap: Map<string, IColumn> = new Map();
+    private columnMap: Map<string, IColumn> = new Map();
+    private relationMap: Map<string, IEntityRelation> = new Map();
+
+    public getProperty(name: string) {
+        const field = this.fieldMap.get(name);
+        const relation = this.relationMap.get(name);
+        return { field, relation };
+    }
+
+    public addColumn(c: IColumn) {
+
+        const existing = this.fieldMap.get(c.name);
+        if (existing) {
+            c.fkRelation = existing.fkRelation;
+            c.fkRelation.fkColumn = c;
+        }
+
+        this.fieldMap.set(c.name, c);
+        this.columnMap.set(c.columnName, c);
+        this.columns.push(c);
+        if (c.key) {
+            this.keys.push(c);
+        } else {
+            this.nonKeys.push(c);
+        }
+    }
+
+    public getColumn(name: string) {
+        return this.columnMap.get(name);
+    }
+
+    public getField(name: string) {
+        return this.fieldMap.get(name);
+    }
+
+    addRelation(relation: IEntityRelation) {
+        // we will also set fk to the corresponding column
+        this.relations.push(relation);
+        this.relationMap.set(relation.name, relation);
+
+        // find fk...
+        let fkColumn = this.fieldMap.get(relation.foreignKey);
+        if(!fkColumn) {
+            fkColumn = {
+                name: relation.foreignKey,
+                fkRelation: relation,
+                dataType: "BigInt"
+            };
+            this.fieldMap.set(relation.foreignKey, fkColumn);
+        }
+        fkColumn.fkRelation = relation;
+        relation.fkColumn = fkColumn;
+        if (fkColumn.dataType === "Double") {
+            fkColumn.dataType = "BigInt";
+        }
+
+        // let us set inverse relations...
+        const relatedType = SchemaRegistry.model(relation.relatedTypeClass);
+        relation.relatedEntity = relatedType;
+        const inverseRelation: IEntityRelation = {
+            name: relation.relatedName,
+            foreignKey: "",
+            relatedName: relation.name,
+            relatedTypeClass: this.typeClass,
+            dotNotCreateIndex: true,
+            fkColumn,
+            isCollection: true,
+            relatedRelation: relation,
+            relatedEntity: this
+        };
+        relatedType.relationMap.set(inverseRelation.name, inverseRelation);
+        relatedType.relations.push(inverseRelation);
+        inverseRelation.relatedRelation = relation;
+
+    }
+
+}

package/src/migrations/Migrations.ts

@@ -0,0 +1,17 @@
+import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import EntityType from "../entity-query/EntityType.js";
+import type EntityContext from "../model/EntityContext.js";
+
+export default abstract class Migrations {
+
+    public async migrate(context: EntityContext) {
+        for (const iterator of context.model.entities.keys()) {
+            const type = SchemaRegistry.model(iterator);
+            await this.migrateTable(context, type);
+        }
+    }
+
+    abstract migrateTable(context: EntityContext, type: EntityType): Promise<any>;
+
+
+}

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -0,0 +1,97 @@
+import { IColumn } from "../../decorators/IColumn.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import EntityType from "../../entity-query/EntityType.js";
+import EntityContext from "../../model/EntityContext.js";
+import Migrations from "../Migrations.js";
+import PostgresMigrations from "./PostgresMigrations.js";
+
+export default class PostgresAutomaticMigrations extends PostgresMigrations {
+
+    async migrateTable(context: EntityContext, type: EntityType) {
+
+
+        // create table if not exists...
+        const nonKeyColumns = type.nonKeys;
+        const keys = type.keys;
+
+        const driver = context.driver;
+
+        await this.createTable(driver, type, keys);
+
+        await this.createColumns(driver, type, nonKeyColumns);
+
+        await this.createIndexes(driver, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
+
+    }
+
+    async createIndexes(driver: BaseDriver, type: EntityType, fkColumns: IColumn[]) {
+
+        const name = type.schema
+        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
+        : JSON.stringify(type.name);
+
+        for (const iterator of fkColumns) {
+            const indexName =  JSON.stringify(`IX_${type.name}_${iterator.columnName}`);
+            const columnName = JSON.stringify(iterator.columnName);
+            let query = `CREATE INDEX ${indexName} ON ${name} ( ${columnName})`;
+            if (iterator.nullable !== true) {
+                query += ` WHERE (${columnName} is not null)`;
+            }
+            await driver.executeQuery(query);
+        }
+    }
+
+    async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
+
+        const name = type.schema
+        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
+        : JSON.stringify(type.name);
+
+        if (nonKeyColumns.length > 1) {
+            nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        for (const iterator of nonKeyColumns) {
+            const columnName = JSON.stringify(iterator.columnName);
+            let def = `ALTER TABLE ${name} ADD COLUMN IF NOT EXISTS ${columnName} `;
+            def += this.getColumnDefinition(iterator);
+            if (iterator.nullable !== true) {
+                def += " NOT NULL ";
+            }
+            if (typeof iterator.default === "string") {
+                def += " DEFAULT " + iterator.default;
+            }
+            await driver.executeQuery(def + ";");
+        }
+
+    }
+
+    async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
+
+        const name = type.schema
+            ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
+            : JSON.stringify(type.name);
+
+        if (keys.length > 1) {
+            keys.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        const fields = [];
+
+        for (const iterator of keys) {
+            let def = JSON.stringify(iterator.columnName) + " ";
+            if (iterator.autoGenerate) {
+                def += iterator.dataType === "BigInt" ? "bigserial " : "serial ";
+            } else {
+                def += this.getColumnDefinition(iterator);
+            }
+            def += " not null primary key\r\n\t";
+            fields.push(def);
+        }
+
+        await driver.executeQuery(`CREATE TABLE IF NOT EXISTS ${name} (${fields.join(",")})`);
+
+    }
+
+
+}

package/src/migrations/postgres/PostgresMigrations.ts

@@ -0,0 +1,56 @@
+import { IColumn } from "../../decorators/IColumn.js";
+import Migrations from "../Migrations.js";
+
+export default abstract class PostgresMigrations extends Migrations {
+
+    protected getColumnDefinition(iterator: IColumn) {
+        if (iterator.dataType === "Decimal") {
+            if (iterator.precision && iterator.scale) {
+                return `decimal (${iterator.precision}, ${iterator.scale})`;
+            }
+            return `decimal (18,2)`;
+        }
+        const type = this.getColumnType(iterator);
+        if (iterator.length) {
+            return `${type} (${iterator.length})`;
+        }
+        return type;
+    }
+
+    protected getColumnType(iterator: IColumn) {
+        switch(iterator.dataType) {
+            case "BigInt":
+                return "bigint";
+            case "AsciiChar":
+            case "Char":
+                if (!iterator.length) {
+                    return "text";
+                }
+                return "varchar";
+            case "DateTime":
+                return "timestamp";
+            case "DateTimeOffset":
+                return "timestamp with time zone";
+            case "Double":
+                return "float8";
+            case "Float":
+                return "real";
+            case "Int":
+                return "integer";
+            case "Boolean":
+                return "boolean";
+            case "ByteArray":
+                return "bytea";
+            case "Decimal":
+                return "decimal";
+            case "JSON":
+                return "json";
+            case "JSONB":
+                return "jsonb";
+            case "UUID":
+                return "uuid";
+        }
+        const a: never = iterator.dataType;
+        throw new Error("Not Defined");
+    }
+}

package/src/migrations/sql-server/SqlServerAutomaticMigrations.ts

@@ -0,0 +1,102 @@
+import { IColumn } from "../../decorators/IColumn.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import { SqlServerLiteral } from "../../drivers/sql-server/SqlServerLiteral.js";
+import EntityType from "../../entity-query/EntityType.js";
+import EntityContext from "../../model/EntityContext.js";
+import Migrations from "../Migrations.js";
+import SqlServerMigrations from "./SqlServerMigrations.js";
+
+export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
+
+    async migrateTable(context: EntityContext, type: EntityType) {
+
+
+        // create table if not exists...
+        const nonKeyColumns = type.nonKeys;
+        const keys = type.keys;
+
+        const driver = context.driver;
+
+        await this.createTable(driver, type, keys);
+
+        await this.createColumns(driver, type, nonKeyColumns);
+
+        await this.createIndexes(driver, type, nonKeyColumns.filter((x) => x.fkRelation && !x.fkRelation?.dotNotCreateIndex));
+
+    }
+
+    async createIndexes(driver: BaseDriver, type: EntityType, fkColumns: IColumn[]) {
+
+        const name = type.schema
+        ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
+        : SqlServerLiteral.quotedLiteral(type.name);
+
+        for (const iterator of fkColumns) {
+            const indexName =  SqlServerLiteral.quotedLiteral(`IX_${type.name}_${iterator.columnName}`);
+            const columnName = SqlServerLiteral.quotedLiteral(iterator.columnName);
+            let query = `CREATE INDEX ${indexName} ON ${name} ( ${columnName})`;
+            if (iterator.nullable !== true) {
+                query += ` WHERE (${columnName} is not null)`;
+            }
+            await driver.executeQuery(query);
+        }
+    }
+
+    async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
+
+        const name = type.schema
+        ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
+        : SqlServerLiteral.quotedLiteral(type.name);
+
+        if (nonKeyColumns.length > 1) {
+            nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        for (const iterator of nonKeyColumns) {
+            const columnName = SqlServerLiteral.quotedLiteral(iterator.columnName);
+            let def = `IF COL_LENGTH(${ SqlServerLiteral.escapeLiteral(name)}, ${ SqlServerLiteral.escapeLiteral(columnName)}) IS NULL ALTER TABLE ${name} ADD ${columnName} `;
+            def += this.getColumnDefinition(iterator);
+            if (iterator.nullable === true) {
+                def += " NULL ";
+            } else {
+                def += " NOT NULL ";
+            }
+            if (typeof iterator.default === "string") {
+                def += " DEFAULT " + iterator.default;
+            }
+            await driver.executeQuery(def + ";");
+        }
+
+    }
+
+    async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
+
+        const name = type.schema
+            ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
+            : SqlServerLiteral.quotedLiteral(type.name);
+
+        if (keys.length > 1) {
+            keys.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        }
+
+        const fields = [];
+
+        for (const iterator of keys) {
+            let def = SqlServerLiteral.quotedLiteral(iterator.columnName) + " ";
+            if (iterator.autoGenerate) {
+                def += this.getColumnDefinition(iterator) + " IDENTITY(1,1)";
+            } else {
+                def += this.getColumnDefinition(iterator);
+            }
+            def += " NOT NULL primary key\r\n\t";
+            fields.push(def);
+        }
+
+        await driver.executeQuery(`IF OBJECT_ID(${ SqlServerLiteral.escapeLiteral(name)}) IS NULL BEGIN
+            CREATE TABLE ${name} (${fields.join(",")});
+        END`);
+
+    }
+
+
+}