@entity-access/entity-access 1.0.1

package/src/decorators/Column.ts

@@ -0,0 +1,46 @@
+import { IColumn } from "./IColumn.js";
+import { ISqlType } from "./ISqlType.js";
+import SchemaRegistry from "./SchemaRegistry.js";
+
+import "reflect-metadata";
+
+;
+export default function Column(cfg: Omit<Omit<IColumn, "name">, "type"> = {}): any {
+    return (target, key) => {
+        const cn = target.constructor ?? target;
+        const model = SchemaRegistry.model(cn);
+        const c = cfg as IColumn;
+        c.columnName ??= key;
+        c.name = key;
+        c.nullable ??= false;
+        c.order ??= model.columns.length;
+        c.type = model;
+
+        if (c.dataType === void 0) {
+            const jsType = (Reflect as any).getMetadata("design:type", target, key);
+            c.dataType = typeFrom(c, jsType);
+        }
+
+
+        model.addColumn(c);
+    };
+}
+
+function typeFrom(c: IColumn, jsType: any): ISqlType {
+    switch(jsType) {
+        case String:
+            return "Char";
+        case Number:
+            if (c.key) {
+                return "BigInt";
+            }
+            return "Double";
+        case BigInt:
+            return "BigInt";
+        case Date:
+            return "DateTime";
+        case Boolean:
+            return "Boolean";
+    }
+    return "Char";
+}

package/src/decorators/ForeignKey.ts

@@ -0,0 +1,42 @@
+import type { IClassOf } from "./IClassOf.js";
+import SchemaRegistry from "./SchemaRegistry.js";
+import NameParser from "./parser/MemberParser.js";
+
+
+export default function ForeignKey<T, TRelated>(
+    {
+        key: name,
+        related: c,
+        relatedProperty: inv,
+        relatedKey: invKey,
+        dotNotCreateIndex
+    } : {
+
+            key: (item: T) => any,
+
+            related: IClassOf<TRelated>,
+
+            relatedProperty: (item: TRelated) => any,
+
+            relatedKey?: (item: TRelated) => any,
+            dotNotCreateIndex?: boolean,
+        }
+
+    ) {
+    return (target: T, key: string): any => {
+
+        const cn = target.constructor ?? target;
+        const type = SchemaRegistry.model(cn);
+
+        type.addRelation({
+            type,
+            name: key,
+            foreignKey: NameParser.parseMember(name),
+            relatedTypeClass: c,
+            relatedName: NameParser.parseMember(inv),
+            relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
+            dotNotCreateIndex
+        });
+
+    };
+}

package/src/decorators/IClassOf.ts

@@ -0,0 +1 @@
+export type IClassOf<T> = abstract new (... a: any[]) => T;

package/src/decorators/IColumn.ts

@@ -0,0 +1,70 @@
+import EntityType from "../entity-query/EntityType.js";
+import { IClassOf } from "./IClassOf.js";
+import { ISqlType } from "./ISqlType.js";
+
+
+export interface IColumn {
+    name?: string;
+    columnName?: string;
+    order?: number;
+    key?: boolean;
+    autoGenerate?: boolean;
+    dataType?: ISqlType;
+    nullable?: boolean;
+    /**
+     * If length is specified, it will take exact same length always.
+     */
+    fixed?: boolean;
+    /**
+     * If length is not specified, text will be unlimited or variable length with maximum size.
+     */
+    length?: number;
+
+    precision?: number;
+    scale?: number;
+
+    type?: EntityType;
+
+    /**
+     * String representation of the default, empty string must be specified as ""
+     */
+    default?: string;
+
+    /**
+     * This only identifies itself as relation's foreign key, this will be set automatically.
+     */
+    fkRelation?: IEntityRelation;
+}
+
+export interface IEntityRelation {
+
+    type?: EntityType;
+
+    /**
+     * Name of own field...
+     */
+    name: string;
+
+    isCollection?: boolean;
+
+
+    foreignKey: string;
+
+    relatedTypeClass: IClassOf<any>;
+
+    fkColumn?: IColumn;
+
+
+    relatedName: string;
+
+    relatedKey?: string;
+
+
+    relatedEntity?: EntityType;
+
+    relatedRelation?: IEntityRelation;
+
+    dotNotCreateIndex?: boolean;
+
+}
+

