@entity-access/entity-access 1.0.2 → 1.0.6

package/src/di/di.ts

@@ -0,0 +1,224 @@
+import { IDisposable, disposeDisposable } from "../common/IDisposable.js";
+import { IAbstractClassOf, IClassOf } from "../decorators/IClassOf.js";
+
+import "reflect-metadata";
+import EntityContext from "../model/EntityContext.js";
+import { BaseDriver } from "../drivers/base/BaseDriver.js";
+
+export type ServiceKind = "Singleton" | "Transient" | "Scoped";
+
+const registrations = new Map<any,IServiceDescriptor>();
+
+export const injectServiceTypesSymbol = Symbol("injectServiceTypes");
+export const injectServiceKeysSymbol = Symbol("injectServiceKeys");
+
+const registrationsSymbol = Symbol("registrations");
+
+const serviceProvider = Symbol("serviceProvider");
+
+const parentServiceProvider = Symbol("parentServiceProvider");
+
+export class ServiceProvider implements IDisposable {
+
+    public static global = new ServiceProvider();
+
+    public static resolve<T>(serviceOwner: any, type: IClassOf<T>): T {
+        const sp = (serviceOwner[serviceProvider] ?? this.global) as ServiceProvider;
+        return sp.resolve(type);
+    }
+
+    static create<T>(serviceOwner, type: IClassOf<T>): T {
+        const sp = (serviceOwner[serviceProvider] ?? this.global) as ServiceProvider;
+        return sp.createFromType(type);
+    }
+
+
+    private map: Map<any,any> = new Map();
+    private disposables: IDisposable[];
+
+    constructor(parent?: ServiceProvider) {
+        this[serviceProvider] = this;
+        this[parentServiceProvider] = parent;
+    }
+
+    add<T1, T extends T1>(type: IAbstractClassOf<T1> | IClassOf<T1>, instance: T) {
+        this.getRegistration(type, true);
+        this.map.set(type, instance);
+        instance[serviceProvider] = this;
+        return instance;
+    }
+
+
+    createScope() {
+        return new ServiceProvider(this);
+    }
+
+    create<T>(type: IClassOf<T>): T {
+        return this.createFromType(type);
+    }
+
+
+    resolve(type) {
+        let instance;
+        const sd = this.getRegistration(type);
+        switch(sd.kind) {
+            case "Scoped":
+                if (!this[parentServiceProvider]) {
+                    throw new Error(`Unable to create scoped service ${type?.name ?? type} in global scope.`);
+                }
+                instance = this.map.get(type);
+                if (!instance) {
+                    instance = this.createFromDescriptor(sd);
+                    this.map.set(type, instance);
+                    instance[serviceProvider] = this;
+                    if (instance[Symbol.disposable] || instance[Symbol.asyncDisposable]) {
+                        (this.disposables ??= []).push(instance);
+                    }
+                }
+                return  instance;
+            case "Singleton":
+                let sp = this;
+                while (sp[parentServiceProvider]) {
+                    sp = sp[parentServiceProvider];
+                }
+                instance = sp.map.get(type);
+                if (!instance) {
+                    instance = sp.createFromDescriptor(sd);
+                    instance[serviceProvider] = sp;
+                    sp.map.set(type, instance);
+                    if (instance[Symbol.disposable] || instance[Symbol.asyncDisposable]) {
+                        (sp.disposables ??= []).push(instance);
+                    }
+                }
+                return  instance;
+            case "Transient":
+                instance = sp.createFromDescriptor(sd);
+                instance[serviceProvider] = sp;
+                return instance;
+        }
+    }
+
+    dispose() {
+        this[Symbol.disposable]();
+    }
+
+    [Symbol.disposable]() {
+        const disposables = this.disposables;
+        if (!disposables) {
+            return;
+        }
+        for (const iterator of disposables) {
+            disposeDisposable(iterator);
+        }
+    }
+
+    private getRegistration(type: any, add = false) {
+        let sd = registrations.get(type);
+        if (!sd) {
+
+            if (add) {
+                const registration: IServiceDescriptor = { key: type, kind: "Scoped"};
+                registrations.set(type, registration);
+                return registration;
+            }
+
+            // we need to go through all services
+            // to find the derived type
+            for (const [key, value] of registrations.entries()) {
+                if (key instanceof type) {
+                    // we found the match..
+                    registrations.set(type, { ...value, key: type });
+                    sd = value;
+                }
+            }
+            if (!sd) {
+                throw new Error(`No service registered for ${type?.name ?? type}`);
+            }
+        }
+        return sd;
+    }
+
+    private createFromDescriptor(sd: IServiceDescriptor): any {
+        if(sd.factory) {
+            return sd.factory(this);
+        }
+        return this.createFromType(sd.key);
+    }
+
+    private createFromType(type): any {
+        const injectTypes = type[injectServiceTypesSymbol] as any[];
+        const injectServices = injectTypes
+            ? injectTypes.map((x) => this.resolve(x))
+            : [];
+        const instance = new type(... injectServices);
+        instance[serviceProvider] = this;
+        // initialize properties...
+        const keys = type.prototype[injectServiceKeysSymbol];
+        if (keys) {
+            for (const key in keys) {
+                if (Object.prototype.hasOwnProperty.call(keys, key)) {
+                    const element = keys[key];
+                    instance[key] = this.resolve(element);
+                }
+            }
+        }
+        return instance;
+    }
+
+}
+
+export interface IServiceDescriptor {
+
+    key: any;
+    kind: ServiceKind;
+    instance?: any;
+    factory?: (sp: ServiceProvider) => any;
+}
+
+
+export const ServiceCollection = {
+    register(kind: ServiceKind, key, factory?: (sp: ServiceProvider) => any) {
+        registrations.set(key, { kind, key, factory});
+    },
+    [registrationsSymbol]: registrations
+};
+
+export default function Inject(target, key, index?: number) {
+
+    if (index !== void 0) {
+        const plist = (Reflect as any).getMetadata("design:paramtypes", target, key);
+        const serviceTypes = target[injectServiceTypesSymbol] ??= [];
+        serviceTypes[index] = plist[index];
+        return;
+    }
+
+    const pType = (Reflect as any).getMetadata("design:type", target, key);
+    (target[injectServiceKeysSymbol] ??= {})[key] = pType;
+    Object.defineProperty(target, key, {
+        get() {
+            const result = ServiceProvider.resolve(this, pType);
+            // get is compatible with AtomWatcher
+            // as it will ignore getter and it will
+            // not try to set a binding refresher
+            Object.defineProperty(target, key, {
+                get: () => result
+            });
+            return result;
+        },
+        configurable: true
+    });
+
+
+}
+
+export function Register(kind: ServiceKind, factory?: (sp: ServiceProvider) => any) {
+    return function(target) {
+        ServiceCollection.register(kind, target, factory);
+    };
+}
+
+export const RegisterSingleton = Register("Singleton");
+
+export const RegisterScoped = Register("Scoped");
+
+export const RegisterTransient = Register("Transient");

