@entity-access/entity-access 1.0.2 → 1.0.5

package/src/model/EntityQuery.ts

@@ -1,17 +1,37 @@
-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 EntityContext from "./EntityContext.js";
+import { IOrderedEntityQuery, IEntityQuery } from "./IFilterWithParameter.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 +40,13 @@ 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
+        }));
     }
 
     async toArray(): Promise<T[]> {
@@ -46,23 +58,32 @@ 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;
+            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);
                     yield entry.entity;
                     continue;
                 }
                 yield iterator as T;
             }
+        } catch(error) {
+            session.error(`Failed executing ${query?.text}\n${error.stack ?? error}`);
+            throw error;
         } finally {
-            await reader.dispose();
+            await scope.dispose();
         }
     }
 
@@ -70,7 +91,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 +101,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 +134,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 +142,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 +159,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,15 @@
 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, ExpressionAs, QuotedLiteral, SelectStatement } 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 +27,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,52 +37,68 @@ 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 where<P>(...[parameter, fx]: IFilterExpression<P, 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
-        })).where(parameter, fx) as IEntityQuery<T>;
+        return this.asQuery().where(parameter, fx);
     }
 
     generateModel(): SelectStatement {
         const source = this.model.fullyQualifiedName;
-        const as = QuotedLiteral.create({ literal: this.model.name[0] + "1" });
+        const as = Expression.parameter(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),
+                expression: Expression.member(as, c.columnName),
                 alias: QuotedLiteral.create({ literal: c.name })
             })
-            : QuotedLiteral.propertyChain(as.literal, c.columnName));
+            : Expression.member(as, c.columnName));
         return SelectStatement.create({
             source,
             as,
             fields,
+            names: JSON.stringify([as.name])
         });
     }
 
+    public asQuery() {
+        const { model, context } = this;
+        const selectStatement = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
+        selectStatement.model = model;
+        return new EntityQuery<T>({
+            context,
+            type: model,
+            selectStatement
+        }) as any as IEntityQuery<T>;
+
+    }
+
     public toQuery() {
         const filter = this.filter;
         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[]};

package/src/model/SourceExpression.ts

@@ -1,7 +1,7 @@
 import { modelSymbol } from "../common/symbols/symbols.js";
 import EntityType from "../entity-query/EntityType.js";
-import { BinaryExpression, Expression, ExpressionAs, Identifier, JoinExpression, MemberExpression, QuotedLiteral, SelectStatement } from "../query/ast/Expressions.js";
-import { ITextOrFunction } from "../query/ast/IStringTransformer.js";
+import { BinaryExpression, Expression, ExpressionAs, Identifier, JoinExpression, MemberExpression, ParameterExpression, QuotedLiteral, SelectStatement } from "../query/ast/Expressions.js";
+import { ITextQueryFragment, QueryParameter } from "../query/ast/IStringTransformer.js";
 import EntityContext from "./EntityContext.js";
 
 const sourceSymbol = Symbol("source");
@@ -12,9 +12,8 @@ export class SourceExpression {
         return new SourceExpression(p);
     }
 
-    signal: AbortSignal;
-    alias: string;
-    parameter?: string;
+    alias: ParameterExpression;
+    parameter?: ParameterExpression;
     context: EntityContext;
     model?: EntityType;
     include?: EntityType[];
@@ -59,31 +58,28 @@ export class SourceExpression {
             }
         }
         const column = relation.relation.fkColumn;