package/src/decorators/ISqlType.ts

@@ -0,0 +1,70 @@
+
+export type ISqlType =
+    /**
+     * BigInt, long, 8 bytes
+     */
+    "BigInt" |
+
+    /**
+     * Integer, 4 bytes
+     */
+    "Int" |
+
+    /**
+     * Floating Point number, 4 bytes only
+     */
+
+    "Float" |
+
+
+    /**
+     * Numeric with default (18,2) precision ans scale, you can change precision
+     */
+    "Decimal" |
+
+    /**
+     * Double, floating point number, 8 bytes
+     */
+    "Double" |
+    /**
+     * Date and Time, usually 8 bytes
+     */
+    "DateTime" |
+    /**
+     * Date and Time with TimeZone, 8+ bytes
+     */
+    "DateTimeOffset" |
+    /**
+     * Ascii character, single byte, do not use for unicode
+     */
+    "AsciiChar" |
+
+    /**
+     * Unicode character
+     */
+
+    "Char" |
+    /**
+     * Single bit
+     */
+    "Boolean" |
+
+    /**
+     * uuid
+     */
+    "UUID" |
+
+    /**
+     * text json
+     */
+    "JSON" |
+
+    /**
+     * Binary Json
+     */
+    "JSONB" |
+
+    /**
+     * Byte Array - var binary
+     */
+    "ByteArray";

package/src/decorators/SchemaRegistry.ts

@@ -0,0 +1,19 @@
+import EntityType from "../entity-query/EntityType.js";
+
+
+export default class SchemaRegistry {
+
+    public static model(type) {
+        let model = this.map.get(type);
+        if (!model) {
+            model = new EntityType();
+            // @ts-expect-error readonly for compile time only
+            model.typeClass = type;
+            this.map.set(type, model);
+        }
+        return model;
+    }
+
+    private static map: Map<any, EntityType> = new Map();
+
+}

package/src/decorators/Table.ts

@@ -0,0 +1,18 @@
+import SchemaRegistry from "./SchemaRegistry.js";
+
+export interface ITable {
+    name: string;
+    schema?: string;
+}
+
+export default function Table<T>(
+    name: string,
+    schema?: string): any {
+    return (target: T) => {
+        const model = SchemaRegistry.model(target);
+        // @ts-expect-error readonly
+        model.name = name;
+        // @ts-expect-error readonly
+        model.schema = schema;
+    };
+}

package/src/decorators/parser/MemberParser.ts

@@ -0,0 +1,8 @@
+export default class NameParser {
+    public static parseMember(text: ((a: any) => any)) {
+        const t: string = text.toString();
+
+        const index = t.lastIndexOf(".");
+        return t.substring(index + 1);
+    }
+}

package/src/drivers/base/BaseDriver.ts

