@arrai-innovations/reactive-helpers 9.0.2 → 10.0.0

package/config/listCrud.js

@@ -0,0 +1,37 @@
+import { addOrUpdateReactiveObject } from "../utils/assignReactiveObject.js";
+import cloneDeep from "lodash-es/cloneDeep.js";
+import isFunction from "lodash-es/isFunction.js";
+import { isReactive, toRef } from "vue";
+
+const defaultCrud = {
+    args: {},
+    list: undefined,
+    subscribe: undefined,
+};
+
+export const setListCrud = ({ list, subscribe, args = {}, ...rest }) => {
+    defaultCrud.list = list;
+    defaultCrud.subscribe = subscribe;
+    // defensive cloning
+    Object.assign(defaultCrud.args, cloneDeep(args));
+    if (Object.keys(rest).length) {
+        throw new Error(`Unknown key(s) passed to setListCrud: ${Object.keys(rest).join(", ")}`);
+    }
+};
+
+export const getListCrud = (reactiveCrud, { props, functions } = {}) => {
+    // don't mutate the default crud
+    Object.assign(reactiveCrud, cloneDeep(defaultCrud));
+    if (props?.crudArgs) {
+        addOrUpdateReactiveObject(reactiveCrud.args, props.crudArgs);
+    }
+    if (functions) {
+        for (const [key, value] of Object.entries(functions)) {
+            if (isFunction(value) && key in reactiveCrud) {
+                reactiveCrud[key] = isReactive(functions) ? toRef(functions, key) : value;
+            } else {
+                throw Error(`Invalid function "${key}" for getListCrud: invalid key or not a function.`);
+            }
+        }
+    }
+};

package/config/objectCrud.js

@@ -0,0 +1,45 @@
+import { addOrUpdateReactiveObject } from "../utils/assignReactiveObject.js";
+import cloneDeep from "lodash-es/cloneDeep.js";
+import isFunction from "lodash-es/isFunction.js";
+import { isReactive, toRef } from "vue";
+
+const defaultCrud = {
+    args: {},
+    retrieve: undefined,
+    create: undefined,
+    update: undefined,
+    patch: undefined,
+    delete: undefined,
+    subscribe: undefined,
+};
+
+export const setObjectCrud = ({ retrieve, create, update, patch, delete: deleteFn, subscribe, args = {}, ...rest }) => {
+    defaultCrud.retrieve = retrieve;
+    defaultCrud.create = create;
+    defaultCrud.update = update;
+    defaultCrud.patch = patch;
+    defaultCrud.delete = deleteFn;
+    defaultCrud.subscribe = subscribe;
+    // defensive cloning
+    Object.assign(defaultCrud.args, cloneDeep(args));
+    if (Object.keys(rest).length) {
+        throw new Error(`Unknown key(s) passed to setObjectCrud: ${Object.keys(rest).join(", ")}`);
+    }
+};
+
+export const getObjectCrud = (reactiveCrud, { props, functions } = {}) => {
+    // don't mutate the default crud
+    Object.assign(reactiveCrud, cloneDeep(defaultCrud));
+    if (props?.crudArgs) {
+        addOrUpdateReactiveObject(reactiveCrud.args, props.crudArgs);
+    }
+    if (functions) {
+        for (const [key, value] of Object.entries(functions)) {
+            if (isFunction(value) && key in reactiveCrud) {
+                reactiveCrud[key] = isReactive(functions) ? toRef(functions, key) : value;
+            } else {
+                throw Error(`Invalid function "${key}" for getObjectCrud: invalid key or not a function.`);
+            }
+        }
+    }
+};

package/docs.md

@@ -23,23 +23,31 @@
 
 ## Functions
 
-| Name                         | Description |
-| ---------------------------- | ----------- |
-| [useCombineClasses(classes)] |
+| Name                           | Description                                                                                                                                                                                                                                               |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [useCombineClasses(classes)]   |
+| [useListInstance(options)]     | `useListInstance` is a Vue composition function that manages a list of objects. It has the ability to retrieve the list from an implementation, or subscribe to updates from an implementation. It tracks the objects in the list, and their added order. |
+| [useListSubscription(options)] | `useListSubscription` creates a reactive object that manages a list of objects, as returned by `useListInstance`, causing the list to be re-fetched as needed and listening for updates to the list.                                                      |
 
 ## Typedefs
 