package/src/drivers/base/BaseDriver.ts

@@ -1,8 +1,8 @@
 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";
+import ChangeEntry from "../../model/changes/ChangeEntry.js";
+import { BinaryExpression, Constant, DeleteStatement, Expression, InsertStatement, QuotedLiteral, ReturnUpdated, TableLiteral, UpdateStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 
 export const disposableSymbol: unique symbol = (Symbol as any).dispose ??= Symbol("disposable");
 
@@ -47,7 +47,6 @@ export interface IQueryResult {
 }
 
 export abstract class BaseDriver {
-
     abstract get compiler(): QueryCompiler;
 
     constructor(public readonly connectionString: IDbConnectionString) {}
@@ -131,4 +130,30 @@ export abstract class BaseDriver {
         });
     }
 
+    createDeleteExpression(type: EntityType, entity: any) {
+        let where: Expression;
+        for (const iterator of type.keys) {
+            const key = entity[iterator.name];
+            if (!key) {
+                return null;
+            }
+            const compare = BinaryExpression.create({
+                left: QuotedLiteral.create({ literal: iterator.columnName }),
+                operator: "=",
+                right: Constant.create({ value: key })
+            });
+            where = where
+                ? BinaryExpression.create({ left: where, operator: "AND", right: compare })
+                : compare;
+        }
+        if (!where) {
+            return null;
+        }
+        return DeleteStatement.create({
+            table: type.fullyQualifiedName,
+            where
+        });
+    }
+
+
 }

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

@@ -1,10 +1,10 @@
 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";
