@entity-access/entity-access 1.0.111 → 1.0.113

package/src/common/ObjectPool.ts

@@ -2,6 +2,7 @@
 import EntityAccessError from "./EntityAccessError.js";
 import TimedCache from "./cache/TimedCache.js";
 import sleep from "./sleep.js";
+import "./IDisposable.js";
 
 interface IObjectPool<T> {
     factory?: () => T;
@@ -22,12 +23,16 @@ interface IObjectPool<T> {
 
     /**
      * Max wait in milliseconds before creating
-     * new object, default is 15 seconds with gap of 1 second each
+     * new object, default is 5 seconds
      */
     maxWait?: number;
+
+    logger?: (text: string) => void;
 }
 
-export type IPooledObject<T> = T & { [Symbol.asyncDisposable](): Promise<any>; };
+export type IPooledObject<T> = T & {
+    [Symbol.asyncDisposable](): Promise<any>;
+};
 
 /**
  * Most pool implementations are poor and are having too many errors.
@@ -63,10 +68,13 @@ export default class ObjectPool<T> {
 
     private awaited: Set<AbortController> = new Set();
 
+    private logger: (text: string) => void;
+
     constructor({
         maxSize = 40,
         maxWait = 5000,
         poolSize = 20,
+        logger,
         asyncFactory,
         factory,
         destroy,
@@ -79,6 +87,7 @@ export default class ObjectPool<T> {
         this.factory = factory;
         this.destroy = destroy;
         this.subscribeForRemoval = subscribeForRemoval;
+        this.logger = logger;
     }
 
     public async dispose() {
@@ -94,51 +103,58 @@ export default class ObjectPool<T> {
     }
 
     public async acquire(): Promise<IPooledObject<T>> {
-        let item = this.free.pop();
-        if(!item) {
+        let existing = this.free.pop();
+        if(!existing) {
             if (this.total >= this.poolSize) {
                 const a = new AbortController();
                 this.awaited.add(a);
                 await sleep(this.maxWait, a.signal);
                 this.awaited.delete(a);
-                item = this.free.pop();
+                existing = this.free.pop();
             }
         }
-        if(!item) {
-
-            if (this.total >= this.maxSize) {
-                throw new EntityAccessError(`Maximum size of pool reached. Retry after sometime.`);
-            }
-            this.total++;
+        if(existing) {
+            return existing as IPooledObject<T>;
+        }
 
-            // create new..
-            if (this.factory) {
-                item = this.factory();
-            } else {
-                item = await this.asyncFactory();
-            }
-            this.subscribeForRemoval(item as unknown as any, () => {
-                const index = this.free.indexOf(item);
-                this.free.splice(index, 1);
-            });
+        if (this.total >= this.maxSize) {
+            throw new EntityAccessError(`Maximum size of pool reached. Retry after sometime.`);
         }
+        this.total++;
+
+           // create new..
+        const item = this.factory?.() ?? (await this.asyncFactory());
+        this.subscribeForRemoval(item as unknown as any, () => {
+            const index = this.free.indexOf(item);
+            this.free.splice(index, 1);
+        });
+
+        return this.setupItem(item);
+    }
+
+
+    private setupItem(item: T) {
         const pooledItem = item as IPooledObject<T>;
         pooledItem[Symbol.asyncDisposable] = async () => {
+            delete this[Symbol.asyncDisposable];
             if (this.free.length < this.poolSize) {
-                this.free.push(item);
-                for (const iterator of this.awaited) {
+                this.logger?.(`Pooled item ${pooledItem} freed.`);
+                this.free.push(pooledItem);
+                for (const [iterator] of this.awaited.entries()) {
                     this.awaited.delete(iterator);
                     iterator.abort();
-                    break;
+                    return;
                 }
-            } else {
-                await this.destroy(item);
-                this.total--;
+                return;
             }
+            this.total--;
+            this.logger?.(`Pooled item ${pooledItem} destoryed.`);
+            void this.destroy(pooledItem)?.catch(console.error);
         };
+        this.logger?.(`Pooled item ${pooledItem} acquired.`);
+        this.logger?.(`Item ${pooledItem} has disposable ${typeof pooledItem[Symbol.asyncDisposable]}`);
         return item as IPooledObject<T>;
     }
-
 }
 
 export class NamedObjectPool<T> {

package/src/common/sleep.ts

@@ -3,14 +3,35 @@ export default async function sleep(n: number, signal?: AbortSignal, throwOnAbor
         return;
     }
     return new Promise<void>((resolve, reject) => {
+        if (!signal) {
+            setTimeout(resolve, n);
+            return;
+        }
+        let resolved = false;
+        const old = resolve;
+        resolve = () => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            old();
+        };
+        const oldReject = reject;
+        reject = (r) => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            oldReject(r);
+        };
         const id = setTimeout(resolve, n);
-        signal?.addEventListener("abort", () => {
+        signal.onabort = () => {
             clearTimeout(id);
             if (throwOnAbort) {
                 reject("cancelled");
                 return;
             }
             resolve();
-        });
+        };
     });
 }

package/src/decorators/IColumn.ts

@@ -86,6 +86,8 @@ export interface IEntityRelation {
 
     relatedTypeClass: IClassOf<any>;
 
+    relatedTypeClassFactory?: () => IClassOf<any>;
+
     fkColumn?: IColumn;
 
 

package/src/decorators/Relate.ts

@@ -2,95 +2,62 @@ import type { IClassOf } from "./IClassOf.js";
 import SchemaRegistry from "./SchemaRegistry.js";
 import NameParser from "./parser/NameParser.js";
 
-
-
-export default function Relate<T, TRelated>(c: IClassOf<TRelated>,
-    {
-        foreignKey: name, inverseProperty: inv, inverseKey: invKey, dotNotCreateIndex
-    }: {
-
-        foreignKey: (item: T) => any;
-
-        inverseProperty: (item: TRelated) => T[];
-
-        inverseKey?: (item: TRelated) => any;
-        dotNotCreateIndex?: boolean;
-    }
-
-) {
-    return (target: T, key: string): any => {
-
-        const cn = target.constructor ?? target;
-        const type = SchemaRegistry.model(cn);
-
-        type.addRelation({
-            type,
-            name: key,
-            foreignKey: NameParser.parseMember(name),
-            relatedTypeClass: c,
-            relatedName: NameParser.parseMember(inv),
-            relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
-            dotNotCreateIndex
-        });
-
-    };
+export interface IRelatedType<T, TRelated> {
+    property: (item: T) => TRelated;
+    inverseProperty: (item: TRelated) => T[];
+    inverseKey?: (item: TRelated) => any;
+    dotNotCreateIndex?: boolean;
 }
 
-export function RelateOne<T, TRelated>(c: IClassOf<TRelated>,
-    {
-        foreignKey: name, inverseProperty: inv, inverseKey: invKey, dotNotCreateIndex
-    }: {
-
-        foreignKey: (item: T) => any;
-
-        inverseProperty: (item: TRelated) => T;
-
-        inverseKey?: (item: TRelated) => any;
-        dotNotCreateIndex?: boolean;
-    }
-
-) {
-    return (target: T, key: string): any => {
-
-        const cn = target.constructor ?? target;
-        const type = SchemaRegistry.model(cn);
-
-        const r = type.addRelation({
-            type,
-            name: key,
-            foreignKey: NameParser.parseMember(name),
-            relatedTypeClass: c,
-            relatedName: NameParser.parseMember(inv),
-            relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
-            dotNotCreateIndex
-        });
-        r.relatedRelation.isCollection = false;
-    };
+export interface IRelatedTypeOne<T, TRelated> {
+    property: (item: T) => TRelated;
+    inverseProperty: (item: TRelated) => T;
+    inverseKey?: (item: TRelated) => any;
+    dotNotCreateIndex?: boolean;
 }
 
-export function RelateTo<T, TRelated>(c: IClassOf<TRelated>,
-    {
-        property,
-        inverseProperty, inverseKey: invKey, dotNotCreateIndex
-    }: {
+export interface IRelatedTypeWithType<T, TRelated> {
+    type: () => IClassOf<TRelated>,
+    property: (item: T) => TRelated;
+    inverseProperty: (item: TRelated) => T[];
+    inverseKey?: (item: TRelated) => any;
+    dotNotCreateIndex?: boolean;
+}
 
-        property: (item: T) => TRelated;
-        inverseProperty: (item: TRelated) => T[];
-        inverseKey?: (item: TRelated) => any;
-        dotNotCreateIndex?: boolean;
+export interface IRelatedTypeOneWithType<T, TRelated> {
+    type: () => IClassOf<TRelated>,
+    property: (item: T) => TRelated;
+    inverseProperty: (item: TRelated) => T;
+    inverseKey?: (item: TRelated) => any;
+    dotNotCreateIndex?: boolean;
+}
+export function RelateTo<T, TRelated>(p: IRelatedTypeWithType<T, TRelated>): (target: T, key: string) => any;
+export function RelateTo<T, TRelated>(c: IClassOf<TRelated>, p: IRelatedType<T, TRelated>): (target: T, key: string) => any;
+export function RelateTo(c, p?): any {
+
+    if (p === void 0) {
+        p = c;
+        // c = p.type?.();
+        if (p.type) {
+            c = void 0;
+        }
     }
 
-) {
-    return (target: T, foreignKey: string): any => {
+    const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex } = p;
+
+    return (target: any, foreignKey: string): any => {
 
         const cn = target.constructor ?? target;
-        const type = SchemaRegistry.model(cn);
+        const entityType = SchemaRegistry.model(cn);
+
+        const name = NameParser.parseMember(property);
 
-        type.addRelation({
-            type,
-            name: NameParser.parseMember(property),
+        entityType.addRelation({
+            type: entityType,
+            name,
             foreignKey,
             relatedTypeClass: c,
+            relatedTypeClassFactory: p.type,
             relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
             dotNotCreateIndex
@@ -99,34 +66,69 @@ export function RelateTo<T, TRelated>(c: IClassOf<TRelated>,
     };
 }
 
+export function RelateToOne<T, TRelated>(p: IRelatedTypeOneWithType<T, TRelated>): (target: T, key: string) => any;
+export function RelateToOne<T, TRelated>(c: IClassOf<TRelated>, p: IRelatedTypeOne<T, TRelated>): (target: T, key: string) => any;
+export function RelateToOne(c, p?): any {
 
-export function RelateToOne<T, TRelated>(c: IClassOf<TRelated>,
-    {
-        property: name, inverseProperty: inv, inverseKey: invKey, dotNotCreateIndex
-    }: {
-
-        property: (item: T) => TRelated;
-        inverseProperty: (item: TRelated) => T;
-
-        inverseKey?: (item: TRelated) => any;
-        dotNotCreateIndex?: boolean;
+    if (p === void 0) {
+        p = c;
+        // c = p.type?.();
+        if (p.type) {
+            c = void 0;
+        }
     }
 
-) {
-    return (target: T, key: string): any => {
+    const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex } = p;
+
+    return (target: any, foreignKey: string): any => {
 
         const cn = target.constructor ?? target;
-        const type = SchemaRegistry.model(cn);
+        const entityType = SchemaRegistry.model(cn);
 
-        const r = type.addRelation({
-            type,
-            name: NameParser.parseMember(name),
-            foreignKey: key,
+        const name = NameParser.parseMember(property);
+
+        entityType.addRelation({
+            type: entityType,
+            name,
+            foreignKey,
             relatedTypeClass: c,
-            relatedName: NameParser.parseMember(inv),
+            relatedTypeClassFactory: p.type,
+            relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
             dotNotCreateIndex,
             singleInverseRelation: true
         });
+
     };
 }
+
+// export function RelateToOne<T, TRelated>(c: IClassOf<TRelated>,
+//     {
+//         property: name, inverseProperty: inv, inverseKey: invKey, dotNotCreateIndex
+//     }: {
+
+//         property: (item: T) => TRelated;
+//         inverseProperty: (item: TRelated) => T;
+
+//         inverseKey?: (item: TRelated) => any;
+//         dotNotCreateIndex?: boolean;
+//     }
+
+// ) {
+//     return (target: T, key: string): any => {
+
+//         const cn = target.constructor ?? target;
+//         const type = SchemaRegistry.model(cn);
+
+//         const r = type.addRelation({
+//             type,
+//             name: NameParser.parseMember(name),
+//             foreignKey: key,
+//             relatedTypeClass: c,
+//             relatedName: NameParser.parseMember(inv),
+//             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
+//             dotNotCreateIndex,
+//             singleInverseRelation: true
+//         });
+//     };
+// }

package/src/entity-query/EntityType.ts

@@ -106,6 +106,11 @@ export default class EntityType {
         // we will also set fk to the corresponding column
         this.relations.push(relation);
         this.relationMap.set(relation.name, relation);
+        if (getInverseModel) {
+            if (!relation.relatedTypeClass) {
+                relation.relatedTypeClass = relation.relatedTypeClassFactory();
+            }
+        }
 
         // find fk...
         let fkColumn = this.fieldMap.get(relation.foreignKey);

package/src/tests/model/ShoppingContext.ts

@@ -1,9 +1,10 @@
 import EntityContext from "../../model/EntityContext.js";
 import Column from "../../decorators/Column.js";
-import Relate, { RelateTo, RelateToOne } from "../../decorators/Relate.js";
+import { RelateTo, RelateToOne } from "../../decorators/Relate.js";
 import Table from "../../decorators/Table.js";
 import Index from "../../decorators/Index.js";
 import DateTime from "../../types/DateTime.js";
+import { UserFile } from "./UseFile.js";
 
 export const statusPublished = "published";
 
@@ -47,6 +48,13 @@ export class User {
     @Column({ dataType: "Char", length: 200 })
     public userName: string;
 
+    @RelateTo({
+        type: () => UserFile,
+        property: (u) => u.photo,
+        inverseProperty: (uf) => uf.photoUsers
+    })
+    public photoID: number;
+
     public profile: UserProfile;
 
     public ownedProducts: Product[];
@@ -55,6 +63,9 @@ export class User {
 
     public categories: UserCategory[];
 
+    public files: UserFile[];
+
+    public photo: UserFile;
 }
 
 @Table("Categories")
@@ -263,7 +274,8 @@ export class OrderItem {
     public orderItemID: number;
 
     @Column()
-    @RelateTo(Order, {
+    @RelateTo({
+        type: () => Order,
         property: (orderItem) => orderItem.order,
         inverseProperty: (order) => order.orderItems
     })

package/src/tests/model/UseFile.ts

@@ -0,0 +1,24 @@
+import Column from "../../decorators/Column.js";
+import { RelateTo } from "../../decorators/Relate.js";
+import Table from "../../decorators/Table.js";
+import { User } from "./ShoppingContext.js";
+
+@Table("UserFiles")
+export class UserFile {
+
+    @Column({ dataType: "BigInt", key: true, autoGenerate: true })
+    public fileID: number;
+
+    @Column({ dataType: "BigInt"})
+    @RelateTo({
+        type: () => User,
+        property: (uf) => uf.user,
+        inverseProperty: (u) => u.files
+    })
+    public userID: number;
+
+    public user: User;
+
+    public photoUsers: User[];
+
+}

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

@@ -3,70 +3,77 @@ 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();
+export default async function () {
+    let id = 1;
+    const logs = [] as string[];
+    try {
+        const pool = new ObjectPool({
+            asyncFactory: async () => {
+                await sleep(1);
+                return Promise.resolve({ id: id++, toString() { return `item-${this.id}`; } });
+            },
+            subscribeForRemoval: (po, clear) => void 0,
+            destroy(item) {
+                return Promise.resolve();
+            },
+            maxSize: 5,
+            poolSize: 2,
+            maxWait: 5000,
+            logger: (t) => logs.push(t)
+        });
 
-    await c1[Symbol.asyncDisposable]();
+        const c1 = await pool.acquire();
+        const c2 = await pool.acquire();
 
-    assert.equal(pool.freeSize, 1);
+        assert.equal(2, c2.id);
 
-    const c3 = await pool.acquire();
-    assert.equal(c1, c3);
+        assert.notStrictEqual(c1, c2);
 
-    assert.equal(pool.freeSize, 0);
+        await c1[Symbol.asyncDisposable]();
 
-    const c4 = await pool.acquire();
-    assert.notEqual(c4, c1);
-    assert.notEqual(c4, c2);
+        assert.equal(pool.freeSize, 1);
 
-    assert.equal(pool.currentSize, 3);
+        const c3 = await pool.acquire();
+        assert.strictEqual(c1, c3);
+        assert.notStrictEqual(c2, c3);
+        assert.strictEqual(pool.freeSize, 0);
 
-    await c3[Symbol.asyncDisposable]();
+        const c4 = await pool.acquire();
+        assert.notStrictEqual(c4, c1);
+        assert.notStrictEqual(c4, c2);
 
-    assert.equal(pool.currentSize, 3);
+        assert.strictEqual(pool.currentSize, 3);
 
-    await c4[Symbol.asyncDisposable]();
-    await c2[Symbol.asyncDisposable]();
+        await c4[Symbol.asyncDisposable]();
+        await c2[Symbol.asyncDisposable]();
 
-    assert.equal(pool.currentSize, 2);
+        assert.equal(pool.currentSize, 3);
 
-    assert.equal(pool.freeSize, 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");
+        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();
+    } finally {
+        console.log(logs.join("\n"));
     }
-
-    // free last after few milliseconds
-    setTimeout(() => {
-        last[Symbol.asyncDisposable]().catch(console.error);
-    }, 10);
-
-    // this should not fail
-    await pool.acquire();
 }