@entity-access/entity-access 1.0.105 → 1.0.109

package/src/drivers/postgres/PostgreSqlDriver.ts

@@ -1,7 +1,5 @@
 /* eslint-disable no-console */
-import EntityAccessError from "../../common/EntityAccessError.js";
 import ObjectPool, { IPooledObject } from "../../common/ObjectPool.js";
-import TimedCache from "../../common/cache/TimedCache.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import Migrations from "../../migrations/Migrations.js";
 import PostgresAutomaticMigrations from "../../migrations/postgres/PostgresAutomaticMigrations.js";
@@ -29,13 +27,26 @@ const pgID = Symbol("pgID");
 
 class DbReader implements IDbReader {
 
-    constructor(private cursor: Cursor, private client: IPooledObject<pg.Client>) {
+    cursor: Cursor<any>;
+    client: IPooledObject<pg.Client>;
+
+    constructor(
+        private command: IQuery,
+        private connection: PostgreSqlConnection,
+        private signal?: AbortSignal) {
 
     }
 
     async *next(min = 100) {
+
+        const connection = await this.connection.getConnection(this.signal);
+        if (!this.connection.isInTransaction) {
+            this.client = connection;
+        }
+        const q = toQuery(this.command);
+        const cursor = this.cursor = connection.query(new Cursor(q.text, q.values));
         do {
-            const rows = await this.cursor.read(min);
+            const rows = await cursor.read(min);
             yield *rows;
             if (rows.length === 0) {
                 break;
@@ -60,8 +71,6 @@ class DbReader implements IDbReader {
     }
 }
 
-const poolCache = new TimedCache<string, ObjectPool<pg.Client>>();
-
 export default class PostgreSqlDriver extends BaseDriver {
 
     public get compiler() {
@@ -70,30 +79,62 @@ export default class PostgreSqlDriver extends BaseDriver {
 
     private myCompiler = new QueryCompiler();
 
+    private pool: ObjectPool<pg.Client>;
+
     constructor(private readonly config: IPgSqlConnectionString) {
         super(config);
+        this.pool = new ObjectPool({
+            asyncFactory: async () => {
+                const c = new pg.Client(this.config);
+                await c.connect();
+                const row = await c.query("SELECT pg_backend_pid() as id");
+                c[pgID] = (row.rows as any).id;
+                return c;
+            },
+            destroy(item) {
+                return item.end();
+            },
+            subscribeForRemoval(po, clear) {
+                po.on("end", clear);
+            },
+        });
+    }
+
+    dispose() {
+        this.pool?.dispose().catch(console.error);
     }
 
     newConnection(): BaseConnection {
-        return new PostgreSqlConnection(this);
+        return new PostgreSqlConnection(this, this.pool);
     }
 }
 
 class PostgreSqlConnection extends BaseConnection {
 
+    public get isInTransaction() {
+        return this.transaction as any as boolean;
+    }
+
     private transaction: IPooledObject<pg.Client>;
 
     private get config() {
         return this.connectionString;
     }
 
+    constructor(driver: BaseDriver, private pool: ObjectPool<pg.Client>) {
+        super(driver);
+    }
+
     public async createTransaction(): Promise<IBaseTransaction> {
         const tx = await this.getConnection();
         await tx.query("BEGIN");
         return {
             commit: () => tx.query("COMMIT"),
             rollback: () => tx.query("ROLLBACK"),
-            dispose: () => (this.transaction = null, tx[Symbol.asyncDisposable]())
+            dispose: () => {
+                this.transaction = null;
+                return tx[Symbol.asyncDisposable]();
+            }
         };
     }
 
@@ -102,10 +143,7 @@ class PostgreSqlConnection extends BaseConnection {
     }
 
     public async executeReader(command: IQuery, signal?: AbortSignal): Promise<IDbReader> {
-        const connection = await this.getConnection(signal);
-        const q = toQuery(command);
-        const cursor = connection.query(new Cursor(q.text, q.values));
-        return new DbReader(cursor, this.transaction ? void 0 : connection);
+        return new DbReader(command, this, signal);
     }
 
     public async executeQuery(command: IQuery, signal?: AbortSignal) {
@@ -161,7 +199,7 @@ class PostgreSqlConnection extends BaseConnection {
     }
 
 
-    private async getConnection(signal?: AbortSignal) {
+    public async getConnection(signal?: AbortSignal) {
 
         if (signal?.aborted) {
             throw new Error("Aborted");
@@ -171,24 +209,7 @@ class PostgreSqlConnection extends BaseConnection {
             return this.transaction;
         }
 
-        const key = `${this.config.host}:${this.config.port}//${this.config.database}?${this.config.user}&${this.config.password}`;
-
-        const pooledClient = poolCache.getOrCreate(key, this, (k, self) => new ObjectPool({
-            asyncFactory: async () => {
-                const c = new pg.Client(self.config);
-                await c.connect();
-                const row = await c.query("SELECT pg_backend_pid() as id");
-                c[pgID] = (row.rows as any).id;
-                return c;
-            },
-            destroy(item) {
-                return item.end();
-            },
-            subscribeForRemoval(po, clear) {
-                po.on("end", clear);
-            },
-        }));
-        const client = await pooledClient.acquire();
+        const client = await this.pool.acquire();
 
         if (signal) {
             signal.addEventListener("abort", () => this.kill(client[pgID]).catch((error) => console.error(error)));

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

@@ -25,6 +25,10 @@ export default class SqlServerDriver extends BaseDriver {
         config.server = config.host;
     }
 
+    dispose() {
+        // do nothing
+    }
+
     newConnection(): BaseConnection {
         return new SqlServerConnection(this, this.config);
     }

package/src/entity-query/EntityType.ts

@@ -152,9 +152,9 @@ export default class EntityType {
     }
 
     public selectAllFields() {
-        if (this.selectAll) {
-            return { ... this.selectAll };
-        }
+        // if (this.selectAll) {
+        //     return { ... this.selectAll };
+        // }
         const source = this.fullyQualifiedName;
         const as = Expression.parameter(this.name[0] + "1");
         as.model = this;
@@ -169,9 +169,9 @@ export default class EntityType {
     }
 
     public selectOneNumber() {
-        if (this.selectOne) {
-            return { ... this.selectOne };
-        }
+        // if (this.selectOne) {
+        //     return { ... this.selectOne };
+        // }
         const source = this.fullyQualifiedName;
         const as = Expression.parameter(this.name[0] + "1");
         as.model = this;

package/src/query/ast/DebugStringVisitor.ts

@@ -134,7 +134,7 @@ export default class DebugStringVisitor extends Visitor<string> {
     }
 
     visitJoinExpression(e: JoinExpression): string {
-        return `\n${e.joinType} JOIN ${this.visit(e.source)}\n\t\tON ${this.visit(e.where)}\n`;
+        return `\n${e.joinType} JOIN ${this.visit(e.source)} ${this.visit(e.as)} \n\t\tON ${this.visit(e.where)}\n`;
     }
 
     visitOrderByExpression(e: OrderByExpression): string {

package/src/query/ast/ExpressionToSql.ts

@@ -353,6 +353,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 if (scope.isRuntimeParam) {
                     return [(p) => p[chain[0]]];
                 }
+
                 const name = this.scope.nameOf(parameter);
 
                 // need to change name as per naming convention here...

package/src/query/ast/ParameterScope.ts

@@ -28,8 +28,8 @@ export default class ParameterScope {
 
     public nameOf(p: ParameterExpression) {
         const model = this.map.get(p);
-        p.name = model.name;
-        return model.name;
+        // p.name = model.name;
+        return model?.name ?? p.name;
     }
 
     public alias(

package/src/query/expander/QueryExpander.ts

@@ -1,6 +1,8 @@
+import { cloner } from "../../common/cloner.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityContext from "../../model/EntityContext.js";
 import EntityQuery from "../../model/EntityQuery.js";
+import DebugStringVisitor from "../ast/DebugStringVisitor.js";
 import { ArrowFunctionExpression, ExistsExpression, Expression, ExpressionType, JoinExpression, NumberLiteral, ParameterExpression, SelectStatement, TableSource } from "../ast/Expressions.js";
 import ReplaceParameter from "../ast/ReplaceParameter.js";
 import ArrowToExpression from "../parser/ArrowToExpression.js";
@@ -24,6 +26,8 @@ export class QueryExpander {
 
     expandNode(parent: SelectStatement, model: EntityType, node: ExpressionType): [SelectStatement, EntityType] {
 
+        parent = cloner.clone(parent);
+
         if (node.type === "ArrayExpression") {
             for (const iterator of node.elements) {
                 this.expandNode(parent, model,  iterator as ExpressionType);
@@ -83,7 +87,7 @@ export class QueryExpander {
             //     query = events.includeFilter(query, model, p.value) ?? query;
             // }
         // }
-        const select = { ... (query as EntityQuery).selectStatement };
+        const select = cloner.clone((query as EntityQuery).selectStatement);
 
         let where: Expression;
         let joinWhere: Expression;
@@ -108,17 +112,18 @@ export class QueryExpander {
             //     ? Expression.logicalAnd(joinWhere, parent.where)
             //     : joinWhere;
 
-            let keyColumn = model.keys[0].columnName;
+            const keyColumn = model.keys[0].columnName;
             let columnName = fk.columnName;
             // for inverse relation, we need to
             // use primary key of current model
             if (!relation.isCollection) {
-                columnName = model.keys[0].columnName;
-                keyColumn = select.model.keys[0].columnName;
+                columnName = select.model.keys[0].columnName;
             }
 
 
             const joins = (select.joins ??= []);
+            // const joinParameter = Expression.parameter(parent.sourceParameter.name);
+            // joinParameter.model = parent.sourceParameter.model;
             joins.push(JoinExpression.create({
                 joinType: "LEFT",
                 source: parent.source as TableSource,
@@ -127,21 +132,33 @@ export class QueryExpander {
                 where: Expression.equal(
                     Expression.member(
                         parent.sourceParameter,
-                        Expression.identifier(columnName)
+                        Expression.identifier(keyColumn)
                     ),
                     Expression.member(
                         select.sourceParameter,
-                        Expression.identifier(keyColumn)
+                        Expression.identifier(columnName)
                     )
                 )
             }));
-            // if (parent.joins?.length) {
-            //     joins.push(... parent.joins);
-            // }
+
+            if (parent.where) {
+                select.where = select.where
+                    ? Expression.logicalAnd(select.where, parent.where)
+                    : parent.where;
+            }
+
+            if (parent.joins?.length) {
+                 joins.push(... parent.joins);
+            }
+            // Object.setPrototypeOf(select, SelectStatement.prototype);
+            // const text = DebugStringVisitor.expressionToString(select);
+            // console.log(text);
             (this.select.include ??= []).push(select);
             return [select, relation.relatedEntity];
         }
 
+        // if we can skip this if join already exists !!
+
         joinWhere = Expression.equal(
             Expression.member(
                 parent.sourceParameter,
@@ -153,7 +170,7 @@ export class QueryExpander {
             )
         );
 
-        parent = { ... parent, fields: [ NumberLiteral.one ] };
+        parent = cloner.clone({ ... parent, fields: [ NumberLiteral.one ]});
 
         parent.where = parent.where
             ? Expression.logicalAnd(parent.where, joinWhere)

package/src/tests/db-tests/tests/select-inverse-one-to-one.ts

@@ -10,11 +10,11 @@ export default async function(this: TestConfig) {
 
     const context = await createContext(this.driver);
 
-    const count = await context.users.all()
-        .where({} , (p) => (x) => x.profile.photos.some((a) => true) || x.profile.photos.some((a) => true))
-        .count();
+    // const count = await context.users.all()
+    //     .where({} , (p) => (x) => x.profile.photos.some((a) => true) || x.profile.photos.some((a) => true))
+    //     .count();
 
-    assert.equal(0, count);
+    // assert.equal(0, count);
 
     // include inverse...
     const all = await context.users.all()

package/src/tests/db-tests/tests/select-nested.ts

@@ -0,0 +1,36 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext, headPhoneCategory } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    let headphone = await context.products
+        .where({ name: "Jabber Head Phones" }, (p) => (x) => x.name === p.name)
+        .include((x) => x.categories.forEach((c) => c.category.children))
+        .first();
+
+    assert.notEqual(null, headphone);
+
+    let child = headphone.categories[0].category.children[0];
+    assert.notEqual(null, child);
+
+    // select nested with filter
+
+    const blueTooth = "Bluetooth";
+    headphone = await context.products
+    .where({ name: "Jabber Head Phones", blueTooth }, (p) => (x) => x.name === p.name
+        && x.categories.some((c) =>
+            c.category.children.some((cc) => cc.name === p.blueTooth)))
+    .include((x) => x.categories.forEach((c) => c.category.children))
+    .first();
+
+    child = headphone.categories[0].category.children[0];
+    assert.notEqual(null, child);
+
+}

package/src/tests/model/ShoppingContext.ts

@@ -66,10 +66,21 @@ export class Category {
     @Column({ length: 200 })
     public name: string;
 
+    @Column({ dataType: "Char", length: 200, nullable: true })
+    @RelateTo(Category, {
+        property: (c) => c.parent,
+        inverseProperty: (c) => c.children
+    })
+    public parentID: string;
+
     public productCategories: ProductCategory[];
 
     public users: UserCategory[];
 
+    public children: Category[];
+
+    public parent: Category;
+
 }
 
 @Table("UserProfile")

package/src/tests/model/createContext.ts

@@ -236,7 +236,13 @@ export const headPhoneCategory = "head-phones";
 function addHeadPhones(context: ShoppingContext, now: Date, owner: User) {
     const category = context.categories.add({
         name: "Headphones",
-        categoryID: headPhoneCategory
+        categoryID: headPhoneCategory,
+        children: [
+            context.categories.add({
+                name: "Bluetooth",
+                categoryID: `${headPhoneCategory}/blue-tooth`
+            })
+        ]
     });
 
     const startDate = new Date();

package/src/tests/pool/pool-test.ts

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+import assert from "assert";
+import ObjectPool from "../../common/ObjectPool.js";
+import sleep from "../../common/sleep.js";
+
+export default async function () {
+    const pool = new ObjectPool({
+        asyncFactory: async () => {
+            await sleep(10);
+            return Promise.resolve({});
+        },
+        subscribeForRemoval: (po, clear) => void 0,
+        destroy(item) {
+            return sleep(10);
+        },
+        maxSize: 5,
+        poolSize: 2,
+        maxWait: 100
+    });
+
+    const c1 = await pool.acquire();
+    const c2 = await pool.acquire();
+
+    await c1[Symbol.asyncDisposable]();
+
+    assert.equal(pool.freeSize, 1);
+
+    const c3 = await pool.acquire();
+    assert.equal(c1, c3);
+
+    assert.equal(pool.freeSize, 0);
+
+    const c4 = await pool.acquire();
+    assert.notEqual(c4, c1);
+    assert.notEqual(c4, c2);
+
+    assert.equal(pool.currentSize, 3);
+
+    await c3[Symbol.asyncDisposable]();
+
+    assert.equal(pool.currentSize, 3);
+
+    await c4[Symbol.asyncDisposable]();
+    await c2[Symbol.asyncDisposable]();
+
+    assert.equal(pool.currentSize, 2);
+
+    assert.equal(pool.freeSize, 2);
+
+    await pool.acquire();
+    await pool.acquire();
+    await pool.acquire();
+    await pool.acquire();
+    const last = await pool.acquire();
+    let lastError;
+    try {
+        await pool.acquire();
+    } catch (error) {
+        lastError = error;
+    }
+    if (!lastError) {
+        assert.fail("Failed");
+    }
+
+    // free last after few milliseconds
+    setTimeout(() => {
+        last[Symbol.asyncDisposable]().catch(console.error);
+    }, 10);
+
+    // this should not fail
+    await pool.acquire();
+}