@@ -0,0 +1,134 @@
+import QueryCompiler from "../../compiler/QueryCompiler.js";
+import EntityType from "../../entity-query/EntityType.js";
+import Migrations from "../../migrations/Migrations.js";
+import ChangeEntry from "../../model/ChangeEntry.js";
+import { BinaryExpression, Constant, Expression, InsertStatement, QuotedLiteral, ReturnUpdated, TableLiteral, UpdateStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+
+export const disposableSymbol: unique symbol = (Symbol as any).dispose ??= Symbol("disposable");
+
+interface IDisposable {
+    [disposableSymbol]?(): void;
+}
+
+export interface IRecord {
+    [key: string]: string | boolean | number | Date | Uint8Array | Blob;
+}
+
+export interface IDbConnectionString {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+}
+
+export interface IDbReader extends IDisposable {
+    next(min?: number, signal?: AbortSignal): AsyncGenerator<IRecord, any, any>;
+    dispose(): Promise<any>;
+}
+
+export const toQuery = (text: IQuery): { text: string, values?: any[]} => typeof text === "string"
+    ? { text, values: [] }
+    : text;
+
+export type IQuery = string | {
+    text: string;
+    values?: any[];
+};
+
+export interface IQueryTask {
+    query: IQuery;
+    postExecution?: ((r: any) => Promise<any>);
+}
+
+export interface IQueryResult {
+    rows?: any[];
+    updated?: number;
+}
+
+export abstract class BaseDriver {
+
+    abstract get compiler(): QueryCompiler;
+
+    constructor(public readonly connectionString: IDbConnectionString) {}
+
+    public abstract executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader>;
+
+    public abstract executeQuery(command: IQuery, signal?: AbortSignal): Promise<IQueryResult>;
+
+    public abstract ensureDatabase(): Promise<any>;
+
+    public abstract runInTransaction<T = any>(fx?: () => Promise<T>): Promise<T>;
+
+    /**
+     * This migrations only support creation of missing items.
+     * However, you can provide events to change existing items.
+     */
+    public abstract automaticMigrations(): Migrations;
+
+    createInsertExpression(type: EntityType, entity: any): InsertStatement {
+        const returnFields = [] as QuotedLiteral[];
+        const fields = [] as QuotedLiteral[];
+        const values = [] as Constant[];
+        for (const iterator of type.columns) {
+            const literal = QuotedLiteral.create({ literal: iterator.columnName });
+            if (iterator.autoGenerate) {
+                returnFields.push(literal);
+                continue;
+            }
+            const value = entity[iterator.name];
+            if (value === void 0) {
+                continue;
+            }
+            fields.push(literal);
+            values.push(Constant.create({ value }));
+        }
+
+        const name = QuotedLiteral.create({ literal: type.name });
+        const schema = type.schema ? QuotedLiteral.create({ literal: type.schema }) : void 0;
+
+        return InsertStatement.create({
+            table: TableLiteral.create({
+                name,
+                schema
+            }),
+            values: ValuesStatement.create({ fields, values: [values] }),
+            returnValues: ReturnUpdated.create({
+                changes: "INSERTED",
+                fields: returnFields
+            }),
+        });
+    }
+
+    createUpdateExpression(entry: ChangeEntry) {
+        const set = [] as BinaryExpression[];
+        for (const [key, change] of entry.modified) {
+            set.push(BinaryExpression.create({
+                left: QuotedLiteral.create({ literal: key.columnName}),
+                operator: "=",
+                right: Constant.create({ value: change.newValue ?? null })
+            }));
+        }
+        let where = null as Expression;
+        for (const iterator of entry.type.keys) {
+            const compare = BinaryExpression.create({
+                left: QuotedLiteral.create({ literal: iterator.columnName }),
+                operator: "=",
+                right: Constant.create({ value: entry.entity[iterator.name]})
+            });
+            where = !where
+                ? compare
+                : BinaryExpression.create({
+                    left: where,
+                    operator: "AND",
+                    right: compare
+                });
+        }
+        return UpdateStatement.create({
+            set,
+            table: entry.type.fullyQualifiedName,
+            where
+        });
+    }
+
+}

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -0,0 +1,178 @@
+/* eslint-disable no-console */
+import QueryCompiler from "../../compiler/QueryCompiler.js";
+import { IColumn } from "../../decorators/IColumn.js";
+import EntityType from "../../entity-query/EntityType.js";
+import Migrations from "../../migrations/Migrations.js";
+import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
+import { Query } from "../../query/Query.js";
+import { BaseDriver, IDbConnectionString, IDbReader, IQuery, IRecord, toQuery } from "../base/BaseDriver.js";
+import pkg from "pg";
+import Cursor from "pg-cursor";
+
+const { Client } = pkg;
+
+export interface IPgSqlConnectionString extends IDbConnectionString {
+
+    user?: string, // default process.env.PGUSER || process.env.USER
+    password?: string, // default process.env.PGPASSWORD
+    host?: string, // default process.env.PGHOST
+    database?: string, // default process.env.PGDATABASE || user
+    port?: number, // default process.env.PGPORT
+    connectionString?: string, // e.g. postgres://user:password@host:5432/database
+    ssl?: any, // passed directly to node.TLSSocket, supports all tls.connect options
+    types?: any, // custom type parsers
+    statement_timeout?: number, // number of milliseconds before a statement in query will time out, default is no timeout
+    query_timeout?: number, // number of milliseconds before a query call will timeout, default is no timeout
+    application_name?: string, // The name of the application that created this Client instance
+    connectionTimeoutMillis?: number, // number of milliseconds to wait for connection, default is no timeout
+    idle_in_transaction_session_timeout?: number // number of milliseconds before terminating any session with an open idle transaction, default is no timeout
+};
+
+class DbReader implements IDbReader {
+
+    constructor(private cursor, private client) {
+
+    }
+
+    async *next(min = 100) {
+        do {
+            const rows = await this.cursor.read(min);
+            yield *rows;
+            if (rows.length === 0) {
+                break;
+            }
+        } while (true);
+    }
+
+    async dispose() {
+        try {
+            await this.cursor.close();
+        } catch {
+            // intentionally left blank
+        }
+
+        try {
+            if (this.client) {
+                await this.client.end();
+            }
+        } catch {
+            // intentionally left blank
+        }
+    }
+}
+
+export default class PostgreSqlDriver extends BaseDriver {
+
+    public get compiler() {
+        return this.myCompiler;
+    }
+
+    private transaction: pkg.Client;
+    private myCompiler = new QueryCompiler();
+
+    constructor(private readonly config: IPgSqlConnectionString) {
+        super(config);
+    }
+
+    public async runInTransaction<T>(fx?: () => Promise<T>): Promise<T> {
+        const connection = await this.getConnection();
+        let result: T;
+        try {
+            this.transaction = connection;
+            await connection.query("BEGIN");
+            result = await fx();
+            await connection.query("COMMIT");
+            return result;
+        } catch (error) {
+            await connection.query("ROLLBACK");
+            throw error;
+        } finally {
+            this.transaction = void 0;
+            await connection.end();
+        }
+    }
+
+    public automaticMigrations(): Migrations {
+        return new PostgresAutomaticMigrations();
+    }
+
+    public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
+        const connection = await this.getConnection(signal);
+        const q = toQuery(command);
+        const cursor = connection.query(new Cursor(q.text, q.values));
+        return new DbReader(cursor, this.transaction ? void 0 : connection);
+    }
+
+    public async executeQuery(command: IQuery, signal?: AbortSignal) {
+        const connection = await this.getConnection(signal);
+        // we need to change parameter styles
+        try {
+            const q = toQuery(command);
+            const result = await connection.query(q.text, q.values);
+            return result;
+        } finally {
+            if (!this.transaction) {
+                await connection.end();
+            }
+        }
+    }
+
+    public ensureDatabase() {
+        const create = async () => {
+            const defaultDb = "postgres";
+            const db = this.config.database;
+            this.config.database = defaultDb;
+            const connection = await this.getConnection();
+            // @ts-expect-error readonly
+            this.config = { ... this.config };
+            this.config.database = db;
+            try {
+                const r = await connection.query("SELECT FROM pg_database WHERE datname = $1", [ db ]);
+                if(r.rowCount === 1) {
+                    return;
+                }
+                await connection.query("CREATE DATABASE " + JSON.stringify(db));
+            } finally {
+                await connection.end();
+            }
+        };
+        const value = create();
+        Object.defineProperty(this, "ensureDatabase", {
+            value: () => value,
+        });
+        return value;
+    }
+
+
+    private async getConnection(signal?: AbortSignal) {
+
+        if (signal?.aborted) {
+            throw new Error("Aborted");
+        }
+
+        if (this.transaction) {
+            return this.transaction;
+        }
+        const client = new Client(this.config);
+        await client.connect();
+        const row = await client.query("SELECT pg_backend_pid() as id");
+        const clientId = (row.rows as any).id;
+        // there is no support to kill the query running inside
+        if (signal) {
+            signal.addEventListener("abort", () => this.kill(clientId).catch((error) => console.error(error)));
+        }
+        return client;
+    }
+
+    private async kill(id) {
+        const client = new Client(this.config);
+        try {
+            await client.connect();
+            await client.query("SELECT pg_cancel_backend($1)", [id]);
+        } catch (error) {
+            console.error(error);
+        } finally {
+            await client.end();
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+import ExpressionToSql from "../../query/ast/ExpressionToSql.js";
+import { Identifier, InsertStatement, OrderByExpression, ReturnUpdated, SelectStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+import { ITextOrFunctionArray, prepare } from "../../query/ast/IStringTransformer.js";
+
+export default class ExpressionToSqlServer extends ExpressionToSql {
+
+    visitReturnUpdated(e: ReturnUpdated): ITextOrFunctionArray {
+        if (!e) {
+            return [];
+        }
+        if (e.fields.length === 0) {
+            return [];
+        }
+        const fields = [];
+        let i = 0;
+        for (const iterator of e.fields) {
+            if (i++) {
+                fields.push(",");
+            }
+            fields.push(prepare `${e.changes}.${this.visit(iterator)}`);
+        }
+        return prepare ` OUTPUT ${fields}`;
+    }
+
+    visitInsertStatement(e: InsertStatement): ITextOrFunctionArray {
+        const returnValues = this.visit(e.returnValues);
+        if (e.values instanceof ValuesStatement) {
+
+            const rows = [];
+            for (const iterator of e.values.values) {
+                const row = this.visitArray(iterator);
+                if (row.length === 0) {
+                    continue;
+                }
+                rows.push(prepare `(${ row })`);
+            }
+
+            if (rows.length === 0) {
+                return prepare `INSERT INTO ${this.visit(e.table)} ${returnValues}`;
+            }
+
+            return prepare `INSERT INTO ${this.visit(e.table)} (${this.visitArray(e.values.fields)}) ${returnValues} VALUES ${rows}`;
+        }
+        return prepare `INSERT INTO ${this.visit(e.table)} ${returnValues} ${this.visit(e.values)}`;
+
+    }
+
+    visitSelectStatement(e: SelectStatement): ITextOrFunctionArray {
+        const fields = this.visitArray(e.fields, ",\n\t\t");
+
+        const showTop = e.limit && !e.offset;
+        const showFetch = e.limit && e.offset;
+
+        if (e.limit && e.offset) {
+            if (!e.orderBy?.length) {
+                // lets set default order by... if not set...
+                // as sql server needs something to order by...
+                e.orderBy = [
+                    OrderByExpression.create({  target:  Identifier.create({ value: "1"})  })
+                ];
+            }
+        }
+
+        const topValue = Number(e.limit);
+        const top = showTop ? prepare ` TOP (${() => topValue}) ` : "";
+
+        const orderBy = e.orderBy?.length > 0 ? prepare `\n\t\tORDER BY ${this.visitArray(e.orderBy)}` : "";
+        const source = this.visit(e.source);
+        const where = e.where ? prepare `\n\tWHERE ${this.visit(e.where)}` : "";
+        const as = e.as ? prepare ` AS ${this.visit(e.as)}` : "";
+        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins)}` : [];
+        const offset = showFetch ? prepare ` OFFSET ${Number(e.offset).toString()} ROWS ` : "";
+        const next = showFetch ? prepare ` FETCH NEXT ${Number(e.limit).toString()} ROWS ONLY` : "";
+        return prepare `SELECT ${top}
+        ${fields}
+        FROM ${source}${as}${joins}${where}${orderBy}${offset}${next}`;
+    }
+}