@arrai-innovations/reactive-helpers 18.0.0 → 18.0.2

package/tests/unit/config/listCrud.spec.js

@@ -1,114 +0,0 @@
-import cloneDeep from "lodash-es/cloneDeep.js";
-import { reactive } from "vue";
-
-describe("config/listCrud.js", () => {
-    describe("get & set", () => {
-        let setListCrud, getListCrud;
-        beforeAll(async () => {
-            const listCrudModule = await import("../../../config/listCrud.js");
-            setListCrud = listCrudModule.setListCrud;
-            getListCrud = listCrudModule.getListCrud;
-        });
-        it("should not die getting crud before setting", () => {
-            const reactiveCrud = reactive({});
-            expect(() => getListCrud(reactiveCrud)).not.toThrow();
-        });
-        it("should set and get the default crud, avoiding mutation", () => {
-            const crud = {
-                list: () => 1,
-                subscribe: () => 2,
-                args: {
-                    test: "test",
-                },
-            };
-            expect(() => setListCrud(crud)).not.toThrow();
-
-            /** @type {import("vue").UnwrapNestedRefs<
-             *      import('../../../config/listCrud.js').ListCrudFunctions &
-             *      import('../../../config/listCrud.js').ListCrudArgs
-             *  >}
-             */
-            const retrievedCrud = reactive({});
-            expect(() => getListCrud(retrievedCrud)).not.toThrow();
-            expect(new Set(Object.keys(retrievedCrud))).toEqual(
-                new Set(["list", "bulkDelete", "executeAction", "subscribe", "args"])
-            );
-            expect(retrievedCrud.args).not.toBe(crud.args);
-            expect(retrievedCrud.args).toEqual(crud.args);
-            expect(retrievedCrud.list).toBe(crud.list);
-            expect(retrievedCrud.subscribe).toBe(crud.subscribe);
-
-            const originalCrud = cloneDeep(crud);
-            crud.args.test = "test2";
-            crud.list = () => 3;
-            crud.subscribe = () => 4;
-            expect(retrievedCrud.args.test).toBe(originalCrud.args.test);
-            expect(retrievedCrud.list).toBe(originalCrud.list);
-            expect(retrievedCrud.subscribe).toBe(originalCrud.subscribe);
-        });
-        it("should die if an unknown function is passed", () => {
-            expect(() =>
-                setListCrud({ list: () => 1, subscribe: () => 2, args: { test: "test" }, unknown: () => 3 })
-            ).toThrow("Unknown key(s) passed to setListCrud: unknown");
-        });
-        it("should customize via getListCrud", () => {
-            const defaultCrud = {
-                list: () => 1,
-                subscribe: () => 2,
-                args: {
-                    test: "test",
-                },
-            };
-            const customCrudArgs = {
-                props: reactive({
-                    crudArgs: {
-                        test: "test2",
-                    },
-                }),
-                functions: {
-                    list: () => 3,
-                    subscribe: () => 4,
-                },
-            };
-            const expectedCustomCrud = {
-                list: customCrudArgs.functions.list,
-                subscribe: customCrudArgs.functions.subscribe,
-                args: customCrudArgs.props.crudArgs,
-            };
-            expect(() => setListCrud(defaultCrud)).not.toThrow();
-            const defaultRetrievedCrud = reactive({});
-            getListCrud(defaultRetrievedCrud);
-            expect(defaultRetrievedCrud).toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).not.toEqual(expectedCustomCrud);
-            const customRetrievedCrud = reactive({});
-            getListCrud(customRetrievedCrud, customCrudArgs);
-            expect(customRetrievedCrud).toEqual(expectedCustomCrud);
-            expect(customRetrievedCrud).not.toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).not.toEqual(expectedCustomCrud);
-        });
-        it("should throw if passed functions object that has values that are not functions", () => {
-            const retrievedCrud = reactive({});
-            expect(() =>
-                getListCrud(retrievedCrud, {
-                    functions: {
-                        list: () => 1,
-                        subscribe: true,
-                    },
-                })
-            ).toThrow('Invalid function "subscribe" for getListCrud: invalid key or not a function.');
-        });
-        it("should throw if passed unexpected functions", () => {
-            const retrievedCrud = reactive({});
-            expect(() =>
-                getListCrud(retrievedCrud, {
-                    functions: {
-                        list: () => 1,
-                        subscribe: () => 2,
-                        unknown: () => 3,
-                    },
-                })
-            ).toThrow('Invalid function "unknown" for getListCrud: invalid key or not a function.');
-        });
-    });
-});