-| Name                 | Description                                                                                            |
-| -------------------- | ------------------------------------------------------------------------------------------------------ |
-| [CSSValue]           | A string representing a CSS class or a space-separated list of CSS classes.                            |
-| [CSSObject]          | A CSS object where keys are CSS classes and values are booleans indicating whether to apply the class. |
-| [CSSClasses]         | A mixed array containing multiple ways of specifying CSS classes.                                      |
-| [CSSStringOrObject]  | The amalgamated classes as returned by `objectifyClasses` & `combineClasses`.                          |
-| [CSSValue]           | A string representing a CSS class or a space-separated list of CSS classes.                            |
-| [CSSObject]          | A CSS object where keys are CSS classes and values are booleans indicating whether to apply the class. |
-| [CSSClasses]         | A mixed array containing multiple ways of specifying CSS classes.                                      |
-| [CSSClassesWithRefs] | A mixed array containing multiple ways of specifying CSS classes.                                      |
-| [CSSStringOrObject]  | A CSS object or a space-separated list of CSS classes.                                                 |
+| Name                      | Description                                                                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------ |
+| [CSSValue]                | A string representing a CSS class or a space-separated list of CSS classes.                            |
+| [CSSObject]               | A CSS object where keys are CSS classes and values are booleans indicating whether to apply the class. |
+| [CSSClasses]              | A mixed array containing multiple ways of specifying CSS classes.                                      |
+| [CSSStringOrObject]       | The amalgamated classes as returned by `objectifyClasses` & `combineClasses`.                          |
+| [ListInstanceOptions]     | The configuration options used to create a list instance.                                              |
+| [ListInstanceState]       | A reactive object that manages a list of objects, as returned by `useListInstance`.                    |
+| [ListInstance]            |
+| [ListSubscriptionOptions] | The configuration options used to create a list subscription.                                          |
+| [ListSubscriptionState]   | A reactive object that manages a list of objects, as returned by `useListInstance`.                    |
+| [ListSubscription]        |
+| [CSSValue]                | A string representing a CSS class or a space-separated list of CSS classes.                            |
+| [CSSObject]               | A CSS object where keys are CSS classes and values are booleans indicating whether to apply the class. |
+| [CSSClasses]              | A mixed array containing multiple ways of specifying CSS classes.                                      |
+| [CSSClassesWithRefs]      | A mixed array containing multiple ways of specifying CSS classes.                                      |
+| [CSSStringOrObject]       | A CSS object or a space-separated list of CSS classes.                                                 |
 
 ## utils/assignReactiveObject
 
@@ -427,6 +435,31 @@ Remove empty objects and undefined values from arrays in a mixed object array tr
 | ------- | -------------- | -------------------------------------------------------------------------------------------- |
 | classes | [`CSSClasses`] | A mixed array containing multiple ways of specifying CSS classes. Non-ref values are cloned. |
 
+## useListInstance(options)
+
+`useListInstance` is a Vue composition function that manages a list of objects.
+It has the ability to retrieve the list from an implementation, or subscribe to updates from an implementation.
+It tracks the objects in the list, and their added order.
+
+**Kind**: global function  
+**Returns**: [`ListInstance`] - - the list instance
+
+| Param   | Type                    | Description                                  |
+| ------- | ----------------------- | -------------------------------------------- |
+| options | [`ListInstanceOptions`] | the options used to create the list instance |
+
+## useListSubscription(options)
+
+`useListSubscription` creates a reactive object that manages a list of objects, as returned by `useListInstance`,
+causing the list to be re-fetched as needed and listening for updates to the list.
+
+**Kind**: global function  
+**Returns**: ListSubscription
+
+| Param   | Type                        |
+| ------- | --------------------------- |
+| options | [`ListSubscriptionOptions`] |
+
 ## CSSValue
 
 A string representing a CSS class or a space-separated list of CSS classes.
@@ -451,6 +484,115 @@ The amalgamated classes as returned by `objectifyClasses` & `combineClasses`.
 
 **Kind**: global typedef
 
