@entity-access/entity-access 1.0.111 → 1.0.112

package/src/decorators/Relate.ts

@@ -2,95 +2,58 @@ 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 => {
+export interface IRelatedTypeOne<T, TRelated> {
+    property: (item: T) => TRelated;
+    inverseProperty: (item: TRelated) => T;
+    inverseKey?: (item: TRelated) => any;
+    dotNotCreateIndex?: boolean;
+}
 
-        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 IRelatedTypeWithType<T, TRelated> {
+    type: () => IClassOf<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 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 {
 
-        property: (item: T) => TRelated;
-        inverseProperty: (item: TRelated) => T[];
-        inverseKey?: (item: TRelated) => any;
-        dotNotCreateIndex?: boolean;
+    if (p === void 0) {
+        p = c;
+        c = p.type?.();
     }
 
-) {
-    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,
+            relatedTypeClass: c ?? (Reflect as any).getMetadata("design:type", target, name),
             relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
             dotNotCreateIndex
@@ -99,34 +62,65 @@ 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?.();
     }
 
-) {
-    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 r = type.addRelation({
-            type,
-            name: NameParser.parseMember(name),
-            foreignKey: key,
-            relatedTypeClass: c,
-            relatedName: NameParser.parseMember(inv),
+        const entityType = SchemaRegistry.model(cn);
+
+        const name = NameParser.parseMember(property);
+
+        entityType.addRelation({
+            type: entityType,
+            name,
+            foreignKey,
+            relatedTypeClass: c ?? (Reflect as any).getMetadata("design:type", target, name),
+            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/tests/model/ShoppingContext.ts

@@ -1,6 +1,6 @@
 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";
@@ -263,7 +263,8 @@ export class OrderItem {
     public orderItemID: number;
 
     @Column()
-    @RelateTo(Order, {
+    @RelateTo({
+        type: () => Order,
         property: (orderItem) => orderItem.order,
         inverseProperty: (order) => order.orderItems
     })

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();
 }