package/tests/unit/config/objectCrud.spec.js

@@ -1,160 +0,0 @@
-import cloneDeep from "lodash-es/cloneDeep.js";
-import { reactive } from "vue";
-
-describe("config/objectCrud.js", () => {
-    describe("get & set", () => {
-        let setObjectCrud, getObjectCrud;
-        beforeAll(async () => {
-            const objectCrudModule = await import("../../../config/objectCrud.js");
-            setObjectCrud = objectCrudModule.setObjectCrud;
-            getObjectCrud = objectCrudModule.getObjectCrud;
-        });
-        it("should not die getting crud before setting", () => {
-            const reactiveCrud = reactive({});
-            expect(() => getObjectCrud(reactiveCrud)).not.toThrow();
-        });
-        it("should set and get the default crud, avoiding mutation", () => {
-            const crud = {
-                retrieve: () => 1,
-                create: () => 2,
-                update: () => 3,
-                patch: () => 4,
-                delete: () => 5,
-                subscribe: () => 6,
-                args: {
-                    test: "test",
-                },
-            };
-            expect(() => setObjectCrud(crud)).not.toThrow();
-
-            /** @type {import("vue").UnwrapNestedRefs<
-             *      import('../../../config/objectCrud.js').ObjectCrudFunctions &
-             *      import('../../../config/objectCrud.js').ObjectCrudArgs
-             *  >}
-             */
-            const retrievedCrud = reactive({});
-            expect(() => getObjectCrud(retrievedCrud)).not.toThrow();
-            expect(new Set(Object.keys(retrievedCrud))).toEqual(
-                new Set(["retrieve", "create", "update", "patch", "delete", "subscribe", "args"])
-            );
-            expect(retrievedCrud.args).not.toBe(crud.args);
-            expect(retrievedCrud.args).toEqual(crud.args);
-            expect(retrievedCrud.retrieve).toBe(crud.retrieve);
-            expect(retrievedCrud.create).toBe(crud.create);
-            expect(retrievedCrud.update).toBe(crud.update);
-            expect(retrievedCrud.patch).toBe(crud.patch);
-            expect(retrievedCrud.delete).toBe(crud.delete);
-            expect(retrievedCrud.subscribe).toBe(crud.subscribe);
-
-            const originalCrud = cloneDeep(crud);
-            crud.args.test = "test2";
-            crud.retrieve = () => 7;
-            crud.create = () => 8;
-            crud.update = () => 9;
-            crud.patch = () => 10;
-            crud.delete = () => 11;
-            crud.subscribe = () => 12;
-            expect(retrievedCrud.args.test).toBe(originalCrud.args.test);
-            expect(retrievedCrud.retrieve).toBe(originalCrud.retrieve);
-            expect(retrievedCrud.create).toBe(originalCrud.create);
-            expect(retrievedCrud.update).toBe(originalCrud.update);
-            expect(retrievedCrud.patch).toBe(originalCrud.patch);
-            expect(retrievedCrud.delete).toBe(originalCrud.delete);
-            expect(retrievedCrud.subscribe).toBe(originalCrud.subscribe);
-        });
-        it("should customize via getObjectCrud", () => {
-            const defaultCrud = {
-                retrieve: () => 1,
-                create: () => 2,
-                update: () => 3,
-                patch: () => 4,
-                delete: () => 5,
-                subscribe: () => 6,
-                args: {
-                    test: "test",
-                },
-            };
-            const customCrudArgs = {
-                props: reactive({
-                    crudArgs: {
-                        test: "test2",
-                    },
-                }),
-                functions: {
-                    retrieve: () => 7,
-                    create: () => 8,
-                    update: () => 9,
-                    patch: () => 10,
-                    delete: () => 11,
-                    subscribe: () => 12,
-                },
-            };
-            const expectedCustomCrud = {
-                retrieve: customCrudArgs.functions.retrieve,
-                create: customCrudArgs.functions.create,
-                update: customCrudArgs.functions.update,
-                patch: customCrudArgs.functions.patch,
-                delete: customCrudArgs.functions.delete,
-                subscribe: customCrudArgs.functions.subscribe,
-                args: customCrudArgs.props.crudArgs,
-            };
-            expect(() => setObjectCrud(defaultCrud)).not.toThrow();
-            const defaultRetrievedCrud = reactive({});
-            getObjectCrud(defaultRetrievedCrud);
-            expect(defaultRetrievedCrud).toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).not.toEqual(expectedCustomCrud);
-            const customRetrievedCrud = reactive({});
-            getObjectCrud(customRetrievedCrud, customCrudArgs);
-            expect(customRetrievedCrud).toEqual(expectedCustomCrud);
-            expect(customRetrievedCrud).not.toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).toEqual(defaultCrud);
-            expect(defaultRetrievedCrud).not.toEqual(expectedCustomCrud);
-        });
-        it("should die if an unknown function is passed", () => {
-            expect(() =>
-                setObjectCrud({
-                    retrieve: () => 1,
-                    create: () => 2,
-                    update: () => 3,
-                    patch: () => 4,
-                    delete: () => 5,
-                    subscribe: () => 6,
-                    args: { test: "test" },
-                    unknown: () => 7,
-                })
-            ).toThrow("Unknown key(s) passed to setObjectCrud: unknown");
-        });
-
-        it("should throw if passed functions object that has values that are not functions", () => {
-            const retrievedCrud = reactive({});
-            expect(() =>
-                getObjectCrud(retrievedCrud, {
-                    functions: {
-                        retrieve: () => 1,
-                        create: () => 2,
-                        update: 3,
-                        patch: () => 4,
-                        delete: () => 5,
-                        subscribe: () => 6,
-                    },
-                })
-            ).toThrow('Invalid function "update" for getObjectCrud: invalid key or not a function.');
-        });
-        it("should throw if passed unexpected functions", () => {
-            const retrievedCrud = reactive({});
-            expect(() =>
-                getObjectCrud(retrievedCrud, {
-                    functions: {
-                        retrieve: () => 1,
-                        create: () => 2,
-                        update: () => 3,
-                        patch: () => 4,
-                        delete: () => 5,
-                        subscribe: () => 6,
-                        unknown: () => 7,
-                    },
-                })
-            ).toThrow('Invalid function "unknown" for getObjectCrud: invalid key or not a function.');
-        });
-    });
-});

