@adviser/cement 0.5.0 → 0.5.2

package/ts/cjs/resolve-once.test.js

@@ -1,6 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const cement_1 = require("@adviser/cement");
+const is_promise_js_1 = require("./is-promise.js");
+const promise_sleep_js_1 = require("./promise-sleep.js");
 describe("resolve-once", () => {
     it("sequence", async () => {
         const once = new cement_1.ResolveOnce();
@@ -11,7 +46,7 @@ describe("resolve-once", () => {
                 }, 100);
             });
         });
-        const start = Date.now();
+        const start = performance.now();
         const fn = () => once.once(async () => reallyOnce());
         expect(reallyOnce).toHaveBeenCalledTimes(0);
         expect(await fn()).toBe(42);
@@ -20,7 +55,7 @@ describe("resolve-once", () => {
         expect(reallyOnce).toHaveBeenCalledTimes(1);
         expect(await fn()).toBe(42);
         expect(reallyOnce).toHaveBeenCalledTimes(1);
-        const diff = Date.now() - start;
+        const diff = performance.now() - start;
         expect(diff).toBeGreaterThanOrEqual(90);
         expect(diff).toBeLessThan(150);
     });
@@ -34,13 +69,13 @@ describe("resolve-once", () => {
             });
         });
         const fn = () => once.once(async () => reallyOnce());
-        const start = Date.now();
+        const start = performance.now();
         expect(await Promise.all(Array(100)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(100).fill(42));
         expect(reallyOnce).toHaveBeenCalledTimes(1);
-        const diff = Date.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(99);
+        const diff = performance.now() - start;
+        expect(diff).toBeGreaterThanOrEqual(95);
         expect(diff).toBeLessThan(150);
     });
     it("async works with void", async () => {
@@ -56,12 +91,12 @@ describe("resolve-once", () => {
         const fn = () => once.once(() => {
             return reallyOnce();
         });
-        const start = Date.now();
+        const start = performance.now();
         expect(await Promise.all(Array(cnt)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(cnt).fill(undefined));
         expect(reallyOnce).toHaveBeenCalledTimes(1);
-        const diff = Date.now() - start;
+        const diff = performance.now() - start;
         expect(diff).toBeGreaterThanOrEqual(95);
         expect(diff).toBeLessThan(150);
     });
@@ -84,7 +119,7 @@ describe("resolve-once", () => {
             });
         });
         const fn = () => once.once(async () => reallyOnce());
-        const start = Date.now();
+        const start = performance.now();
         await new Promise((rs) => {
             for (let i = 0; i < 100; i++) {
                 fn()
@@ -100,7 +135,7 @@ describe("resolve-once", () => {
                 });
             }
         });
-        const diff = Date.now() - start;
+        const diff = performance.now() - start;
         expect(diff).toBeGreaterThanOrEqual(99);
         expect(diff).toBeLessThan(250);
     });
@@ -119,15 +154,15 @@ describe("resolve-once", () => {
             const ret = await once.once(async () => reallyOnce());
             return `${o}:${ret}`;
         };
-        const start = Date.now();
+        const start = performance.now();
         expect(await Promise.all(Array(100)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(100)
             .fill(undefined)
             .map((_, i) => `${i}:42`));
         expect(reallyOnce).toHaveBeenCalledTimes(1);
-        const diff = Date.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(99);
+        const diff = performance.now() - start;
+        expect(diff).toBeGreaterThanOrEqual(95);
         expect(diff).toBeLessThan(150);
     });
     it("preserves call order to resolv order", async () => {
@@ -139,7 +174,7 @@ describe("resolve-once", () => {
                 }, 100);
             });
         });
-        const start = Date.now();
+        const start = performance.now();
         const orderFn = vi.fn();
         const fns = Array(100)
             .fill(0)
