@entity-access/entity-access 1.0.2 → 1.0.6

package/.github/workflows/node.yml

@@ -1,6 +1,11 @@
 name: Build
 
-on: push
+on:
+  push:
+    branches-ignore:
+      - 'feature/**'
+    tags-ignore:
+      - '*'
 
 jobs:
   build:
@@ -38,7 +43,7 @@ jobs:
       - run: npm install
       - run: npm install -D typescript
       - run: tsc
-      - run: npm run test-db
+      - run: npm run test
         env:
           POSTGRES_HOST: localhost
           POSTGRES_PORT: 5432

package/.vscode/settings.json

@@ -33,6 +33,7 @@
         "PGPASSWORD",
         "PGPORT",
         "PGUSER",
+        "quasis",
         "sysdatabases",
         "varbinary"
     ]

package/README.md

@@ -5,7 +5,7 @@ Inspired from Entity Framework Core, Entity Access is ORM for JavaScript runtime
 
 # Project Status
 1. Beta - Postgres Driver
-2. Alpha - Sql Server Driver
+2. Beta - Sql Server Driver
 
 ## Features
 1. Unit of Work and Repository Pattern
@@ -15,6 +15,7 @@ Inspired from Entity Framework Core, Entity Access is ORM for JavaScript runtime
 5. Postgres Driver
 6. Sql Server Driver
 7. Automatic parameterization to safeguard sql injection attacks.
+8. Context Filters - This is a new concept where you can setup filters that will be used against saving/retrieving data.
 
 ## Upcoming Features
 1. Include