package/tests/unit/crudPromise.js

@@ -1,40 +0,0 @@
-/**
- * A class that wraps a promise and its resolve and reject functions
- */
-export class Resolvable {
-    /**
-     * Create a new Resolvable
-     */
-    constructor() {
-        /**
-         * @type {Promise}
-         */
-        this.promise = new Promise((resolve, reject) => {
-            /** @type {Function} */
-            this.resolve = resolve;
-            /** @type {Function} */
-            this.reject = reject;
-        });
-    }
-}
-
-/**
- * A Resolvable with a cancel function.
- */
-export class CancellableResolvable {
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            /** @type {Function} */
-            this.resolve = resolve;
-            /** @type {Function} */
-            this.reject = reject;
-        });
-        const cancelResolvable = new Resolvable();
-        // @ts-ignore - the whole point of this class is add and mock this function
-        this.promise.cancel = vi
-            .fn()
-            .mockImplementationOnce(async () => cancelResolvable.promise)
-            .mockRejectedValue(new Error("cancel already called"));
-        this.cancel = cancelResolvable;
-    }
-}

package/tests/unit/expectHelpers.js

@@ -1,6 +0,0 @@
-export function expectErrorToBeNull(error) {
-    if (error) {
-        console.error(error);
-    }
-    expect(error).toBeNull();
-}

package/tests/unit/mockOnUnmounted.js

@@ -1,9 +0,0 @@
-export function getMockOnUnmounted() {
-    const mockOnUnmounted = {};
-    vi.mock("vue", () => ({
-        _esModule: true,
-        ...vi.importActual("vue"),
-        onUnmounted: () => mockOnUnmounted,
-    }));
-    return mockOnUnmounted;
-}