@@ -155,8 +190,8 @@ describe("resolve-once", () => {
             .fill(undefined)
             .map((_, i) => `${i}:42`));
         expect(reallyOnce).toHaveBeenCalledTimes(1);
-        const diff = Date.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(99);
+        const diff = performance.now() - start;
+        expect(diff).toBeGreaterThanOrEqual(95);
         expect(diff).toBeLessThan(150);
         expect(orderFn).toHaveBeenCalledTimes(100);
         expect(orderFn.mock.calls.map(([i]) => i)).toEqual(Array(100)
@@ -203,31 +238,41 @@ describe("resolve-once", () => {
             keyed.get(() => "b").once(b_orderFn),
         ]);
         expect(a_orderFn).toHaveBeenCalledTimes(1);
-        expect(a_orderFn).toHaveBeenCalledWith({ key: "a" });
+        expect(a_orderFn).toHaveBeenCalledWith({
+            refKey: "a",
+            givenKey: "a",
+            value: undefined,
+            ctx: {},
+        }, undefined);
         expect(b_orderFn).toHaveBeenCalledTimes(1);
-        expect(b_orderFn).toHaveBeenCalledWith({ key: "b" });
+        expect(b_orderFn).toHaveBeenCalledWith({
+            refKey: "b",
+            givenKey: "b",
+            value: undefined,
+            ctx: {},
+        }, undefined);
     });
     it("keyedResolvOnce with pass ctx & {key: K}", () => {
         const my = new cement_1.KeyedResolvOnce({ ctx: { wurst: "world" } });
-        my.get(1).once((ctx) => {
-            assertType(ctx);
-            assertType(ctx);
-            assertType(ctx.key);
-            assertType(ctx.wurst);
-            expect(ctx.key).toBe(1);
-            expect(ctx.wurst).toBe("world");
+        my.get(1).once((item) => {
+            assertType(item);
+            assertType(item);
+            assertType(item.givenKey);
+            assertType(item.ctx.wurst);
+            expect(item.givenKey).toBe(1);
+            expect(item.ctx.wurst).toBe("world");
             return { hello: "world" };
         });
     });
     it("keyedResolvSeq with pass ctx & {key: K}", () => {
         const my = new cement_1.KeyedResolvSeq({ ctx: { wurst: "world" } });
-        my.get(1).add((ctx) => {
-            assertType(ctx);
-            assertType(ctx);
-            assertType(ctx.key);
-            assertType(ctx.wurst);
-            expect(ctx.wurst).toBe("world");
-            expect(ctx.key).toBe(1);
+        my.get(1).add((item) => {
+            assertType(item);
+            assertType(item);
+            assertType(item.givenKey);
+            assertType(item.ctx.wurst);
+            expect(item.ctx.wurst).toBe("world");
+            expect(item.givenKey).toBe(1);
             return { hello: "world" };
         });
     });
@@ -242,8 +287,8 @@ describe("resolve-once", () => {
     });
     it("keyedResolvOnce with pass decompose", () => {
         const my = new cement_1.KeyedResolvOnce();
-        my.get("1").once(({ key }) => {
-            assertType(key);
+        my.get("1").once(({ refKey }) => {
+            assertType(refKey);
             return { hello: "world" };
         });
         my.get("2").once(() => {
@@ -256,7 +301,7 @@ describe("resolve-once", () => {
     });
     it("keyedResolvOnce with pass decompose", () => {
         const my = new cement_1.KeyedResolvSeq();
-        my.get("1").add(({ key }) => {
+        my.get("1").add(({ refKey: key }) => {
             assertType(key);
             return { hello: "world" };
         });
@@ -280,9 +325,19 @@ describe("resolve-once", () => {
                 .then((resolveOnce) => resolveOnce.once(b_orderFn)),
         ]);
         expect(a_orderFn).toHaveBeenCalledTimes(1);
-        expect(a_orderFn).toHaveBeenCalledWith({ key: "a" });
+        expect(a_orderFn).toHaveBeenCalledWith({
+            ctx: {},
+            givenKey: "a",
+            refKey: "a",
+            value: undefined,
+        }, undefined);
         expect(b_orderFn).toHaveBeenCalledTimes(1);
-        expect(b_orderFn).toHaveBeenCalledWith({ key: "b" });
+        expect(b_orderFn).toHaveBeenCalledWith({
+            ctx: {},
+            givenKey: "b",
+            refKey: "b",
+            value: undefined,
+        }, undefined);
     });
     function shuffle(array) {
         let currentIndex = array.length;
@@ -423,11 +478,17 @@ describe("resolve-once", () => {
         const a = keyed.get("a");
         expect(keyed.values()).toEqual([]);
         a.once(() => 42);
-        expect(keyed.values()).toEqual([{ key: "a", value: cement_1.Result.Ok(42) }]);
+        expect(keyed.values()).toEqual([
+            {
+                key: "a",
+                value: cement_1.Result.Ok(42),
+                item: expect.objectContaining({ givenKey: "a", refKey: "a" }),
+            },
+        ]);
         keyed.get("b").once(() => 43);
         expect(keyed.values()).toEqual([
-            { key: "a", value: cement_1.Result.Ok(42) },
-            { key: "b", value: cement_1.Result.Ok(43) },
+            { key: "a", value: cement_1.Result.Ok(42), item: expect.objectContaining({ givenKey: "a", refKey: "a" }) },
+            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
         ]);
         try {
             keyed.get("c").once(() => {
@@ -438,13 +499,15 @@ describe("resolve-once", () => {
             expect(e).toEqual(new Error("nope"));
         }
         expect(keyed.values()).toEqual([
-            { key: "a", value: cement_1.Result.Ok(42) },
-            { key: "b", value: cement_1.Result.Ok(43) },
-            { key: "c", value: cement_1.Result.Err(new Error("nope")) },
+            { key: "a", value: cement_1.Result.Ok(42), item: expect.objectContaining({ givenKey: "a", refKey: "a" }) },
+            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
+            { key: "c", value: cement_1.Result.Err(new Error("nope")), item: expect.objectContaining({ givenKey: "c", refKey: "c" }) },
         ]);
         keyed.unget("a");
         keyed.unget("c");
-        expect(keyed.values()).toEqual([{ key: "b", value: cement_1.Result.Ok(43) }]);
+        expect(keyed.values()).toEqual([
+            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
+        ]);
     });
     it("KeyedResolvOnce entries", () => {
         const keyed = new cement_1.KeyedResolvOnce();
@@ -481,8 +544,8 @@ describe("resolve-once", () => {
             keyed.get(i.toString()).once(() => i);
         }
         expect(keyed.values()).toEqual([
-            { key: "8", value: cement_1.Result.Ok(8) },
-            { key: "9", value: cement_1.Result.Ok(9) },
+            { key: "8", value: cement_1.Result.Ok(8), item: expect.objectContaining({ givenKey: "8", refKey: "8" }) },
+            { key: "9", value: cement_1.Result.Ok(9), item: expect.objectContaining({ givenKey: "9", refKey: "9" }) },
         ]);
     });
     it("resolve once serves ready and value", () => {
@@ -625,7 +688,7 @@ describe("Reset does not remove pending futures", () => {
             return once.once(() => releaseOnce.asPromise().then(() => 24));
         }));
         const newValue = new cement_1.Future();
-        let newWaiting;
+        let newWaiting = undefined;
         const never = vi.fn();
         const resetResult = once.reset(async () => {
             newWaiting = Promise.all(Array(cnt)
@@ -642,7 +705,11 @@ describe("Reset does not remove pending futures", () => {
         expect(await resetResult).toBe(42);
         const resWaiting = await waiting;
         expect(resWaiting).toEqual(Array(cnt).fill(24));
-        const newWaitingResult = await newWaiting;
+        if (!(0, is_promise_js_1.isPromise)(newWaiting)) {
+            assert.fail("newWaiting is undefined");
+            return;
+        }
+        const newWaitingResult = await Promise.resolve(newWaiting);
         expect(newWaitingResult).toEqual(Array(cnt).fill(24));
         expect(never).not.toHaveBeenCalled();
         const resolvedReset = await resetResult;
@@ -695,5 +762,172 @@ describe("Lazy Initialization", () => {
         expect(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
         expect(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
     });
+    it("Sync Lazy With Renew Timer", async () => {
+        let initVal = 0;
+        const lazy = (0, cement_1.Lazy)(() => {
+            return ++initVal;
+        }, { resetAfter: 50 });
+        expect(lazy()).toBe(1);
+        await (0, promise_sleep_js_1.sleep)(10);
+        expect(lazy()).toBe(1);
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(lazy()).toBe(2);
+        expect(lazy()).toBe(2);
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(lazy()).toBe(3);
+        expect(lazy()).toBe(3);
+    });
+    it("Async Lazy With Renew Timer", async () => {
+        let initVal = 0;
+        const lazy = (0, cement_1.Lazy)(() => {
+            return Promise.resolve(++initVal);
+        }, { resetAfter: 50 });
+        expect(await lazy()).toBe(1);
+        await (0, promise_sleep_js_1.sleep)(10);
+        expect(await lazy()).toBe(1);
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(await lazy()).toBe(2);
+        expect(await lazy()).toBe(2);
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(await lazy()).toBe(3);
+        expect(await lazy()).toBe(3);
+    });
+    it("KeyedResolveOnce and resetAfter", async () => {
+        const keyed = new cement_1.KeyedResolvOnce({
+            resetAfter: 50,
+        });
+        let initVal = 0;
+        function onces(initVal) {
+            return Array(5)
+                .fill(0)
+                .map((_, idx) => keyed.get(idx).once(() => initVal));
+        }
+        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        await (0, promise_sleep_js_1.sleep)(10);
+        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        await (0, promise_sleep_js_1.sleep)(10);
+        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
+        await (0, promise_sleep_js_1.sleep)(60);
+        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
+    });
+});
+describe("KeyToHash", () => {
+    it("KeyedResolvSeq could use default KeyToHash", async () => {
+        const keyed = new cement_1.KeyedResolvSeq({
+            key2string: (key) => `${key.id}:${key.name}`,
+            ctx: { ctx: "test" },
+        });
+        const addFn = vi
+            .fn()
+            .mockImplementation((item) => {
+            return Promise.resolve({ item });
+        });
+        await keyed.get({ id: 1, name: "test" }).add(addFn);
+        await keyed.get({ id: 1, name: "test" }).add(addFn);
+        await keyed.get({ id: 2, name: "test" }).add(addFn);
+        expect(addFn).toHaveBeenCalledTimes(3);
+        expect(addFn).toHaveBeenNthCalledWith(1, {
+            refKey: "1:test",
+            givenKey: { id: 1, name: "test" },
+            value: undefined,
+            ctx: { ctx: "test" },
+        });
+        expect(addFn).toHaveBeenNthCalledWith(2, {
+            refKey: "1:test",
+            givenKey: { id: 1, name: "test" },
+            value: undefined,
+            ctx: { ctx: "test" },
+        });
+        expect(addFn).toHaveBeenNthCalledWith(3, {
+            refKey: "2:test",
+            givenKey: { id: 2, name: "test" },
+            value: undefined,
+            ctx: { ctx: "test" },
+        });
+    });
+    it("KeyedResolvOnce could use custom KeyToHash", async () => {
+        const keyed = new cement_1.KeyedResolvOnce({
+            key2string: (key) => `${key.id}:${key.name}`,
+            ctx: { ctx: "test" },
+        });
+        const onceFn = vi.fn().mockImplementation((item) => {
+            return {
+                id: item.givenKey.id,
+                name: item.givenKey.name,
+            };
+        });
+        for (let i = 0; i < 3; i++) {
+            const res = await keyed.get({ id: 1, name: "test" }).once((item) => {
+                return Promise.resolve(onceFn(item));
+            });
+            expect(res).toEqual({ id: 1, name: "test" });
+        }
+        expect(onceFn).toHaveBeenCalledTimes(1);
+        expect(onceFn).toHaveBeenCalledWith({
+            refKey: "1:test",
+            givenKey: { id: 1, name: "test" },
+            value: undefined,
+            ctx: { ctx: "test" },
+        });
+    });
+});
+it("ResolveOnce gets is prev value if reset", () => {
+    const once = new cement_1.ResolveOnce();
+    once.once(() => ({
+        value: 42,
+        stats: 1,
+    }));
+    once.reset();
+    const res1 = once.once((_, prev) => {
+        if (!prev) {
+            throw new Error("prev is undefined");
+        }
+        return {
+            value: 45,
+            stats: prev.stats + 1,
+        };
+    });
+    expect(res1).toEqual({
+        value: 45,
+        stats: 2,
+    });
+    once.reset();
+    const res2 = once.once((_, prev) => {
+        if (!prev) {
+            throw new Error("prev is undefined");
+        }
+        prev.stats++;
+        prev.value += 3;
+        return prev;
+    });
+    expect(res2).toEqual({
+        value: 48,
+        stats: 3,
+    });
+});
+it("does not block node on process exit", async () => {
+    let runtime = undefined;
+    if ((0, cement_1.runtimeFn)().isNodeIsh) {
+        runtime = ["tsx", "-e"];
+    }
+    if ((0, cement_1.runtimeFn)().isDeno) {
+        runtime = ["deno", "eval"];
+    }
+    if (runtime) {
+        const { $ } = await Promise.resolve().then(() => __importStar(require("zx")));
+        const start = Date.now();
+        const code = [
+            "import { ResolveOnce } from './src/resolve-once.ts';",
+            `(new ResolveOnce(undefined, { resetAfter: 100000 }).once(() => Promise.resolve("done")))`,
+            `.finally(() => console.log("done"));`,
+        ].join("");
+        const res = await $ `${runtime} ${[code]}`;
+        expect(res.ok).toBe(true);
+        const duration = Date.now() - start;
+        expect(duration).toBeLessThan(1000);
+    }
 });
 //# sourceMappingURL=resolve-once.test.js.map