@entity-access/entity-access 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entity-access/entity-access",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/common/cache/TimedCache.ts

@@ -11,10 +11,10 @@ export default class TimedCache<TKey = any, T = any> {
         this.map.delete(key);
     }
 
-    getOrCreate(key: TKey, factory: (k: TKey) => T, ttl: number = 15000) {
+    getOrCreate<TP>(key: TKey, p1: TP, factory: (k: TKey,p: TP) => T, ttl: number = 15000) {
         let item = this.map.get(key);
         if (!item) {
-            item = { value: factory(key), ttl, expire: Date.now() + ttl };
+            item = { value: factory(key, p1), ttl, expire: Date.now() + ttl };
             this.map.set(key, item);
         } else {
             item.expire = Date.now() + ttl;

package/src/decorators/IColumn.ts

@@ -45,6 +45,8 @@ export interface IEntityRelation {
      */
     name: string;
 
+    isInverseRelation?: boolean;
+
     isCollection?: boolean;
 
 

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

@@ -47,25 +47,11 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
 
     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;
-            }
-        }
+        this.prepareStatement(e);
 
         const orderBy = e.orderBy?.length > 0 ? prepare `\n\t\tORDER BY ${this.visitArray(e.orderBy)}` : "";
         const where = e.where ? prepare `\n\tWHERE ${this.visit(e.where)}` : "";
-        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins)}` : [];
+        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins, "\n")}` : [];
 
         const fields = this.visitArray(e.fields, ",\n\t\t");
 

package/src/entity-query/EntityType.ts

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

package/src/model/EntityQuery.ts

@@ -3,8 +3,10 @@ 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> {
@@ -49,6 +51,14 @@ export default class EntityQuery<T = any>
         }));
     }
 
+    include(p: any): any {
+        const selectStatement = QueryExpander.expand(this.context, { ... this.selectStatement }, p);
+        return new EntityQuery({
+            ... this,
+            selectStatement
+        });
+    }
+
     async toArray(): Promise<T[]> {
         const results: T[] = [];
         for await (const iterator of this.enumerate()) {
@@ -66,6 +76,20 @@ export default class EntityQuery<T = any>
             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);
@@ -74,11 +98,13 @@ export default class EntityQuery<T = any>
                     Object.setPrototypeOf(iterator, type.typeClass.prototype);
                     // set identity...
                     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;
@@ -87,6 +113,23 @@ export default class EntityQuery<T = any>
         }
     }
 
