@entity-access/entity-access 1.0.2 → 1.0.5

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,28 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
 
     }
 
-    visitSelectStatement(e: SelectStatement): ITextOrFunctionArray {
+    visitSelectStatement(e: SelectStatement): ITextQuery {
+
+        if (e.as && e.model) {
+            const scope = this.targets.get(e.as);
+            if (!scope) {
+                this.targets.set(e.as, {
+                    parameter: e.as,
+                    model:
+                    e.model,
+                    replace: e.as,
+                    selectStatement: e
+                });
+            } else {
+                scope.selectStatement = e;
+                scope.model = e.model;
+            }
+        }
+
+        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)}` : [];
+
         const fields = this.visitArray(e.fields, ",\n\t\t");
 
         const showTop = e.limit && !e.offset;
@@ -64,15 +85,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,7 +1,7 @@
 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 InstanceCache from "../common/cache/InstanceCache.js";

package/src/model/EntityContext.ts

@@ -1,48 +1,193 @@
 import { BaseDriver } from "../drivers/base/BaseDriver.js";
-import ChangeSet from "./ChangeSet.js";
+import ChangeSet from "./changes/ChangeSet.js";
 import EntityModel from "./EntityModel.js";
 import { Expression } from "../query/ast/Expressions.js";
-import QueryCompiler from "../compiler/QueryCompiler.js";
+import { IClassOf } from "../decorators/IClassOf.js";
+import VerificationSession from "./verification/VerificationSession.js";
+import EntityType from "../entity-query/EntityType.js";
+import EntityEvents from "./events/EntityEvents.js";
+import ChangeEntry from "./changes/ChangeEntry.js";
+import ContextEvents from "./events/ContextEvents.js";
+import Inject, { ServiceProvider } from "../di/di.js";
+import EntityAccessError from "../common/EntityAccessError.js";
+import Logger from "../common/Logger.js";
+
+const isChanging = Symbol("isChanging");
 
 export default class EntityContext {
 
     public readonly model = new EntityModel(this);
     public readonly changeSet = new ChangeSet(this);
 
+    public raiseEvents: boolean;
+
+    public verifyFilters = false;
+
+    public get isChanging() {
+        return this[isChanging];
+    }
+
+    private postSaveChangesQueue: { task: () => any, order: number }[];
+
     constructor(
-        public driver: BaseDriver
+        @Inject
+        public driver: BaseDriver,
+        @Inject
+        private events?: ContextEvents,
+        @Inject
+        private logger?: Logger
     ) {
+        this.raiseEvents = !!events;
+    }
+
+    eventsFor<T>(type: IClassOf<T>, fail = true): EntityEvents<T>{
+        const eventsClass = this.events?.for(type, fail);
+        if (!eventsClass) {
+            if (fail) {
+                EntityAccessError.throw(`No rules defined for ${type}`);
+            }
+            return null;
+        }
+        return ServiceProvider.create(this, eventsClass);
+    }
 
+    query<T>(type: IClassOf<T>) {
+        const query = this.model.register(type).asQuery();
+        return query;
     }
 
-    public async saveChanges() {
+    public async saveChanges(signal?: AbortSignal) {
+
+        if (this[isChanging]) {
+            if (!this.raiseEvents) {
+                this.queuePostSaveTask(() => this.saveChangesWithoutEvents(signal));
+                return 0;
+            }
+            this.queuePostSaveTask(() => this.saveChanges(signal));
+            return 0;
+        }
 
         this.changeSet.detectChanges();
 
-        await this.driver.runInTransaction(async () => {
-            for (const iterator of this.changeSet.entries) {
-                switch(iterator.status) {
+        if(!this.raiseEvents) {
+            return this.saveChangesWithoutEvents(signal);
+        }
+
+        try {
+            this[isChanging] = true;
+            const r = await this.saveChangesInternal(signal);
+            const postSaveChanges = this.postSaveChangesQueue;
+            this.postSaveChangesQueue = void 0;
+            this[isChanging] = false;
+            if (postSaveChanges?.length) {
+                postSaveChanges.sort((a, b) => a.order - b.order);
+                for (const { task } of postSaveChanges) {
+                    const p = task();
+                    if (p?.then) {
+                        await p;
+                    }
+                }
+            }
+            return r;
+        } finally {
+            this[isChanging] = false;
+        }
+    }
+
+    public queuePostSaveTask(task: () => any, order = Number.MAX_SAFE_INTEGER) {
+        this.postSaveChangesQueue ??= [];
+        this.postSaveChangesQueue.push({ task, order });
+    }
+
+    async saveChangesInternal(signal?: AbortSignal) {
+
+        const verificationSession = new VerificationSession(this);
+
+        const pending = [] as { status: ChangeEntry["status"], change: ChangeEntry , events: EntityEvents<any>  }[];
+
+        for (const iterator of this.changeSet.entries) {
+
+            const events = this.eventsFor(iterator.type.typeClass);
+            switch(iterator.status) {
+                case "inserted":
+                    await events.beforeInsert(iterator.entity, iterator);
+                    if (this.verifyFilters) {
+                        verificationSession.queueVerification(iterator, events);
+                    }
+                    pending.push({ status: iterator.status, change: iterator, events });
+                    continue;
+                case "deleted":
+                    await events.beforeDelete(iterator.entity, iterator);
+                    if (this.verifyFilters) {
+                        verificationSession.queueVerification(iterator, events);
+                    }
+                    pending.push({ status: iterator.status, change: iterator, events });
+                    continue;
+                case "modified":
+                    await events.beforeUpdate(iterator.entity, iterator);
+                    if (this.verifyFilters) {
+                        verificationSession.queueVerification(iterator, events);
+                    }
+                    pending.push({ status: iterator.status, change: iterator, events });
+                    continue;
+            }
+        }
+
+        if (this.verifyFilters) {
+            await verificationSession.verifyAsync();
+        }
+
+        await this.driver.runInTransaction(() => this.saveChangesWithoutEvents(signal));
+
+        if (pending.length > 0) {
+
+            for (const { status, change, change: { entity}, events } of pending) {
+                switch(status) {
                     case "inserted":
-                        const insert  = this.driver.createInsertExpression(iterator.type, iterator.entity);
-                        const r = await this.executeExpression(insert);
-                        iterator.apply(r);
-                        break;
+                        await events.afterInsert(entity, entity);
+                        continue;
+                    case "deleted":
+                        await events.afterDelete(entity, entity);
+                        continue;
                     case "modified":
-                        if (iterator.modified.size > 0) {
-                            const update = this.driver.createUpdateExpression(iterator);
-                            await this.executeExpression(update);
-                        }
-                        iterator.apply({});
-                        break;
+                        await events.afterUpdate(entity, entity);
+                        continue;
                 }
             }
-        });
+        }
+
+    }
+
+    protected async saveChangesWithoutEvents(signal: AbortSignal) {
+        for (const iterator of this.changeSet.entries) {
+            switch (iterator.status) {
+                case "inserted":
+                    const insert = this.driver.createInsertExpression(iterator.type, iterator.entity);
+                    const r = await this.executeExpression(insert, signal);
+                    iterator.apply(r);
+                    break;
+                case "modified":
+                    if (iterator.modified.size > 0) {
+                        const update = this.driver.createUpdateExpression(iterator);
+                        await this.executeExpression(update, signal);
+                    }
+                    iterator.apply({});
+                    break;
+                case "deleted":
+                    const deleteQuery = this.driver.createDeleteExpression(iterator.type, iterator.entity);
+                    if (deleteQuery) {
+                        await this.executeExpression(deleteQuery, signal);
+                    }
+                    iterator.apply({});
+                    break;
+            }
+        }
     }
 
-    private async executeExpression(expression: Expression) {
-        const { text, values } = this.driver.compiler.compileExpression(expression);
-        const r = await this.driver.executeQuery({ text, values });
-        return r.rows[0];
+    private async executeExpression(expression: Expression, signal: AbortSignal) {
+        const { text, values } = this.driver.compiler.compileExpression(null, expression);
+        const r = await this.driver.executeQuery({ text, values }, signal);
+        return r.rows?.[0];
     }
 
 }