package/tests/unit/poll.js

@@ -1,50 +0,0 @@
-import { Resolvable } from "./crudPromise.js";
-
-export async function poll(condition, interval = 100, timeout = 1000) {
-    let intervalId,
-        timeoutId,
-        resolvable = new Resolvable();
-
-    const calledStack = new Error().stack.split("\n").slice(2).join("\n");
-
-    function stop() {
-        if (intervalId) {
-            clearInterval(intervalId);
-            intervalId = null;
-        }
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-    }
-
-    function doInterval() {
-        if (condition()) {
-            stop();
-            if (resolvable) {
-                resolvable.resolve();
-                resolvable = null;
-            }
-        }
-    }
-
-    function doTimeout() {
-        stop();
-        let conditionValue = condition();
-        if (conditionValue) {
-            if (resolvable) {
-                resolvable.resolve();
-                resolvable = null;
-            }
-        } else if (resolvable) {
-            let timedOutError = new Error(`poll timeout: condition was never true (it was last ${conditionValue})`);
-            timedOutError.stack = timedOutError.stack.split("\n").slice(0, 1).join("\n") + "\n" + calledStack;
-            resolvable.reject(timedOutError);
-            resolvable = null;
-        }
-    }
-    intervalId = setInterval(doInterval, interval);
-    timeoutId = setTimeout(doTimeout, timeout);
-
-    return resolvable.promise;
-}

package/tests/unit/use/cancellableIntent.spec.js