+import { ITextQuery, prepare } from "../../query/ast/IStringTransformer.js";
 
 export default class ExpressionToSqlServer extends ExpressionToSql {
 
-    visitReturnUpdated(e: ReturnUpdated): ITextOrFunctionArray {
+    visitReturnUpdated(e: ReturnUpdated): ITextQuery {
         if (!e) {
             return [];
         }
@@ -22,7 +22,7 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
         return prepare ` OUTPUT ${fields}`;
     }
 
-    visitInsertStatement(e: InsertStatement): ITextOrFunctionArray {
+    visitInsertStatement(e: InsertStatement): ITextQuery {
         const returnValues = this.visit(e.returnValues);
         if (e.values instanceof ValuesStatement) {
 
@@ -45,7 +45,14 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
 
     }
 
-    visitSelectStatement(e: SelectStatement): ITextOrFunctionArray {
+    visitSelectStatement(e: SelectStatement): ITextQuery {
+
+        this.prepareStatement(e);
+
+        const orderBy = e.orderBy?.length > 0 ? prepare `\n\t\tORDER BY ${this.visitArray(e.orderBy)}` : "";
+        const where = e.where ? prepare `\n\tWHERE ${this.visit(e.where)}` : "";
+        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins, "\n")}` : [];
+
         const fields = this.visitArray(e.fields, ",\n\t\t");
 
         const showTop = e.limit && !e.offset;
@@ -64,15 +71,33 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
         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)}` : [];
+        let source: ITextQuery;
+        let as: ITextQuery | "";
+        if (e.source.type === "ValuesStatement") {
+            const v = e.source as ValuesStatement;
+            const rows = v.values.map((x) => prepare `(${this.visitArray(x)})`);
+            source  = prepare `(VALUES ${rows}) as ${this.visit(e.as)}(${this.visitArray(v.fields)})`;
+            as = [];
+        } else {
+            source = this.visit(e.source);
+            as = e.as ? prepare ` AS ${this.visit(e.as)}` : "";
+        }
+
+        // const as = e.as ? prepare ` AS ${this.visit(e.as)}` : "";
         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}`;
     }
+
+    visitValuesStatement(e: ValuesStatement): ITextQuery {
+        const rows = [];
+        for (const rowValues of e.values) {
+            rows.push(prepare `(${ this.visitArray(rowValues) })`);
+        }
+        const fields = e.fields ? prepare ` as x11(${this.visitArray(e.fields)})` : "";
+        return prepare `(VALUES ${rows}) ${fields}`;
+
+    }
 }

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

@@ -4,13 +4,11 @@ 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;
+export type ISqlServerConnectionString = IDbConnectionString & sql.config;
 
 const namedPool = new TimedCache<string, sql.ConnectionPool>();
 
@@ -24,14 +22,8 @@ export default class SqlServerDriver extends BaseDriver {
     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,
-        });
+        super(config);
+        config.server = config.host;
     }
 
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
@@ -61,7 +53,6 @@ export default class SqlServerDriver extends BaseDriver {
         }
 
         try {
-            console.log(command.text);
             const r = await rq.query(command.text);
             return { rows: r.recordset ?? [r.output], updated: r.rowsAffected [0]};
         } catch (error) {
@@ -135,10 +126,11 @@ export default class SqlServerDriver extends BaseDriver {
     }
 
     private newConnection() {
-        const key = this.config.server + "//" + this.config.database + "/" + this.config.user;
-        return namedPool.getOrCreateAsync(this.config.server + "://" + this.config.database,
+        const config = this.config;
+        const key = config.server + "//" + config.database + "/" + config.user;
+        return namedPool.getOrCreateAsync(config.server + "://" + config.database,
             () => {
-                const pool = new sql.ConnectionPool(this.config);
+                const pool = new sql.ConnectionPool(config);
                 const oldClose = pool.close;
                 pool.close = ((c) => {
                     namedPool.delete(key);
@@ -188,7 +180,6 @@ class SqlReader implements IDbReader {
             this.processPendingRows();
         });
 
-        console.log(`Executing ${(command as any).text}`);
         void rq.query((command as any).text);
 
         do {

package/src/entity-query/EntityType.ts

@@ -1,9 +1,9 @@
 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 NameParser from "../decorators/parser/NameParser.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
-import { QuotedLiteral, TableLiteral } from "../query/ast/Expressions.js";
+import { Expression, ExpressionAs, QuotedLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
 import InstanceCache from "../common/cache/InstanceCache.js";
 
 
@@ -40,6 +40,9 @@ export default class EntityType {
     private columnMap: Map<string, IColumn> = new Map();
     private relationMap: Map<string, IEntityRelation> = new Map();
 
+    private selectAll: SelectStatement;
+    private selectOne: SelectStatement;
+
     public getProperty(name: string) {
         const field = this.fieldMap.get(name);
         const relation = this.relationMap.get(name);
@@ -103,14 +106,53 @@ export default class EntityType {
             relatedTypeClass: this.typeClass,
             dotNotCreateIndex: true,
             fkColumn,
-            isCollection: true,
+            isInverseRelation: true,
             relatedRelation: relation,
             relatedEntity: this
         };
         relatedType.relationMap.set(inverseRelation.name, inverseRelation);
         relatedType.relations.push(inverseRelation);
         inverseRelation.relatedRelation = relation;
+        relation.relatedRelation = inverseRelation;
 
     }
 
+    public selectAllFields() {
+        if (this.selectAll) {
+            return { ... this.selectAll };
+        }
+        const source = this.fullyQualifiedName;
+        const as = Expression.parameter(this.name[0] + "1");
+        const fields = this.columns.map((c) => c.name !== c.columnName
+            ? ExpressionAs.create({
+                expression: Expression.member(as, c.columnName),
+                alias: QuotedLiteral.create({ literal: c.name })
+            })
+            : Expression.member(as, c.columnName));
+        this.selectAll = SelectStatement.create({
+            source,
+            model: this,
+            as,
+            fields
+        });
+        return { ... this.selectAll };
+    }
+
+    public selectOneNumber() {
+        if (this.selectOne) {
+            return { ... this.selectOne };
+        }
+        const source = this.fullyQualifiedName;
+        const as = Expression.parameter(this.name[0] + "1");
+        const fields = [
+            Expression.identifier("1")
+        ];
+        this.selectOne = SelectStatement.create({
+            source,
+            model: this,
+            as,
+            fields
+        });
+        return { ... this.selectOne };
+    }
 }