+## ListInstanceOptions
+
+The configuration options used to create a list instance.
+
+**Kind**: global typedef  
+**Properties**
+
+| Name                | Type       | Description                                                                              |
+| ------------------- | ---------- | ---------------------------------------------------------------------------------------- |
+| props               | `object`   | props passed to the component                                                            |
+| props.retrieveArgs  | `object`   | the arguments passed to the server                                                       |
+| props.listArgs      | `object`   | the arguments passed to the server                                                       |
+| props.crudArgs      | `object`   | implementation specific arguments                                                        |
+| functions           | `object`   | optional. default implementation are used as set by `setListCrud`.                       |
+| functions.list      | `function` | provide the implementation for the list function                                         |
+| functions.subscribe | `function` | provide the implementation for the subscribe function                                    |
+| keepOldPages        | `boolean`  | if true, pages will not be cleared when defaultPageCallback is called. default is false. |
+
+## ListInstanceState
+
+A reactive object that manages a list of objects, as returned by `useListInstance`.
+
+**Kind**: global typedef  
+**Properties**
+
+| Name           | Type       | Description                                |
+| -------------- | ---------- | ------------------------------------------ |
+| crud           | `object`   | the crud functions                         |
+| crud.args      | `object`   | the arguments passed to the crud functions |
+| crud.list      | `function` | the list function                          |
+| crud.subscribe | `function` | the subscribe function                     |
+| retrieveArgs   | `object`   | the arguments passed to the server         |
+| listArgs       | `object`   | the arguments passed to the server         |
+| objects        | `Map`      | the objects in the list                    |
+| loading        | `boolean`  | true if the list is loading                |
+| errored        | `boolean`  | true if the list has errored               |
+| error          | `object`   | the error object                           |
+| objectsInOrder | `Array`    | the objects in the list in order           |
+| order          | `Array`    | the order of the objects in the list       |
+| totalRecords   | `number`   | the total number of records                |
+| totalPages     | `number`   | the total number of pages                  |
+| perPage        | `number`   | the number of records per page             |
+
+## ListInstance
+
+**Kind**: global typedef  
+**Properties**
+
+| Name                | Type                  | Description                                  |
+| ------------------- | --------------------- | -------------------------------------------- |
+| list                | `function`            | subscribe to updates from the implementation |
+| addListObject       | `function`            | add an object to the list                    |
+| updateListObject    | `function`            | update an object in the list                 |
+| deleteListObject    | `function`            | delete an object from the list               |
+| clearList           | `function`            | clear the list                               |
+| clearError          | `function`            | clear the error                              |
+| getFakeId           | `function`            | get a fake id                                |
+| defaultPageCallback | `function`            | the default page callback                    |
+| pageCallback        | `function`            | the page callback                            |
+| state               | [`ListInstanceState`] | the list instance state                      |
+| effectScope         | `object`              | a Vue effect scope                           |
+
+## ListSubscriptionOptions
+
+The configuration options used to create a list subscription.
+
+**Kind**: global typedef  
+**Properties**
+
+| Name         | Type             | Description                                                                              |
+| ------------ | ---------------- | ---------------------------------------------------------------------------------------- |
+| props        | `object`         | passed on to a created list instance if one is not provided                              |
+| functions    | `object`         | passed on to a created list instance if one is not provided                              |
+| listInstance | [`ListInstance`] | a list instance to use instead of creating one                                           |
+| keepOldPages | `boolean`        | if true, pages will not be cleared when defaultPageCallback is called. default is false. |
+
+## ListSubscriptionState
+
+A reactive object that manages a list of objects, as returned by `useListInstance`.
+
+**Kind**: global typedef  
+**Extends**: [`ListInstanceState`]  
+**Properties**
+
+| Name                | Type      | Description                                                       |
+| ------------------- | --------- | ----------------------------------------------------------------- |
+| subscriptionLoading | `boolean` | true if the subscription is loading                               |
+| subscriptionErrored | `boolean` | true if the subscription errored                                  |
+| subscriptionError   | `Error`   | the error that caused the subscription to error                   |
+| intendToList        | `boolean` | true if the list should be fetched, or refetched when args change |
+| intendToSubscribe   | `boolean` | true if the list should subscribe for updates                     |
+| subscribed          | `boolean` | true if the subscription is active                                |
+
+## ListSubscription
+
+**Kind**: global typedef  
+**Properties**
+
+| Name               | Type                      | Description                                                                            |
+| ------------------ | ------------------------- | -------------------------------------------------------------------------------------- |
+| state              | [`ListSubscriptionState`] | the reactive state of the list subscription                                            |
+| listInstance       | [`ListInstance`]          | the list instance used by the subscription                                             |
+| listIntent         | `object`                  | the useCancelleableIntent object managing if the list should be (re)fetched            |
+| subscriptionIntent | `object`                  | the useCancelleableIntent object managing if the subscription should be (un)subscribed |
+| subscribe          | `function`                | subscribe to the list                                                                  |
+| unsubscribe        | `function`                | unsubscribe from the list                                                              |
+| clearError         | `function`                | clear the subscription error                                                           |
+| effectScope        | `object`                  | a Vue effect scope                                                                     |
+
 ## CSSValue
 
 A string representing a CSS class or a space-separated list of CSS classes.
@@ -500,6 +642,12 @@ A CSS object or a space-separated list of CSS classes.
 [cssobject]: #cssobject
 [cssclasses]: #cssclasses
 [cssstringorobject]: #cssstringorobject