@@ -1,152 +0,0 @@
-import { useCancellableIntent } from "../../../use/cancellableIntent.js";
-import { CancellableResolvable } from "../crudPromise.js";
-import flushPromises from "flush-promises";
-import { nextTick, reactive, ref } from "vue";
-
-describe("use/cancellableIntent", () => {
-    let mockAwaitableWithCancel, cancellableResolvable;
-    beforeEach(async () => {
-        cancellableResolvable = new CancellableResolvable();
-        mockAwaitableWithCancel = vi.fn().mockReturnValue(cancellableResolvable.promise);
-    });
-    afterEach(() => {
-        cancellableResolvable = null;
-        vi.resetAllMocks();
-    });
-    it("should throw an error if awaitableWithCancel is not provided", () => {
-        expect(() => {
-            // @ts-ignore - we're testing the error case
-            useCancellableIntent({});
-        }).toThrow("awaitableWithCancel is required");
-    });
-
-    it("should throw an error if awaitableWithCancel is not a function", () => {
-        expect(() => {
-            useCancellableIntent({
-                // @ts-ignore - we're testing the error case
-                awaitableWithCancel: "not a function",
-            });
-        }).toThrow("awaitableWithCancel must be a function");
-    });
-    describe("Resolution", () => {
-        it("should initiate the intent and resolve the promise when the awaitableWithCancel resolves", async () => {
-            const subscribeIntent = useCancellableIntent({
-                awaitableWithCancel: mockAwaitableWithCancel,
-                watchArguments: {
-                    testArg: 1,
-                },
-            });
-            await nextTick();
-            await flushPromises();
-            expect(mockAwaitableWithCancel).toHaveBeenCalledTimes(1);
-            expect(subscribeIntent.state.active).toBe(true);
-            expect(subscribeIntent.state.resolving).toBe(true);
-
-            cancellableResolvable.resolve(true);
-
-            await nextTick();
-            await flushPromises();
-
-            expect(subscribeIntent.state.active).toBe(false);
-            expect(subscribeIntent.state.resolving).toBe(false);
-        });
-    });
-
-    describe("Cancellation", () => {
-        it("should cancel the previous promise when watched arguments changed", async () => {
-            let testArgRef = ref(1);
-            const subscribeIntent = useCancellableIntent({
-                awaitableWithCancel: mockAwaitableWithCancel,
-                watchArguments: reactive({
-                    testArg: testArgRef,
-                }),
-                clearActiveOnResolved: true,
-            });
-            await nextTick();
-            await flushPromises();
-            expect(mockAwaitableWithCancel).toHaveBeenCalledTimes(1);
-            expect(subscribeIntent.state.active).toBe(true);
-            expect(subscribeIntent.state.resolving).toBe(true);
-            testArgRef.value = 2;
-
-            await nextTick();
-            await flushPromises();
-            expect(cancellableResolvable.promise.cancel).toHaveBeenCalledTimes(1);
-            expect(subscribeIntent.state.active).toBe(true);
-            expect(subscribeIntent.state.resolving).toBe(true);
-
-            cancellableResolvable.resolve(true);
-            await nextTick();
-            await flushPromises();
-            expect(subscribeIntent.state.active).toBe(false);
-            expect(subscribeIntent.state.resolving).toBe(false);
-        });
-    });
-
-    describe("Delay", () => {
-        it("should handle the delayed watch properly", async () => {
-            let testGuardRef = ref(true);
-            const subscribeIntent = useCancellableIntent({
-                awaitableWithCancel: mockAwaitableWithCancel,
-                watchArguments: {
-                    testArg: 1,
-                },
-                guardArguments: reactive({
-                    testGuard: testGuardRef,
-                }),
-            });
-
-            expect(mockAwaitableWithCancel).not.toHaveBeenCalled();
-            expect(subscribeIntent.state.activeCount).toBeUndefined();
-            expect(subscribeIntent.state.resolvingCount).toBeUndefined();
-
-            testGuardRef.value = false;
-            await nextTick();
-            await flushPromises();
-            expect(mockAwaitableWithCancel).toHaveBeenCalled();
-            expect(subscribeIntent.state.active).toBe(true);
-            expect(subscribeIntent.state.resolving).toBe(true);
-
-            cancellableResolvable.resolve(true);
-            await nextTick();
-            await flushPromises();
-            expect(subscribeIntent.state.active).toBe(false);
-            expect(subscribeIntent.state.resolving).toBe(false);
-        });
-    });
-    describe("Rejection", () => {
-        //error is not being caught
-        it.skip("errored", async () => {
-            const consoleErrorMock = vi.spyOn(console, "error").mockImplementation(() => {});
-            const subscribeIntent = useCancellableIntent({
-                awaitableWithCancel: mockAwaitableWithCancel,
-                watchArguments: {
-                    testArg: 1,
-                },
-            });
-            await nextTick();
-            await flushPromises();
-
-            const mockError = new Error("rejected");
-            cancellableResolvable.reject(mockError);
-
-            await nextTick();
-            await flushPromises();
-
-            expect(cancellableResolvable.promise.cancel).toHaveBeenCalledTimes(1);
-            expect(subscribeIntent.state.active).toBe(true);
-            expect(subscribeIntent.state.resolving).toBe(true);
-
-            await cancellableResolvable.cancel.resolve(true);
-            await nextTick();
-            await flushPromises();
-
-            await expect(cancellableResolvable.promise).rejects.toThrow(mockError);
-            expect(consoleErrorMock).toHaveBeenCalledWith(mockError);
-            expect(subscribeIntent.state.active).toBe(false);
-            expect(subscribeIntent.state.resolving).toBe(false);
-            expect(subscribeIntent.state.errored).toBe(true);
-            expect(subscribeIntent.state.error).toBe(mockError);
-        });
-    });
-});

package/tests/unit/use/listCalculated.spec.js