+    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();
+        }
+    }
+
     async firstOrFail(): Promise<T> {
         for await(const iterator of this.limit(1).enumerate()) {
             return iterator;

package/src/model/EntitySource.ts

@@ -1,13 +1,10 @@
 import type EntityContext from "./EntityContext.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type { IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
-import { Expression, ExpressionAs, QuotedLiteral, SelectStatement } 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";
 
-const modelCache = new TimedCache<any, SelectStatement>();
-
 export class EntitySource<T = any> {
 
     get [modelSymbol]() {
@@ -61,30 +58,19 @@ export class EntitySource<T = any> {
         return this.asQuery();
     }
 
-    public where<P>(...[parameter, fx]: IFilterExpression<P, T>) {
-        return this.asQuery().where(parameter, fx);
+    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);
     }
 
-    generateModel(): SelectStatement {
-        const source = this.model.fullyQualifiedName;
-        const as = Expression.parameter(this.model.name[0] + "1");
-        const fields = this.model.columns.map((c) => c.name !== c.columnName
-            ? ExpressionAs.create({
-                expression: Expression.member(as, c.columnName),
-                alias: QuotedLiteral.create({ literal: c.name })
-            })
-            : Expression.member(as, c.columnName));
-        return SelectStatement.create({
-            source,
-            as,
-            fields,
-            names: JSON.stringify([as.name])
-        });
+    public where<P>(...[parameter, fx]: IFilterExpression<P, T>) {
+        return this.asQuery().where(parameter, fx);
     }
 
     public asQuery() {
         const { model, context } = this;
-        const selectStatement = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
+        const selectStatement = this.model.selectAllFields();
         selectStatement.model = model;
         return new EntityQuery<T>({
             context,

package/src/model/IFilterWithParameter.ts

@@ -26,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> {

package/src/model/changes/ChangeEntry.ts

@@ -120,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;
             }
 
@@ -161,7 +161,7 @@ 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;

package/src/model/changes/ChangeSet.ts

@@ -1,6 +1,6 @@
 import SchemaRegistry from "../../decorators/SchemaRegistry.js";
 import EntityContext from "../EntityContext.js";
-import IdentityService from "../identity/IdentityService.js";
+import IdentityService, { identityMapSymbol } from "../identity/IdentityService.js";
 import ChangeEntry from "./ChangeEntry.js";
 
 export const privateUpdateEntry = Symbol("updateEntry");
@@ -9,6 +9,10 @@ export default class ChangeSet {
 
     public readonly entries: ChangeEntry[] = [];
 
+    get [identityMapSymbol]() {
+        return this.identityMap;
+    }
+
     private entryMap: Map<any, ChangeEntry> = new Map();
 
     /**

package/src/model/events/EntityEvents.ts

@@ -8,13 +8,13 @@ import ChangeEntry from "../changes/ChangeEntry.js";
 
 const done = Promise.resolve() as Promise<void>;
 
-export class ForeignKeyFilter<T = any> {
+export class ForeignKeyFilter<T = any, TE = any> {
 
     public type: EntityType;
     public name: string;
     public fkName: string;
 
-    private events: EntityEvents<any>;
+    private events: EntityEvents<TE>;
     private context: EntityContext;
 
     constructor(p: Partial<ForeignKeyFilter> & { context: EntityContext, events: EntityEvents<any> }) {
@@ -22,17 +22,21 @@ export class ForeignKeyFilter<T = any> {
         return p as any as ForeignKeyFilter;
     }
 
-    public is<TR>(fx: (x: T) => TR): boolean {
+    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() {
+    public read(): IEntityQuery<TE> {
         const read = this.context.query(this.type.typeClass);
         return this.events.filter(read);
     }
 
-    public modify() {
+    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);
     }

package/src/model/identity/IdentityService.ts

@@ -1,7 +1,15 @@
 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/verification/VerificationSession.ts

@@ -48,7 +48,7 @@ export default class VerificationSession {
         // we need to verify access to each foreign key
 
         for (const relation of type.relations) {
-            if (relation.isCollection) {
+            if (relation.isInverseRelation) {
                 continue;
             }
 

package/src/query/ast/DebugStringVisitor.ts

@@ -1,4 +1,4 @@
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, ParameterExpression, QuotedLiteral, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import Visitor from "./Visitor.js";
 
 const isBinary = (type) => /^(BinaryExpression|CoalesceExpression)$/.test(type);
@@ -47,7 +47,7 @@ export default class DebugStringVisitor extends Visitor<string> {
     }
 
     visitConditionalExpression(e: ConditionalExpression): string {
-        return `${e.test} ? ${e.consequent} : ${e.alternate}`;
+        return `${this.visit(e.test)} ? ${this.visit(e.consequent)} : ${this.visit(e.alternate)}`;
     }
 
     visitConstant(e: Constant): string {
@@ -55,7 +55,7 @@ export default class DebugStringVisitor extends Visitor<string> {
     }
 
     visitExpressionAs(e: ExpressionAs): string {
-        return `${e.expression} as ${e.alias}`;
+        return `${this.visit(e.expression)} as ${this.visit(e.alias)}`;
     }
 
     visitIdentifier(e: Identifier): string {
@@ -94,7 +94,7 @@ export default class DebugStringVisitor extends Visitor<string> {
     }
 
     visitStringLiteral(e: StringLiteral): string {
-        return `"${e.value}"`;
+        return `'${e.value}'`;
     }
 
     visitTemplateElement(e: TemplateElement): string {
@@ -122,6 +122,53 @@ export default class DebugStringVisitor extends Visitor<string> {
         return "`" + items.join("") + "`";
     }
 
+    visitDeleteStatement(e: DeleteStatement): string {
+        if (e.where) {
+            return `DELETE FROM ${this.visit(e.table)} WHERE ${this.visit(e.where)}`;
+        }
+        return `DELETE FROM ${this.visit(e.table)}`;
+    }
+
+    visitExistsExpression(e: ExistsExpression): string {
+        return `EXISTS (${this.visit(e.target)})`;
+    }
+
+    visitInsertStatement(e: InsertStatement): string {
+        return `INSERT INTO ${this.visit(e.table)} ${e.values} ${this.visit(e.returnValues)}`;
+    }
+
+    visitJoinExpression(e: JoinExpression): string {
+        return `\n${e.joinType} JOIN ${this.visit(e.source)}\n\t\tON ${this.visit(e.where)}\n`;
+    }
+
+    visitOrderByExpression(e: OrderByExpression): string {
+        return `${e.target} ${e.descending ? "DESC" : "ASC"}`;
+    }
+
+    visitReturnUpdated(e: ReturnUpdated): string {
+        return `\nRETURNING ${this.visitArray(e.fields)}`;
+    }
+
+    visitValuesStatement(e: ValuesStatement): string {
+        const rows = e.values.map((x) => `(${this.visit(x[0])})`).join(",\n\t");
+        return `(VALUES ${rows}) as ${this.visit(e.as)})`;
+    }
+
+    visitSelectStatement(e: SelectStatement): string {
+        const select = `SELECT\n\t${this.visitArray(e.fields, ",\n\t")}\n\tFROM ${this.visit(e.source)}`;
+        const as = e.as ? this.visit(e.as): "";
+        const joins = e.joins?.length > 0 ? this.visitArray(e.joins, "\n\t") : "";
+        const where = e.where ? `\n\tWHERE ${this.visit(e.where)}` : "";
+        const orderBy = e.orderBy ? `\n\tORDER BY ${this.visitArray(e.orderBy, "\n\t\tTHEN BY")}`: "";
+        const limit = e.limit > 0 ? `\n\tLIMIT ${e.limit}` : "";
+        const offset = e.offset > 0 ? `\n\OFFSET ${e.offset}` : "";
+        return `${select}${as}${joins}${where}${orderBy}${limit}${offset}`;
+    }
+
+    visitUpdateStatement(e: UpdateStatement): string {
+        return "UPDATE";
+    }
+
     private visitArray(e: Expression[], separator = ", ") {
         return e.map((x) => this.visit(x)).join(separator);
     }