@entity-access/entity-access 1.0.2 → 1.0.6

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();
     }
@@ -103,7 +120,7 @@ export default class ChangeEntry implements IChanges {
         const { type: { relations }, entity } = this;
         // for parent relations.. check if related key is set or not...
         for (const iterator of relations) {
-            if (iterator.isCollection) {
+            if (iterator.isInverseRelation) {
                 continue;
             }
 
@@ -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) {
+            if (!iterator.isInverseRelation) {
                 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, { identityMapSymbol } 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");
 
@@ -16,6 +9,10 @@ export default class ChangeSet {
 
     public readonly entries: ChangeEntry[] = [];
 
+    get [identityMapSymbol]() {
+        return this.identityMap;
+    }
+
     private entryMap: Map<any, ChangeEntry> = new Map();
 
     /**
@@ -32,6 +29,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 +68,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);
+    }
+
+}

package/src/model/events/EntityEvents.ts

@@ -0,0 +1,96 @@
+import { IClassOf } from "../../decorators/IClassOf.js";
+import NameParser from "../../decorators/parser/NameParser.js";
+import Inject from "../../di/di.js";
+import type  EntityType from "../../entity-query/EntityType.js";
+import type EntityContext from "../EntityContext.js";
+import { IEntityQuery } from "../IFilterWithParameter.js";
+import ChangeEntry from "../changes/ChangeEntry.js";
+
+const done = Promise.resolve() as Promise<void>;
+
+export class ForeignKeyFilter<T = any, TE = any> {
+
+    public type: EntityType;
+    public name: string;
+    public fkName: string;
+
+    private events: EntityEvents<TE>;
+    private context: EntityContext;
+
+    constructor(p: Partial<ForeignKeyFilter> & { context: EntityContext, events: EntityEvents<any> }) {
+        Object.setPrototypeOf(p, ForeignKeyFilter.prototype);
+        return p as any as ForeignKeyFilter;
+    }
+
+    public is<TR>(fx: (x: T) => TR): this is ForeignKeyFilter<T, TR> & boolean {
+        const name = NameParser.parseMember(fx);
+        return name === this.fkName || name === this.name;
+    }
+
+    public read(): IEntityQuery<TE> {
+        const read = this.context.query(this.type.typeClass);
+        return this.events.filter(read);
+    }
+
+    public unfiltered(): IEntityQuery<TE> {
+        return this.context.query(this.type.typeClass);
+    }
+
+    public modify(): IEntityQuery<TE> {
+        const read = this.context.query(this.type.typeClass);
+        return this.events.modify(read);
+    }
+}
+
+
+export default abstract class EntityEvents<T> {
+
+    filter(query: IEntityQuery<T>) {
+        return query;
+    }
+
+    includeFilter(query: IEntityQuery<T>, type?: any, key?: string) {
+        return this.filter(query);
+    }
+
+    modify(query: IEntityQuery<T>) {
+        return this.filter(query);
+    }
+
+    delete(query: IEntityQuery<T>) {
+        return this.modify(query);
+    }
+
+    beforeInsert(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    onForeignKeyFilter(filter: ForeignKeyFilter<T>) {
+        return filter.modify();
+    }
+
+    afterInsert(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    beforeUpdate(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    afterUpdate(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    beforeDelete(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    afterDelete(entity: T, entry: ChangeEntry) {
+        return done;
+    }
+
+    beforeJson(entity: T) {
+        return entity;
+    }
+
+}

package/src/model/{IdentityService.ts → identity/IdentityService.ts}

@@ -1,7 +1,15 @@
-import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import SchemaRegistry from "../../decorators/SchemaRegistry.js";
+import type EntityType from "../../entity-query/EntityType.js";
+
+export const identityMapSymbol = Symbol("identityMapSymbol");
 
 export default class IdentityService {
 
+    public static buildIdentity(model: EntityType, ... keys: any[]) {
+        const type = model.name;
+        return JSON.stringify({ type, keys });
+    }
+
     public static getIdentity(entity) {
         const entityType = SchemaRegistry.model(Object.getPrototypeOf(entity).constructor);
         const keys = [];

package/src/model/identity/RelationMapper.ts

@@ -0,0 +1,71 @@
+import type ChangeEntry from "../changes/ChangeEntry.js";
+import type ChangeSet from "../changes/ChangeSet.js";
+import IdentityService, { identityMapSymbol } from "./IdentityService.js";
+
+export default class RelationMapper {
+
+    private map: Map<string, ChangeEntry[]> = new Map();
+
+    constructor(
+        private changeSet: ChangeSet,
+        private identityMap: Map<string, ChangeEntry> = changeSet[identityMapSymbol]
+    ) {
+
+    }
+
+    push(id: string, waiter: ChangeEntry) {
+        let queue = this.map.get(id);
+        if (!queue) {
+            queue = [];
+            this.map.set(id, queue);
+        }
+        queue.push(waiter);
+    }
+
+    fix(entry: ChangeEntry, nest = true) {
+
+        // find all parents...
+        const { type, entity } = entry;
+        for (const iterator of type.relations) {
+            if (iterator.isInverseRelation) {
+                continue;
+            }
+            const fkColumn = iterator.fkColumn.name;
+            const fkValue = entity[fkColumn];
+            if (fkValue === void 0) {
+                continue;
+            }
+            // get from identity...
+            const id = IdentityService.buildIdentity(iterator.relatedEntity, fkValue);
+            const parent = this.identityMap.get(id);
+            if (!parent) {
+                let waiters = this.map.get(id);
+                if (!waiters) {
+                    waiters = [];
+                    this.map.set(id, waiters);
+                }
+                waiters.push(entry);
+                continue;
+            }
+            entity[iterator.name] = parent;
+
+            const coll = (parent[iterator.relatedRelation.name] ??= []) as any[];
+            if(!coll.includes(entity)){
+                coll.push(entity);
+            }
+        }
+
+        if (!nest) {
+            return;
+        }
+
+        // see if anyone is waiting for us or not...
+        const identity = IdentityService.getIdentity(entry.entity);
+        const pending = this.map.get(identity);
+        if (pending && pending.length) {
+            for (const iterator of pending) {
+                this.fix(iterator, false);
+            }
+        }
+    }
+}

package/src/model/symbols.ts

@@ -0,0 +1 @@
+export const existsQuery = Symbol("existsQuery");

package/src/model/verification/VerificationSession.ts

@@ -0,0 +1,173 @@
+import EntityAccessError from "../../common/EntityAccessError.js";
+import Logger from "../../common/Logger.js";
+import { TypeInfo } from "../../common/TypeInfo.js";
+import { IEntityRelation } from "../../decorators/IColumn.js";
+import { ServiceProvider } from "../../di/di.js";
+import EntityType from "../../entity-query/EntityType.js";
+import { ConditionalExpression, Constant, ExistsExpression, Expression, Identifier, ParameterExpression, QuotedLiteral, SelectStatement, TemplateLiteral, ValuesStatement } from "../../query/ast/Expressions.js";
+import EntityContext from "../EntityContext.js";
+import EntityQuery from "../EntityQuery.js";
+import ChangeEntry from "../changes/ChangeEntry.js";
+import EntityEvents, { ForeignKeyFilter } from "../events/EntityEvents.js";
+
+type KeyValueArray = [string, any][];
+
+export default class VerificationSession {
+
+    private select: SelectStatement;
+
+    private field: ConditionalExpression[];
+
+    constructor(private context: EntityContext) {
+
+        this.select = SelectStatement.create({});
+    }
+
+    queueVerification(change: ChangeEntry, events: EntityEvents<any>) {
+        const { type, entity } = change;
+        if (change.status !== "inserted") {
+            // verify access to the entity
+            const keys = [] as KeyValueArray;
+            for (const iterator of type.keys) {
+                const key = entity[iterator.name];
+                if (key === void 0) {
+                    break;
+                }
+                keys.push([iterator.columnName, key]);
+            }
+            if (keys.length === type.keys.length) {
+                this.queueEntityKey(change, keys, events);
+            }
+        }
+
+        if (change.status === "deleted") {
+            return;
+        }
+
+        // for modified or inserted
+        // we need to verify access to each foreign key
+
+        for (const relation of type.relations) {
+            if (relation.isInverseRelation) {
+                continue;
+            }
+
+            const fk = relation.fkColumn;
+            if (!fk) {
+                continue;
+            }
+
+            const fkValue = entity[fk.name];
+            if (fkValue === void 0) {
+                // not set... ignore..
+                continue;
+            }
+            this.queueEntityForeignKey(change, relation, fkValue);
+        }
+    }
+    queueEntityForeignKey(change: ChangeEntry, relation: IEntityRelation, value) {
+        const relatedModel = relation.relatedEntity;
+        const type = relation.relatedEntity.typeClass;
+        const events = this.context.eventsFor(change.type.typeClass);
+        const relatedEvents = this.context.eventsFor(relation.relatedEntity.typeClass);
+        const context = this.context;
+        const fk = new ForeignKeyFilter({
+            context,
+            events: relatedEvents,
+            type: relatedModel,
+            name: relation.name,
+            fkName: relation.fkColumn.name
+        });
+        let query = events.onForeignKeyFilter(fk);
+        if (query === void 0) {
+            query = fk.modify();
+        }
+        if (query === null) {
+            return;
+        }
+
+        const eq = query as EntityQuery;
+        const compare = Expression.equal(
+            Expression.member(eq.selectStatement.as, relatedModel.keys[0].columnName),
+            Expression.constant(value)
+        );
+        const typeName  = TypeInfo.nameOfType(type);
+        this.addError(query as EntityQuery, compare , `Unable to access entity ${typeName} through foreign key ${TypeInfo.nameOfType(change.type)}.${relation.name}.\n`);
+    }
+
+    queueEntityKey(change: ChangeEntry, keys: KeyValueArray, events: EntityEvents<any>) {
+        const type = change.type.typeClass;
+        let query = this.context.query(type);
+        query = change.status === "modified" ? events.modify(query) : events.delete(query);
+        if (!query) {
+            return;
+        }
+        let compare: Expression;
+        const eq = query as EntityQuery;
+        for (const [key, value] of keys) {
+            const test = Expression.equal(
+                Expression.member(eq.selectStatement.as, Expression.quotedLiteral(key)),
+                Expression.constant(value)
+            );
+            compare = compare
+                ? Expression.logicalAnd(compare, test)
+                : test;
+        }
+        const typeName = TypeInfo.nameOfType(type);
+        this.addError(query  as EntityQuery, compare, `Unable to access entity ${typeName}.\n`);
+    }
+
+    async verifyAsync(): Promise<any> {
+        if (!this.field?.length) {
+            return;
+        }
+        this.select.fields =[
+            Expression.as(Expression.templateLiteral(this.field), "error")
+        ];
+        this.select.as = ParameterExpression.create({ name: "x"});
+        const source = ValuesStatement.create({
+            values: [
+                [Identifier.create({ value: "1"})]
+            ],
+            as: QuotedLiteral.create({ literal: "a"}),
+            fields: [QuotedLiteral.create({ literal: "a"})]
+        });
+        this.select.source = source;
+        const compiler = this.context.driver.compiler;
+        const query = compiler.compileExpression(null, this.select);
+        const logger = ServiceProvider.resolve(this.context, Logger);
+        const session = logger.newSession();
+        try {
+            const { rows: [ { error }]} = await this.context.driver.executeQuery(query);
+            if (error) {
+                session.error(`Failed executing ${query.text}\n[${query.values.join(",")}]\n${error?.stack ?? error}`);
+                EntityAccessError.throw(error);
+            }
+        } finally {
+            session.dispose();
+        }
+    }
+
+    addError(query: EntityQuery, compare: Expression, error: string) {
+        const select = { ... query.selectStatement};
+        select.fields = [
+            Expression.identifier("1")
+        ];
+
+        const where = select.where
+            ? Expression.logicalAnd(select.where, compare)
+            : compare;
+
+        select.where = where;
+
+        const text = ConditionalExpression.create({
+            test: ExistsExpression.create({
+                target: select
+            }),
+            consequent: Expression.constant(""),
+            alternate: Expression.constant(error),
+        });
+
+        (this.field ??=[]).push(text);
+    }
+}