@@ -38,6 +39,22 @@ db.orders.add({
 
 // save all in single transaction
 await db.saveChanges();
+
+
+const existingOrderItem1: OrderItem;
+const existingOrderItem2: OrderItem;
+
+existingOrderItem2.status = "cancelled";
+existingOrderItem1.status = "cancelled";
+// executes update statements in single transaction
+await db.saveChanges();
+
+
+db.orderItems.delete(existingOrderItem1);
+db.orderItems.delete(existingOrderItem2);
+// executes delete statements in single transaction
+await db.saveChanges();
+
 ```
 
 ### Arrow function based query features
@@ -52,11 +69,34 @@ Simple Query
 ```typescript
 const db = new ShoppingContext();
 
-/// first parameter is set of parameters to pass to the query
-/// the reason it is first, is to help in intellisense.
-
-/// second parameter is an arrow function which returns a filter
-const q = db.orders.where({ userID }, (params) => (order) => order.userID === p.userID);
+// find customer from orderID
+const q = db.customers
+    // first we will send parameters
+    .where({ orderID },
+        // second we will write an arrow
+        // accepting parameters
+        (p) =>
+            // this is the arrow which will
+            // be converted to SQL
+            // you can write very limited set of
+            // expressions in this arrow function
+            (x) => x.orders.some(
+                // This will results in exists or join
+                // based on relations declared
+                (order) => order.orderID === p.orderID );
+const customer = await q.first();
+```
+Above expression will result in following filter expression
+```sql
+    SELECT c.firstName, c.lastName, c.customerID
+    FROM customers as c
+    EXISTS (
+        SELECT 1
+        FROM Orders as o1
+        WHERE x.customerID = o1.orderID
+            AND o1.orderID = $1
+    )
+    LIMIT 1;
 ```
 
 Query with Like operator
@@ -124,42 +164,32 @@ class OrderItem {
 
 ### Compare operators
 
+Only handful of operators are supported as of now.
+1. Equality Both `==`, `===`, will result in simple `=` operator in SQL. There is no type check performed and no conversion is performed to speed up
+execution. However, typescript will give you warning and compilation for mismatch of operands and you can convert them as needed. But for conversion
+use only `Sql.*` functions.
+2. Above also applies for operators `!=` and `!==`, they will result in `<>` in SQL.
+3. `+`, `-`, `*`, `/` operators will be sent to SQL as it is.
+4. For precedence, we recommend using brackets in the arrow functions as there might be differences in underlying database engine's preferences and you may not get correct results.
+5. Template Literals, will be sent to SQL as concat, however, please use
+conversion of non string to string type if underlying provider does not support direct conversion.
+6. Conversion methods, `Sql.cast.as*` methods will provide conversion from any type to desired type. `Sql.cast.asText` will convert to number to text.
+
 #### Equality
 Both strict and non strict equality will result in
 simple equality comparison in SQL. Database provider
 may or may not convert them correctly, so we recommend
 using helper functions to convert before comparison.
 ```typescript
-    // find all customer from orderID
     const q = db.customers
-        // first we will send parameters
         .where({ orderID },
-            // second we will write an arrow
-            // accepting parameters
             (p) =>
-                // this is the arrow which will
-                // be converted to SQL
-                // you can write very limited set of
-                // expressions in this arrow function
                 (x) => x.orders.some(
-                    // This will results in exists or join
-                    // based on what level of nested
-                    // foreign key references are available
                     (order) => order.orderID === p.orderID )
         )
 
 ```
 
-Above expression will result in following filter expression
-```sql
-    EXISTS (
-        SELECT 1
-        FROM Orders as o1
-        WHERE x.customerID = o1.orderID
-            AND o1.orderID = $1
-    )
-```
-
 #### Like
 
 To use `LIKE` operator, `Sql.text.like` method must be used

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@entity-access/entity-access",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "",
   "main": "index.js",
   "scripts": {
+    "test-plain": "node --enable-source-maps ./test.js no-db",
     "test": "node --enable-source-maps ./test.js",
-    "test-db": "node --enable-source-maps ./test.js test-db",
     "postversion": "git push --follow-tags"
   },
   "type": "module",

package/src/common/EntityAccessError.ts

@@ -0,0 +1,10 @@
+export default class EntityAccessError extends Error {
+
+    static throw(message: string = "Access denied") {
+        throw new EntityAccessError(message);
+    }
+
+    constructor(message: string = "Access denied") {
+        super(message);
+    }
+}

package/src/common/IDisposable.ts

@@ -0,0 +1,25 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/naming-convention */
+declare global {
+    interface SymbolConstructor {
+        readonly disposable?: unique symbol;
+        readonly asyncDisposable?: unique symbol;
+    }
+}
+
+// @ts-expect-error readonly
+Symbol.disposable ??= Symbol("@@disposable");
+// @ts-expect-error readonly
+Symbol.asyncDisposable ??= Symbol("@@asyncDisposable");
+
+
+export interface IDisposable {
+    dispose?();
+    [Symbol.disposable]?();
+    [Symbol.asyncDisposable]?();
+}
+
+export function disposeDisposable(d: IDisposable) {
+    const f = d[Symbol.disposable] ?? d[Symbol.asyncDisposable];
+    f?.()?.catch((error) => console.error(error));
+}

package/src/common/ImmutableObject.ts

@@ -0,0 +1,53 @@
+import { IClassOf } from "../decorators/IClassOf.js";
+
+function clone() {
+    Object.getPrototypeOf(this).constructor.create({ ... this });
+}
+
+export default class ImmutableObject {
+
+    public static create<T extends ImmutableObject>(this:IClassOf<T>, p: Partial<T>): T {
+        (p as any).type = this.name;
+        for(const [key, value] of Object.entries(p)) {
+            if (!value) {
+                continue;
+            }
+            // if it is array, we should make it immutable
+            if (Array.isArray(value)) {
+                const array = [];
+                let index = 0;
+                for (const iterator of value) {
+                    Object.defineProperty(array, index++, {
+                        value: iterator,
+                        writable: false,
+                        enumerable: true
+                    });
+                }
+                Object.defineProperty(array, "clone", {
+                    value: clone,
+                    enumerable: false,
+                    writable: false
+                });
+                Object.defineProperty(p, key, {
+                    value: array,
+                    enumerable: true,
+                    writable: false
+                });
+                continue;
+            }
+            Object.defineProperty(p, key, {
+                value,
+                enumerable: true,
+                writable: false
+            });
+        }
+        Object.setPrototypeOf(p, Object.getPrototypeOf(this));
+        Object.defineProperty(p, "clone", {
+            value: clone,
+            enumerable: false,
+            writable: false
+        });
+        return p as T;
+    }
+
+}

package/src/common/Logger.ts

@@ -0,0 +1,59 @@
+import { RegisterSingleton } from "../di/di.js";
+import { IDisposable } from "./IDisposable.js";
+
+/* eslint-disable no-console */
+@RegisterSingleton
+export default class Logger implements IDisposable {
+
+    public static instance = new Logger();
+
+    log(a) {
+        console.log(a);
+        return this;
+    }
+
+    error(a) {
+        console.error(a);
+        return this;
+    }
+
+    newSession() {
+        return new SessionLogger(this);
+    }
+
+    dispose() {
+        // do nothing...
+    }
+}
+
+class SessionLogger extends Logger {
+    private items = [];
+
+    constructor(private parent: Logger) {
+        super();
+    }
+
+    log(a) {
+        this.items.push({ log: a});
+        return this;
+    }
+
+    error(a: any) {
+        this.items.push({ error: a});
+        return this;
+    }
+
+    dispose(): void {
+        for (const { log, error } of this.items) {
+            if (log) {
+                this.parent.log(log);
+                continue;
+            }
+            if (error) {
+                this.parent.error(error);
+                continue;
+            }
+        }
+    }
+
+}

package/src/common/TypeInfo.ts

@@ -0,0 +1,3 @@
+export const TypeInfo = {
+    nameOfType: (t: any) => t.name ?? t.toString()
+};

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/common/usingAsync.ts

@@ -1,24 +1,54 @@
+import { IDisposable } from "./IDisposable.js";
 
-export interface IDisposable {
+export type IDisposableObject = IDisposable & { end?(): any; close?():any };
 
-    end?():any;
-    dispose?(): any;
-    close?(): any;
+export type IDisposableObjectType = IDisposableObject | IDisposableObject[];
 
-}
 
+const disposeAll = async (all: (IDisposable & { end?(): any; close?():any })[]) => {
+    let error = null;
+    // we need to dispose in reverse order...
+    while (all.length) {
+        const d = all.pop();
+        try {
+            const f = d.dispose ?? d.end ?? d.close ?? d[Symbol.disposable] ?? d[Symbol.asyncDisposable];
+            const r = f?.apply(d);
+            if (r?.then) {
+                await r;
+            }
+        } catch (e) {
+            error = error
+                ? new Error(`${error.stack ?? error}\r\n${e.stack ?? e}`)
+                : error;
+        }
+    }
+    if (error) {
+        throw error;
+    }
+};
 
-export default async function usingAsync<T extends IDisposable>(d: T, fx: (p:T) => Promise<any>) {
+export default async function usingAsync<T>(fx: (registry: IDisposableObject[]) => T | Promise<T>) {
+    const registry = [] as IDisposableObject[];
     try {
-        const r = fx(d);
+        const r = fx(registry) as any;
         if (r?.then) {
             await r;
         }
-        return r;
     } finally {
-        const r = d.dispose?.() ?? d.end?.() ?? d.close?.();
-        if (r?.then) {
-            await r;
-        }
+        await disposeAll(registry);
     }
 }
+
+export class DisposableScope {
+
+    private disposables: IDisposableObject[] = [];
+
+    public register(d: IDisposableObject) {
+        this.disposables.push(d);
+    }
+
+    async dispose() {
+        await disposeAll(this.disposables);
+    }
+
+}

package/src/compiler/QueryCompiler.ts

@@ -1,14 +1,19 @@
-import { IClassOf } from "../decorators/IClassOf.js";
 import ExpressionToSql from "../query/ast/ExpressionToSql.js";
-import { ISqlMethodTransformer, IStringTransformer, ITextOrFunctionArray } from "../query/ast/IStringTransformer.js";
-import { Expression, PlaceholderExpression } from "../query/ast/Expressions.js";
+import { ISqlMethodTransformer, IStringTransformer, ITextQuery } from "../query/ast/IStringTransformer.js";
+import { Expression, ParameterExpression, SelectStatement } from "../query/ast/Expressions.js";
 import SqlLiteral from "../query/ast/SqlLiteral.js";
 import ArrowToExpression from "../query/parser/ArrowToExpression.js";
 import PostgreSqlMethodTransformer from "./postgres/PostgreSqlMethodTransformer.js";
-import EntityType from "../entity-query/EntityType.js";
-import { EntitySource } from "../model/EntitySource.js";
-import { IEntityQuery } from "../model/IFilterWithParameter.js";
-import { SourceExpression } from "../model/SourceExpression.js";
+import EntityQuery from "../model/EntityQuery.js";
+import ReplaceParameter from "../query/ast/ReplaceParameter.js";
+
+
+export class CompiledQuery {
+    constructor(
+        public root: ParameterExpression,
+        public target: ParameterExpression,
+        public textQuery: ITextQuery) {}
+}
 
 export default class QueryCompiler {
 
@@ -38,47 +43,40 @@ export default class QueryCompiler {
         this.sqlMethodTransformer = sqlMethodTransformer;
     }
 
-    public execute<P = any, T = any>(parameters: P, fx: (p: P) => (x: T) => any, source?: SourceExpression) {
-        const { param, target , body } = this.arrowToExpression.transform(fx);
-        const exp = new this.expressionToSql(source, param, target, this);
+    public execute<P = any, T = any>(parameters: P, fx: (p: P) => (x: T) => any, source?: EntityQuery) {
+        const { params, target , body } = this.arrowToExpression.transform(fx, source?.selectStatement.as);
+        const exp = new this.expressionToSql(source, params[0], target, this);
         const query = exp.visit(body);
         return this.invoke(query, parameters);
     }
 
-    public compileToExpression(source: SourceExpression, p: any, fx: (p1) => (x) => any) {
-        const { param, target , body } = this.arrowToExpression.transform(fx);
-        const exp = new this.expressionToSql(source, param, target, this);
-        const visited = exp.visit(body);
-        return PlaceholderExpression.create({
-            expression: () => visited.map((x) => typeof x === "function" ? () => x(p) : x)
-        });
+    public compile(source: EntityQuery, fx: (p) => (x) => any) {
+        const { params, target , body } = this.arrowToExpression.transform(fx, source?.selectStatement.as);
+        return { params, target, body };
     }
 
-    public compile( source: SourceExpression , fx: (p) => (x) => any) {
-        const { param, target , body } = this.arrowToExpression.transform(fx);
-        const exp = new this.expressionToSql(source, param, target, this);
-        return exp.visit(body);
+    public compileToSql( source: EntityQuery , fx: (p) => (x) => any) {
+        const { params, target , body } = this.arrowToExpression.transform(fx, source?.selectStatement.as);
+        const exp = new this.expressionToSql(source, params[0], target, this);
+        const textQuery = exp.visit(body);
+        return new CompiledQuery(exp.root,exp.target,textQuery);
     }
 
-    public compileExpression(exp: Expression) {
-        const toSql = new this.expressionToSql(null, void 0, void 0, this);
+    public compileExpression(source: EntityQuery, exp: Expression) {
+        const toSql = new this.expressionToSql(source ?? null, null, (exp as SelectStatement)?.as ?? source?.selectStatement?.as, this);
         const query = toSql.visit(exp);
         return this.invoke(query);
     }
 
-    private invoke(query: ITextOrFunctionArray, p: any = {}) {
+    private invoke(query: ITextQuery, p: any = {}) {
         let text = "";
         const values = [];
         for (const iterator of query) {
-            if (typeof iterator === "string") {
+            if (typeof iterator !== "function") {
                 text += iterator;
                 continue;
             }
-            let value = iterator;
-            if (typeof iterator === "function") {
-                value = iterator(p);
-            }
-
+            const value = iterator(p);
             values.push(value);
             text += "$" + values.length;
         }

package/src/compiler/postgres/PostgreSqlMethodTransformer.ts

@@ -6,6 +6,29 @@ export const PostgreSqlHelper: ISqlHelpers = {
     in(a, array) {
         return prepareAny `${a} IN ${array}`;
     },
+    cast: {
+        asBigInt(a) {
+            return prepareAny `(${a} ::bigint)`;
+        },
+        asDate(a) {
+            return prepareAny `(${a} ::date)`;
+        },
+        asDateTime(a) {
+            return prepareAny `(${a} ::timestamp)`;
+        },
+        asInteger(a) {
+            return prepareAny `(${a} ::int)`;
+        },
+        asNumber(a) {
+            return prepareAny `(${a} ::double)`;
+        },
+        asText(a) {
+            return prepareAny `(${a} ::text)`;
+        },
+        asDecimal(a) {
+            return prepareAny `(${a} ::decimal(18,2))`;
+        },
+    },
     date: {
         addDays(d, n) {
             return prepareAny `(${d} + (${n} * interval '1 day'))`;

package/src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -6,6 +6,29 @@ export const SqlServerSqlHelper: ISqlHelpers = {
     in(a, array) {
         return prepareAny `${a} IN ${array}`;
     },
+    cast: {
+        asBigInt(a) {
+            return prepareAny `CAST(${a} as bigint)`;
+        },
+        asDate(a) {
+            return prepareAny `CAST(${a} as date)`;
+        },
+        asDateTime(a) {
+            return prepareAny `CAST(${a} as datetime2)`;
+        },
+        asInteger(a) {
+            return prepareAny `CAST(${a} as int)`;
+        },
+        asNumber(a) {
+            return prepareAny `CAST(${a} as double)`;
+        },
+        asText(a) {
+            return prepareAny `CAST(${a} as varchar(max))`;
+        },
+        asDecimal(a) {
+            return prepareAny `CAST(${a} as decimal(18,2))`;
+        },
+    },
     date: {
         addDays(d, n) {
             return prepareAny `DateAdd(DAY, ${d}, ${n})`;

package/src/decorators/ForeignKey.ts

@@ -1,6 +1,6 @@
 import type { IClassOf } from "./IClassOf.js";
 import SchemaRegistry from "./SchemaRegistry.js";
-import NameParser from "./parser/MemberParser.js";
+import NameParser from "./parser/NameParser.js";
 
 
 export default function ForeignKey<T, TRelated>(

package/src/decorators/IClassOf.ts

@@ -1 +1,2 @@
-export type IClassOf<T> = abstract new (... a: any[]) => T;
+export type IClassOf<T> = new (... a: any[]) => T;
+export type IAbstractClassOf<T> = abstract new (... a: any[]) => T;

package/src/decorators/IColumn.ts

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

package/src/decorators/parser/NameParser.ts

@@ -0,0 +1,15 @@
+const parsedName = Symbol("parsedName");
+
+export default class NameParser {
+    public static parseMember(text: ((a: any) => any)) {
+        let name = text[parsedName];
+        if (!name) {
+            const t: string = text.toString();
+
+            const index = t.lastIndexOf(".");
+            name = t.substring(index + 1);
+            text[parsedName] = name;
+        }
+        return name;
+    }
+}