@entity-access/entity-access 1.0.2 → 1.0.6

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];
     }
 
 }

package/src/model/EntityQuery.ts

@@ -1,17 +1,39 @@
-import { BinaryExpression, CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, QuotedLiteral, SelectStatement, TableSource } from "../query/ast/Expressions.js";
-import { EntitySource } from "./EntitySource.js";
-import { IOrderedEntityQuery, IEntityQuery, ILambdaExpression } from "./IFilterWithParameter.js";
-import { SourceExpression } from "./SourceExpression.js";
+import Logger from "../common/Logger.js";
+import { DisposableScope } from "../common/usingAsync.js";
+import { ServiceProvider } from "../di/di.js";
+import EntityType from "../entity-query/EntityType.js";
+import { CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, QuotedLiteral, SelectStatement } from "../query/ast/Expressions.js";
+import { QueryExpander } from "../query/expander/QueryExpander.js";
+import EntityContext from "./EntityContext.js";
+import { IOrderedEntityQuery, IEntityQuery } from "./IFilterWithParameter.js";
+import RelationMapper from "./identity/RelationMapper.js";
 
 export default class EntityQuery<T = any>
     implements IOrderedEntityQuery<T>, IEntityQuery<T> {
-    constructor (public readonly source: SourceExpression) {
+
+    public context: EntityContext;
+    public type: EntityType;
+    public selectStatement: SelectStatement;
+    public signal?: AbortSignal;
+    constructor (p: Partial<EntityQuery<any>>
+    ) {
+        // lets clone select...
+        Object.setPrototypeOf(p, EntityQuery.prototype);
+        return p as EntityQuery;
+    }
+
+    select(p: any, fx: any): any {
+        return this.map(p, fx);
+    }
+
+    map(p: any, fx: any): any {
+        // const source = this.source.copy();
+        // const { select } = source;
+        // const exp = this.source.context.driver.compiler.compileToExpression(source, p, fx);
     }
 
     withSignal(signal: AbortSignal): any {
-        const source = this.source.copy();
-        source.signal = signal;
-        return new EntityQuery(source);
+        return new EntityQuery({ ... this, signal });
     }
 
     thenBy(parameters: any, fx: any): any {
@@ -20,21 +42,21 @@ export default class EntityQuery<T = any>
     thenByDescending(parameters: any, fx: any) {
         return this.orderByDescending(parameters, fx);
     }
+
     where<P>(parameters: P, fx: (p: P) => (x: T) => boolean): any {
 
-        const source = this.source.copy();
-        const { select } = source;
-        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx);
-        if(!select.where) {
-            select.where = exp;
-        } else {
-            select.where = BinaryExpression.create({
-                left: select.where,
-                operator: "AND",
-                right: exp
-            });
-        }
-        return new EntityQuery(source);
+        return this.extend(parameters, fx, (select, body) => ({
+            ... select,
+            where: select.where ? Expression.logicalAnd(select.where, body): body
+        }));
+    }
+
+    include(p: any): any {
+        const selectStatement = QueryExpander.expand(this.context, { ... this.selectStatement }, p);
+        return new EntityQuery({
+            ... this,
+            selectStatement
+        });
     }
 
     async toArray(): Promise<T[]> {
@@ -46,21 +68,63 @@ export default class EntityQuery<T = any>
     }
 
     async *enumerate(): AsyncGenerator<T, any, unknown> {
-        const type = this.source.model?.typeClass;
-        const signal = this.source.signal;
-        const query = this.source.context.driver.compiler.compileExpression(this.source.select);
-        const reader = await this.source.context.driver.executeReader(query, signal);
+        const logger = ServiceProvider.resolve(this.context, Logger);
+        const scope = new DisposableScope();
+        const session = logger.newSession();
+        let query: { text: string, values: any[]};
         try {
+            scope.register(session);
+            const type = this.type;
+            const signal = this.signal;
+
+            const relationMapper = new RelationMapper(this.context.changeSet);
+
+            const include = this.selectStatement.include;
+            if (include?.length > 0) {
+                // since we will be streaming results...
+                // it is important that we load all the
+                // included entities first...
+                const loaders = include.map((x) => this.load(relationMapper, session, x, signal));
+                await Promise.all(loaders);
+            }
+
+            signal?.throwIfAborted();
+
+            query = this.context.driver.compiler.compileExpression(this, this.selectStatement);
+            const reader = await this.context.driver.executeReader(query, signal);
+            scope.register(reader);
             for await (const iterator of reader.next(10, signal)) {
                 if (type) {
-                    Object.setPrototypeOf(iterator, type.prototype);
+                    Object.setPrototypeOf(iterator, type.typeClass.prototype);
                     // set identity...
-                    const entry = this.source.context.changeSet.getEntry(iterator, iterator);
+                    const entry = this.context.changeSet.getEntry(iterator, iterator);
+                    relationMapper.fix(entry);
                     yield entry.entity;
                     continue;
                 }
                 yield iterator as T;
             }
+
+        } catch(error) {
+            session.error(`Failed executing ${query?.text}\n${error.stack ?? error}`);
+            throw error;
+        } finally {
+            await scope.dispose();
+        }
+    }
+
+    async load(relationMapper: RelationMapper, session: Logger, select: SelectStatement, signal: AbortSignal) {
+        const query = this.context.driver.compiler.compileExpression(this, select);
+        const reader = await this.context.driver.executeReader(query, signal);
+        try {
+            for await (const iterator of reader.next(10, signal)) {
+                Object.setPrototypeOf(iterator, select.model.typeClass.prototype);
+                const entry = this.context.changeSet.getEntry(iterator, iterator);
+                relationMapper.fix(entry);
+            }
+        } catch (error) {
+            session.error(`Failed loading ${query.text}\n${error.stack ?? error}`);
+            throw error;
         } finally {
             await reader.dispose();
         }
@@ -70,7 +134,7 @@ export default class EntityQuery<T = any>
         for await(const iterator of this.limit(1).enumerate()) {
             return iterator;
         }
-        throw new Error(`No records found for ${this.source.model?.name || "Table"}`);
+        throw new Error(`No records found for ${this.type?.name || "Table"}`);
     }
 
     async first(): Promise<T> {
@@ -80,42 +144,32 @@ export default class EntityQuery<T = any>
         return null;
     }
     toQuery(): { text: string; values: any[]; } {
-        return this.source.context.driver.compiler.compileExpression(this.source.select);
+        return this.context.driver.compiler.compileExpression(this, this.selectStatement);
     }
     orderBy(parameters: any, fx: any): any {
-        const source = this.source.copy();
-        const { select } = source;
-        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx as any);
-        select.orderBy ??= [];
-        select.orderBy.push(OrderByExpression.create({
-            target: exp
+        return this.extend(parameters, fx, (select, target) => ({
+            ... select,
+            orderBy: select.orderBy
+                ? [ ... select.orderBy, OrderByExpression.create({ target})]
+                : [OrderByExpression.create({ target})]
         }));
-        return new EntityQuery(source);
     }
     orderByDescending(parameters: any, fx: any): any {
-        const source = this.source.copy();
-        const { select } = source;
-        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx as any);
-        select.orderBy ??= [];
-        select.orderBy.push(OrderByExpression.create({
-            target: exp,
-            descending: true
+        const descending = true;
+        return this.extend(parameters, fx, (select, target) => ({
+            ... select,
+            orderBy: select.orderBy
+                ? [ ... select.orderBy, OrderByExpression.create({ target, descending })]
+                : [OrderByExpression.create({ target, descending })]
         }));
-        return new EntityQuery(source);
     }
 
     limit(n: number): any {
-        const source = this.source.copy();
-        const { select } = source;
-        select.limit = n;
-        return new EntityQuery(source);
+        return new EntityQuery({ ... this, selectStatement: { ... this.selectStatement, limit: n} });
     }
 
     offset(n: number): any {
-        const source = this.source.copy();
-        const { select } = source;
-        select.offset = n;
-        return new EntityQuery(source);
+        return new EntityQuery({ ... this, selectStatement: { ... this.selectStatement, offset: n} });
     }
 
     async count(parameters?:any, fx?: any): Promise<number> {
@@ -123,10 +177,7 @@ export default class EntityQuery<T = any>
             return this.where(parameters, fx).count();
         }
 
-        const source = this.source.copy();
-        const { select } = source;
-
-        select.fields = [
+        const select = { ... this.selectStatement, fields: [
             ExpressionAs.create({
                 expression: CallExpression.create({
                     callee: Identifier.create({ value: "COUNT"}),
@@ -134,10 +185,12 @@ export default class EntityQuery<T = any>
                 }),
                 alias: QuotedLiteral.create({ literal: "count" })
             })
-        ];
+        ] };
 
-        const query = this.source.context.driver.compiler.compileExpression(select);
-        const reader = await this.source.context.driver.executeReader(query);
+        const nq = new EntityQuery({ ... this, selectStatement: select });
+
+        const query = this.context.driver.compiler.compileExpression(nq, select);
+        const reader = await this.context.driver.executeReader(query);
 
         try {
             for await (const iterator of reader.next()) {
@@ -149,4 +202,10 @@ export default class EntityQuery<T = any>
 
     }
 
+    private extend(parameters: any, fx: any, map: (select: SelectStatement, exp: Expression) => SelectStatement) {
+        const exp = this.context.driver.compiler.compile(this, fx);
+        exp.params[0].value = parameters;
+        return new EntityQuery({ ... this, selectStatement: map(this.selectStatement, exp.body)});
+    }
+
 }

package/src/model/EntitySource.ts

@@ -1,25 +1,12 @@
 import type EntityContext from "./EntityContext.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type { IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
-import { BinaryExpression, Expression, ExpressionAs, QuotedLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
+import { Expression } from "../query/ast/Expressions.js";
 import EntityQuery from "./EntityQuery.js";
-import TimedCache from "../common/cache/TimedCache.js";
 import { contextSymbol, modelSymbol } from "../common/symbols/symbols.js";
-import { SourceExpression } from "./SourceExpression.js";
-
-const modelCache = new TimedCache<any, SelectStatement>();
 
 export class EntitySource<T = any> {
 
-
-    public readonly filters: {
-        read?: () => IFilterExpression;
-        modify?: () => IFilterExpression;
-        delete?: () => IFilterExpression;
-        include?: () => IFilterExpression;
-    } = {};
-
-
     get [modelSymbol]() {
         return this.model;
     }
@@ -37,7 +24,7 @@ export class EntitySource<T = any> {
 
     }
 
-    public add(item: Partial<T>) {
+    public add(item: Partial<T>): T {
         const p = Object.getPrototypeOf(item).constructor;
         if (!p || p === Object) {
             Object.setPrototypeOf(item, this.model.typeClass.prototype);
@@ -47,45 +34,50 @@ export class EntitySource<T = any> {
             throw new Error("Entity is already attached to the context");
         }
         entry.status = "inserted";
-        return item as T;
+        return entry.entity;
+    }
+
+    /**
+     * Entity can only be deleted if all primary keys are present
+     * @param item entity to delete
+     */
+    public delete(item: Partial<T>) {
+        const p = Object.getPrototypeOf(item).constructor;
+        if (!p || p === Object) {
+            Object.setPrototypeOf(item, this.model.typeClass.prototype);
+        }
+        const entry = this.context.changeSet.getEntry(item);
+        if (entry.status !== "detached" && entry.status !== "unchanged") {
+            throw new Error("Entity is already attached to the context");
+        }
+        entry.status = "deleted";
+        return entry.entity;
     }
 
     public all(): IEntityQuery<T> {
-        const { model, context } = this;
-        const select = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
-        return new EntityQuery<T>(SourceExpression.create({
-            alias: select.as.literal,
-            context,
-            model,
-            select
-        })) as IEntityQuery<T>;
+        return this.asQuery();
+    }
+
+    public filtered(mode: "read" | "modify" = "read"): IEntityQuery<T> {
+        const query = this.asQuery();
+        const events = this.context.eventsFor(this.model.typeClass, true);
+        return mode === "modify" ? events.modify(query) : events.filter(query);
     }
 
     public where<P>(...[parameter, fx]: IFilterExpression<P, T>) {
+        return this.asQuery().where(parameter, fx);
+    }
+
+    public asQuery() {
         const { model, context } = this;
-        const select = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
-        return new EntityQuery<T>(SourceExpression.create({
-            alias: select.as.literal,
+        const selectStatement = this.model.selectAllFields();
+        selectStatement.model = model;
+        return new EntityQuery<T>({
             context,
-            model,
-            select
-        })).where(parameter, fx) as IEntityQuery<T>;
-    }
+            type: model,
+            selectStatement
+        }) as any as IEntityQuery<T>;
 
-    generateModel(): SelectStatement {
-        const source = this.model.fullyQualifiedName;
-        const as = QuotedLiteral.create({ literal: this.model.name[0] + "1" });
-        const fields = this.model.columns.map((c) => c.name !== c.columnName
-            ? ExpressionAs.create({
-                expression: QuotedLiteral.propertyChain(as.literal, c.columnName),
-                alias: QuotedLiteral.create({ literal: c.name })
-            })
-            : QuotedLiteral.propertyChain(as.literal, c.columnName));
-        return SelectStatement.create({
-            source,
-            as,
-            fields,
-        });
     }
 
     public toQuery() {
@@ -93,6 +85,6 @@ export class EntitySource<T = any> {
         if(!filter) {
             return "";
         }
-        return this.context.driver.compiler.compileExpression(filter);
+        return this.context.driver.compiler.compileExpression( this.asQuery() as any, filter);
     }
 }

package/src/model/IFilterWithParameter.ts

@@ -11,6 +11,9 @@ export interface IBaseQuery<T> {
     firstOrFail(): Promise<T>;
     first(): Promise<T>;
 
+    select<P, TR>(parameters: P, fx: (p: P) => (x: T) => TR): IBaseQuery<TR>;
+    map<P, TR>(parameters: P, fx: (p: P) => (x: T) => TR): IBaseQuery<TR>;
+
     toArray(): Promise<T[]>;
 
     toQuery(): { text: string, values: any[]};
@@ -23,6 +26,8 @@ export interface IBaseQuery<T> {
     count<P>(parameters: P, fx: (p: P) => (x: T) => boolean): Promise<number>;
 
     withSignal<DT>(this:DT, signal: AbortSignal): DT;
+
+    include<TR>(fx: (x: T) => TR | TR[]): IBaseQuery<T>;
 }
 
 export interface IOrderedEntityQuery<T> extends IBaseQuery<T> {