+[listinstanceoptions]: #listinstanceoptions
+[listinstancestate]: #listinstancestate
+[listinstance]: #listinstance
+[listsubscriptionoptions]: #listsubscriptionoptions
+[listsubscriptionstate]: #listsubscriptionstate
+[listsubscription]: #listsubscription
 [cssclasseswithrefs]: #cssclasseswithrefs
 [~validtargetorsource]: #utilsassignreactiveobjectvalidtargetorsource
 [`utils/assignreactiveobject`]: #utilsassignreactiveobject
@@ -515,7 +663,14 @@ A CSS object or a space-separated list of CSS classes.
 [`cssclasses`]: #cssclasses
 [`cssstringorobject`]: #cssstringorobject
 [`cssclasseswithrefs`]: #cssclasseswithrefs
+[`listinstance`]: #listinstance
+[`listinstanceoptions`]: #listinstanceoptions
+[`listsubscriptionoptions`]: #listsubscriptionoptions
+[`listinstancestate`]: #listinstancestate
+[`listsubscriptionstate`]: #listsubscriptionstate
 [usecombineclasses(classes)]: #usecombineclassesclasses
+[uselistinstance(options)]: #uselistinstanceoptions
+[uselistsubscription(options)]: #uselistsubscriptionoptions
 [~addreactiveobject(target, source, \[exclude\], \[addedkeys\])]: #utilsassignreactiveobjectaddreactiveobjecttarget-source-exclude-addedkeys
 [~updatereactiveobject(target, source, \[exclude\], \[samekeys\])]: #utilsassignreactiveobjectupdatereactiveobjecttarget-source-exclude-samekeys
 [~addorupdatereactiveobject(target, source, \[exclude\], \[addedkeys\], \[samekeys\])]: #utilsassignreactiveobjectaddorupdatereactiveobjecttarget-source-exclude-addedkeys-samekeys

package/index.js

@@ -1,2 +1,3 @@
+export * from "./config/index.js";
 export * from "./use/index.js";
 export * from "./utils/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@arrai-innovations/reactive-helpers",
-    "version": "9.0.2",
+    "version": "10.0.0",
     "description": "VueJS 3 utility composition functions to help manipulate objects and lists.",
     "main": "index.js",
     "type": "module",

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

@@ -0,0 +1,18 @@
+import * as config from "../../../config/index.js";
+import fs from "fs/promises";
+
+describe("config/index.js", function () {
+    it("should export everything exported by individual files", async function () {
+        const files = await fs.readdir("./config");
+        const modules = files.filter((file) => file.endsWith(".js") && file !== "index.js");
+        const exportedKeys = [];
+        for (const module of modules) {
+            const moduleExports = await import(`../../../config/${module}`);
+            exportedKeys.push(...Object.keys(moduleExports).filter((key) => key !== "default"));
+        }
+        const useKeys = Object.keys(config);
+        useKeys.sort();
+        exportedKeys.sort();
+        expect(useKeys).toEqual(exportedKeys);
+    });
+});

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

@@ -0,0 +1,107 @@
+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();
+
+            const retrievedCrud = reactive({});
+            expect(() => getListCrud(retrievedCrud)).not.toThrow();
+            expect(new Set(Object.keys(retrievedCrud))).toEqual(new Set(["list", "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

@@ -0,0 +1,155 @@
+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();
+
+            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/use/cancellableIntent.spec.js

@@ -1,4 +1,4 @@
-import { useCancellableIntent } from "../../../use/index.js";
+import { useCancellableIntent } from "../../../use/cancellableIntent.js";
 import { CancellableResolvable } from "../crudPromise.js";
 import flushPromises from "flush-promises";
 import { nextTick, reactive, ref } from "vue";

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

@@ -9,12 +9,13 @@ afterAll(() => {
 });
 
 const fields = ["id", "__str__", "name"];
-describe.skip("use/listInstance.spec.js", function () {
+describe("use/listInstance.spec.js", function () {
     let useListInstance, ListError, useListInstances, globalList;
     beforeEach(async () => {
+        const listCrud = await import("../../../config/listCrud.js");
         const imported = await import("../../../use/listInstance");
         globalList = vi.fn();
-        imported.setListInstanceCrud({
+        listCrud.setListCrud({
             list: globalList,
             args: { stream: "test_stream" },
         });
@@ -143,8 +144,8 @@ describe.skip("use/listInstance.spec.js", function () {
             expect({ ...listInstance.state.objects }).toEqual({});
             globalList.mockImplementation(() => new Promise(() => {}));
 
-            listInstance.list();
-            await expect(listInstance.list()).rejects.toThrow(ListError);
+            const firstPromise = listInstance.list();
+            expect(listInstance.list()).toBe(firstPromise);
 
             expect(globalList).toHaveBeenCalledWith({
                 crudArgs: { stream: "test_stream" },