-        const parameter = this.parameter + "." + property;
+        const parameter = ParameterExpression.create({ name: this.parameter + "." + property});
         const source = this.addSource(model, parameter);
         const join = JoinExpression.create({
-            as: QuotedLiteral.create({ literal: source.alias}),
+            as: source.alias,
             joinType: column.nullable ? "LEFT" : "INNER",
             model,
             source: QuotedLiteral.create({ literal: model.name }),
-            where: BinaryExpression.create({
-                left: MemberExpression.create({
-                    target: Identifier.create({ value: this.alias }),
-                    property: Identifier.create({ value: column.columnName })
-                }),
-                operator: "=",
-                right: MemberExpression.create({
-                    target: Identifier.create({ value: source.alias }),
-                    property: Identifier.create({ value: model.keys[0].columnName })
-                })
-            })
+            where: Expression.logicalAnd(
+                Expression.member(
+                    this.alias,
+                    column.columnName),
+                Expression.member(
+                    source.alias,
+                    model.keys[0].columnName)
+            )
         });
         select.joins.push(join);
         join[sourceSymbol] = source;
         return source;
     }
 
-    addSource(model: EntityType, parameter: string) {
+    addSource(model: EntityType, parameter: ParameterExpression) {
 
         const { context } = this;
         const source = SourceExpression.create({
@@ -105,15 +101,15 @@ export class SourceExpression {
                 break;
             }
         }while (true);
-        source.alias = alias;
+        source.alias = ParameterExpression.create({ name: alias });
         this.map.set(alias, source);
-        this.paramMap.set(parameter, source);
+        this.paramMap.set(parameter.name, source);
         return source;
     }
 
-    flatten(chain: string[]): ITextOrFunction {
+    flatten(chain: string[]): ITextQueryFragment {
         const [start, ... others ] = chain;
-        if (start === this.parameter) {
+        if (start === this.parameter.name) {
             return this.prepareNames(others);
         }
         const mapped = this.paramMap.get(start);
@@ -123,11 +119,11 @@ export class SourceExpression {
         throw new Error("Not found");
     }
 
-    prepareNames([property , ... others]: string[]): ITextOrFunction {
+    prepareNames([property , ... others]: string[]): ITextQueryFragment {
         const p = this.model.getProperty(property);
         const quotedLiteral = this.context.driver.compiler.quotedLiteral;
         if (others.length === 0) {
-            return `${quotedLiteral(this.alias)}.${quotedLiteral(p.field.columnName)}`;
+            return `${ QueryParameter.create(() => this.alias.name, quotedLiteral)}.${quotedLiteral(p.field.columnName)}`;
         }
 
         // this must be a navigation...

package/src/model/{ChangeEntry.ts → changes/ChangeEntry.ts}

@@ -1,5 +1,5 @@
-import { IColumn } from "../decorators/IColumn.js";
-import EntityType from "../entity-query/EntityType.js";
+import { IColumn } from "../../decorators/IColumn.js";
+import EntityType from "../../entity-query/EntityType.js";
 import type ChangeSet from "./ChangeSet.js";
 import { privateUpdateEntry } from "./ChangeSet.js";
 
@@ -31,17 +31,24 @@ export default class ChangeEntry implements IChanges {
 
     private pending: (() => void)[];
 
+    private dependents: ChangeEntry[];
+
     constructor(p: IChanges, changeSet: ChangeSet) {
         Object.setPrototypeOf(p, ChangeEntry.prototype);
         const ce = p as ChangeEntry;
         ce.changeSet = changeSet;
         ce.pending = [];
+        ce.dependents = [];
         ce.modified = new Map();
         return ce;
     }
 
     public detect() {
 
+        if (this.status === "deleted") {
+            return;
+        }
+
         const { type: { columns }, entity, original } = this;
 
         if (original === void 0) {
@@ -76,6 +83,15 @@ export default class ChangeEntry implements IChanges {
         // apply values to main entity
         // set status to unchanged
 
+        if(this.status === "deleted") {
+            // remove...
+            for (const iterator of this.pending) {
+                iterator();
+            }
+            this.changeSet[privateUpdateEntry](this);
+            return;
+        }
+
         // we will only apply the columns defined
         if (dbValues !== void 0) {
             for (const iterator of this.type.columns) {
@@ -95,6 +111,7 @@ export default class ChangeEntry implements IChanges {
 
         this.pending.length = 0;
         this.original = { ... this.entity };
+
         this.status = "unchanged";
         this.modified.clear();
     }
@@ -120,7 +137,15 @@ export default class ChangeEntry implements IChanges {
 
             const keyValue = related[rKey.name];
             if (keyValue === void 0) {
+
+                relatedChanges.dependents.push(this);
+
                 this.order++;
+
+                for (const d of this.dependents) {
+                    d.order++;
+                }
+
                 const fk = iterator;
                 relatedChanges.pending.push(() => {
                     this.entity[fk.fkColumn.name] = related[rKey.name];
@@ -134,10 +159,12 @@ export default class ChangeEntry implements IChanges {
     }
 
     setupInverseProperties() {
+        const deleted = this.status === "deleted";
         for (const iterator of this.type.relations) {
             if (!iterator.isCollection) {
                 continue;
             }
+            const { relatedName } = iterator;
             const related = this.entity[iterator.name];
             if (related === void 0) {
                 continue;
@@ -148,7 +175,10 @@ export default class ChangeEntry implements IChanges {
                 }
                 continue;
             }
-            related[iterator.relatedName] = this.entity;
+            related[relatedName] = this.entity;
+            if (deleted) {
+                this.pending.push(() => delete related[relatedName]);
+            }
         }
     }
 }

package/src/model/{ChangeSet.ts → changes/ChangeSet.ts}

@@ -1,14 +1,7 @@
-import type EntityContext from "./EntityContext.js";
-import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import SchemaRegistry from "../../decorators/SchemaRegistry.js";
+import EntityContext from "../EntityContext.js";
+import IdentityService from "../identity/IdentityService.js";
 import ChangeEntry from "./ChangeEntry.js";
-import { IRecord } from "../drivers/base/BaseDriver.js";
-import IdentityService from "./IdentityService.js";
-
-const entrySymbol = Symbol("entry");
-
-const identitySymbol = Symbol("identity");
-
-const getEntityByIdentity = Symbol("getEntityByIdentity");
 
 export const privateUpdateEntry = Symbol("updateEntry");
 
@@ -32,6 +25,15 @@ export default class ChangeSet {
     [privateUpdateEntry](entry: ChangeEntry) {
         const jsonKey = IdentityService.getIdentity(entry.entity);
         if (jsonKey) {
+            if (entry.status === "deleted") {
+                this.identityMap.delete(jsonKey);
+                const index = this.entries.indexOf(entry);
+                if (index !== -1) {
+                    this.entries.splice(index, 1);
+                }
+                this.entryMap.delete(entry.entity);
+                return;
+            }
             this.identityMap.set(jsonKey, entry.entity);
         }
     }
@@ -62,7 +64,6 @@ export default class ChangeSet {
             original: original ? { ... original } : void 0,
             status: "unchanged"
         }, this);
-        entity[entrySymbol] = entry;
         this.entries.push(entry);
         this.entryMap.set(entity, entry);
         return entry;

package/src/model/events/ContextEvents.ts

@@ -0,0 +1,26 @@
+import { IClassOf } from "../../decorators/IClassOf.js";
+import { ServiceProvider } from "../../di/di.js";
+import { NotSupportedError } from "../../query/parser/NotSupportedError.js";
+import type EntityContext from "../EntityContext.js";
+import type EntityEvents from "./EntityEvents.js";
+
+export default class ContextEvents {
+
+    private map: Map<any, IClassOf<EntityEvents<any>>> = new Map();
+
+    public for<T>(type: IClassOf<T>, fail = true): IClassOf<EntityEvents<T>> {
+        const typeClass = this.map.get(type);
+        if (!typeClass) {
+            if (fail) {
+                throw new NotSupportedError();
+            }
+            return null;
+        }
+        return typeClass;
+    }
+
+    public register<T>(type: IClassOf<T>, events: IClassOf<EntityEvents<T>>) {
+        this.map.set(type, events);
+    }
+
+}