@@ -1,135 +0,0 @@
-import { nextTick } from "vue";
-import { deepUnref } from "vue-deepunref";
-
-describe("use/listCalculated", () => {
-    let useListInstance, useListCalculated, useListRelated, AwaitNot;
-    beforeEach(async () => {
-        const listInstanceModule = await import("../../../use/listInstance.js");
-        useListInstance = listInstanceModule.useListInstance;
-        const listCalculatedModule = await import("../../../use/listCalculated.js");
-        useListCalculated = listCalculatedModule.useListCalculated;
-        // todo: no useListCalculateds test yet
-        const listRelatedModule = await import("../../../use/listRelated.js");
-        useListRelated = listRelatedModule.useListRelated;
-        const watchesModule = await import("../../../utils/watches.js");
-        AwaitNot = watchesModule.AwaitNot;
-    });
-    it("should return a list of calculated items", async () => {
-        const mainListInstance = useListInstance({ props: { pkKey: "id" }, keepOldPages: false });
-        const calculatedListInstance = useListInstance({ props: { pkKey: "id" }, keepOldPages: false });
-        mainListInstance.addListObject({
-            id: "1",
-            name: "main",
-            calculated_items: ["2", "3"],
-            calculated_id: "4",
-        });
-        calculatedListInstance.addListObject({
-            id: "2",
-            name: "calculated1",
-        });
-        calculatedListInstance.addListObject({
-            id: "3",
-            name: "calculated2",
-        });
-        calculatedListInstance.addListObject({
-            id: "4",
-            name: "calculated3",
-        });
-        const listCalculated = useListCalculated({
-            parentState: mainListInstance.state,
-            calculatedObjectsRules: {
-                calculatedItems: (obj) => obj.calculated_items.map((x) => calculatedListInstance.state.objects[x]),
-                calculatedItem: (obj) => calculatedListInstance.state.objects[obj.calculated_id],
-            },
-        });
-        await nextTick();
-        // listCalculated.state.objects is doing proxy shenanigans
-        // in uses handler.has
-        expect(!!listCalculated.state.calculatedObjects?.[1]).toBe(true);
-        expect("calculatedItems" in listCalculated.state.calculatedObjects[1]).toBe(true);
-        expect("calculatedItem" in listCalculated.state.calculatedObjects[1]).toBe(true);
-        // expect uses enumeration, which uses handler.ownKeys and handler.getOwnPropertyDescriptor
-        expect(deepUnref(listCalculated.state.objects)).toEqual({
-            1: {
-                id: "1",
-                name: "main",
-                calculated_id: "4",
-                calculated_items: ["2", "3"],
-            },
-        });
-        expect(deepUnref(listCalculated.state.calculatedObjects)).toEqual({
-            1: {
-                calculatedItems: [
-                    {
-                        id: "2",
-                        name: "calculated1",
-                    },
-                    {
-                        id: "3",
-                        name: "calculated2",
-                    },
-                ],
-                calculatedItem: {
-                    id: "4",
-                    name: "calculated3",
-                },
-            },
-        });
-    });
-    it("should allow calculated objects to return results based on related objects", async () => {
-        const mainListInstance = useListInstance({ props: { pkKey: "id" }, keepOldPages: false });
-        const relatedListInstance = useListInstance({ props: { pkKey: "id" }, keepOldPages: false });
-        mainListInstance.addListObject({
-            id: "1",
-            name: "main",
-            related_items: ["2", "3"],
-            related_id: "4",
-            calculated_items: ["2", "3"],
-            calculated_id: "4",
-        });
-        relatedListInstance.addListObject({
-            id: "2",
-            name: "related1",
-        });
-        relatedListInstance.addListObject({
-            id: "3",
-            name: "related2",
-        });
-        relatedListInstance.addListObject({
-            id: "4",
-            name: "related3",
-        });
-        const listRelated = useListRelated({
-            parentState: mainListInstance.state,
-            relatedObjectsRules: {
-                relatedItems: {
-                    objects: relatedListInstance.state.objects,
-                    pkKey: "related_items",
-                },
-                relatedItem: {
-                    objects: relatedListInstance.state.objects,
-                    pkKey: "related_id",
-                },
-            },
-        });
-        const listCalculated = useListCalculated({
-            parentState: listRelated.state,
-            calculatedObjectsRules: {
-                calculatedItems: (obj, relatedObj) => relatedObj.relatedItems?.map((x) => x.name + "-modified"),
-                calculatedItem: (obj, relatedObj) => relatedObj.relatedItem?.name + "-modified",
-            },
-        });
-        const anr = new AwaitNot({
-            obj: listCalculated.state,
-            prop: "running",
-        });
-        anr.start();
-        await anr.promise;
-        expect(deepUnref(listCalculated.state.calculatedObjects)).toEqual({
-            1: {
-                calculatedItems: ["related1-modified", "related2-modified"],
-                calculatedItem: "related3-modified",
-            },
-        });
-    });
-});