@arrai-innovations/reactive-helpers 9.0.2 → 10.0.0

package/use/objectCalculated.js

@@ -1,8 +1,21 @@
-import { keyDiff, loadingCombine } from "../utils/index.js";
+import { keyDiff } from "../utils/keyDiff.js";
+import { loadingCombine } from "../utils/loadingCombine.js";
+import { objectInstanceStateKeys } from "./objectInstance.js";
+import { objectRelatedStateKeys } from "./objectRelated.js";
+import { objectSubscriptionStateKeys } from "./objectSubscription.js";
 import { useWatchesRunning } from "./watchesRunning.js";
 import isEmpty from "lodash-es/isEmpty.js";
 import { computed, effectScope, onScopeDispose, reactive, toRef, watch } from "vue";
 
+export const objectCalculatedStateKeys = [
+    "calculatedObject",
+    "calculatedObjectRules",
+    "calculatedObjectWatchRunning",
+    "parentStateObjectWatchRunning",
+];
+
+export const objectCalculatedFunctions = [];
+
 export function useObjectCalculateds(instances, args) {
     for (const [key, value] of Object.entries(args)) {
         useObjectCalculated({
@@ -13,54 +26,28 @@ export function useObjectCalculateds(instances, args) {
 }
 
 // the single object version of useListCalculated
-export function useObjectCalculated({
-    parentState,
-    calculatedObjectRules,
-    calculatedObjectPropertyName = "calculatedObject", // NOT REACTIVE
-    passThroughPropertyNames = [
-        // instance
-        "crud",
-        "deleted",
-        "error",
-        "errored",
-        "id",
-        "loading",
-        "object",
-        "retrieveArgs",
-        // subscription
-        "intendToRetrieve",
-        "intendToSubscribe",
-        "subscribed",
-        "subscriptionError",
-        "subscriptionErrored",
-        "subscriptionLoading",
-        // related
-        "relatedObject",
-        "relatedObjectObjects",
-        "relatedObjectRules",
-        "relatedObjectWatchRunning",
-        "relatedRunning",
-    ], // NOT REACTIVE
-}) {
+export function useObjectCalculated({ parentState, calculatedObjectRules }) {
     const state = reactive({
         calculatedObjectRules,
-        calculatedObjectObjects: {},
+        calculatedObject: {},
         parentStateObjectWatchRunning: false,
         calculatedObjectWatchRunning: false,
     });
     const calculatedObjectEffectScopes = {};
     const calculatedObjectOriginalFunctions = {};
 
-    // don't change calculatedObjectPropertyName on us or it will break
-    const copn = calculatedObjectPropertyName + "";
-
     let watchesRunning = null;
 
     const es = effectScope();
 
     es.run(() => {
-        state[copn] = toRef(state, "calculatedObjectObjects");
-        for (let key of passThroughPropertyNames) {
+        for (const key of objectInstanceStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of objectSubscriptionStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of objectRelatedStateKeys) {
             state[key] = toRef(parentState, key);
         }
 
@@ -84,7 +71,7 @@ export function useObjectCalculated({
             }
             for (const removedKey of removedKeys) {
                 delete calculatedObjectOriginalFunctions[removedKey];
-                delete state.calculatedObjectObjects[removedKey];
+                delete state.calculatedObject[removedKey];
                 if (calculatedObjectEffectScopes[removedKey]) {
                     calculatedObjectEffectScopes[removedKey].stop();
                     delete calculatedObjectEffectScopes[removedKey];
@@ -94,7 +81,7 @@ export function useObjectCalculated({
                 calculatedObjectOriginalFunctions[addedKey] = state.calculatedObjectRules[addedKey];
                 calculatedObjectEffectScopes[addedKey] = effectScope();
                 calculatedObjectEffectScopes[addedKey].run(() => {
-                    state.calculatedObjectObjects[addedKey] = computed(() =>
+                    state.calculatedObject[addedKey] = computed(() =>
                         calculatedObjectOriginalFunctions[addedKey](state.object)
                     );
                 });
@@ -110,7 +97,7 @@ export function useObjectCalculated({
         });
 
         state.calculatedRunning = toRef(watchesRunning.state, "running");
-        state.running = computed(() => loadingCombine(watchesRunning.state.running, parentState.relatedRunning));
+        state.running = computed(() => loadingCombine(watchesRunning.state.running, parentState.running));
 
         onScopeDispose(() => {
             for (const key in calculatedObjectEffectScopes) {

package/use/objectInstance.js

@@ -1,6 +1,5 @@
-import { addOrUpdateReactiveObject, assignReactiveObject } from "../utils/index.js";
-import cloneDeep from "lodash-es/cloneDeep.js";
-import isFunction from "lodash-es/isFunction.js";
+import { getObjectCrud } from "../config/objectCrud.js";
+import { assignReactiveObject } from "../utils/assignReactiveObject.js";
 import { reactive, toRef } from "vue";
 
 export class ObjectError extends Error {
@@ -10,23 +9,18 @@ export class ObjectError extends Error {
     }
 }
 
-const defaultCrud = {
-    args: {},
-    retrieve: undefined,
-    create: undefined,
-    update: undefined,
-    patch: undefined,
-    delete: undefined,
-};
+export const objectInstanceStateKeys = [
+    "crud",
+    "id",
+    "retrieveArgs",
+    "object",
+    "loading",
+    "errored",
+    "error",
+    "deleted",
+];
 
-export function setObjectInstanceCrud({ retrieve, create, update, patch, delete: deleteFn, args = {} }) {
-    defaultCrud.retrieve = retrieve;
-    defaultCrud.create = create;
-    defaultCrud.update = update;
-    defaultCrud.patch = patch;
-    defaultCrud.delete = deleteFn;
-    Object.assign(defaultCrud.args, args);
-}
+export const objectInstanceFunctions = ["create", "retrieve", "update", "delete", "patch", "clearError", "clear"];
 
 export function useObjectInstances(instanceArgs) {
     const instances = {};
@@ -40,11 +34,11 @@ export function useObjectInstance({ props, functions = {} }) {
     const state = reactive({
         crud: {
             args: {},
-            retrieve: undefined,
             create: undefined,
+            retrieve: undefined,
             update: undefined,
-            patch: undefined,
             delete: undefined,
+            patch: undefined,
         },
         object: {},
         id: toRef(props, "id"),
@@ -54,18 +48,8 @@ export function useObjectInstance({ props, functions = {} }) {
         error: null,
         deleted: false,
     });
-    // prevent linking of all instances to the same default .args object
-    Object.assign(state.crud, cloneDeep(defaultCrud));
-    if (props.crudArgs) {
-        addOrUpdateReactiveObject(state.crud.args, props.crudArgs);
-    }
-    for (const [key, value] of Object.entries(functions)) {
-        if (isFunction(value) && key in state.crud) {
-            state[key] = value;
-        } else {
-            throw ObjectError(`Invalid function "${key}" for useObjectInstance: invalid key or not a function.`);
-        }
-    }
+
+    getObjectCrud(state.crud, { props, functions });
 
     // due to retrieve being called by `useCancelleableIntent`, if called manually then by the watch,
     //  it will run into the loading check. Instead, return the current retrieve promise if it exists.
@@ -229,11 +213,11 @@ export function useObjectInstance({ props, functions = {} }) {
 
     return reactive({
         state,
-        retrieve,
         create,
+        retrieve,
         update,
-        patch,
         delete: deleteFn,
+        patch,
         clearError,
         clear,
     });

package/use/objectRelated.js

@@ -1,4 +1,7 @@
-import { keyDiff } from "../utils/index.js";
+import { loadingCombine } from "../utils/index.js";
+import { keyDiff } from "../utils/keyDiff.js";
+import { objectInstanceStateKeys } from "./objectInstance.js";
+import { objectSubscriptionStateKeys } from "./objectSubscription.js";
 import { useWatchesRunning } from "./watchesRunning.js";
 import get from "lodash-es/get.js";
 import isArray from "lodash-es/isArray.js";
@@ -6,6 +9,15 @@ import isEmpty from "lodash-es/isEmpty.js";
 import isUndefined from "lodash-es/isUndefined.js";
 import { computed, effectScope, onScopeDispose, reactive, toRef, unref, watch } from "vue";
 
+export const objectRelatedStateKeys = [
+    "relatedObject",
+    "relatedObjectRules",
+    "relatedObjectWatchRunning",
+    "parentStateObjectWatchRunning",
+];
+
+export const objectRelatedFunctions = [];
+
 export function useObjectRelateds(instances, args) {
     for (const [key, value] of Object.entries(args)) {
         useObjectRelated({
@@ -16,47 +28,24 @@ export function useObjectRelateds(instances, args) {
 }
 
 // the single object version of useListRelated
-export function useObjectRelated({
-    parentState,
-    relatedObjectRules,
-    relatedObjectPropertyName = "relatedObject", // NOT REACTIVE
-    passThroughPropertyNames = [
-        // instance
-        "crud",
-        "deleted",
-        "error",
-        "errored",
-        "id",
-        "loading",
-        "object",
-        "retrieveArgs",
-        // subscription
-        "intendToRetrieve",
-        "intendToSubscribe",
-        "subscribed",
-        "subscriptionError",
-        "subscriptionErrored",
-        "subscriptionLoading",
-    ], // NOT REACTIVE
-}) {
+export function useObjectRelated({ parentState, relatedObjectRules }) {
     const state = reactive({
         relatedObjectRules,
-        relatedObjectObjects: {},
+        relatedObject: {},
         parentStateObjectWatchRunning: false,
         relatedObjectWatchRunning: false,
     });
     const relatedObjectEffectScopes = {};
 
-    // don't change relatedObjectPropertyName on us or it will break
-    const ropn = relatedObjectPropertyName + "";
-
     let watchesRunning = null;
 
     const es = effectScope();
 
     es.run(() => {
-        state[ropn] = toRef(state, "relatedObjectObjects");
-        for (let key of passThroughPropertyNames) {
+        for (const key of objectInstanceStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of objectSubscriptionStateKeys) {
             state[key] = toRef(parentState, key);
         }
 
@@ -64,16 +53,16 @@ export function useObjectRelated({
             let addedRuleKeys = [],
                 removedRuleKeys = [];
             if (!state.relatedObjectRules) {
-                removedRuleKeys = Object.keys(state.relatedObjectObjects);
+                removedRuleKeys = Object.keys(state.relatedObject);
             } else {
                 ({ addedKeys: addedRuleKeys, removedKeys: removedRuleKeys } = keyDiff(
                     Object.keys(state.relatedObjectRules),
-                    Object.keys(state.relatedObjectObjects)
+                    Object.keys(state.relatedObject)
                 ));
             }
 
             for (const removedRuleKey of removedRuleKeys) {
-                delete state.relatedObjectObjects[removedRuleKey];
+                delete state.relatedObject[removedRuleKey];
                 if (relatedObjectEffectScopes[removedRuleKey]) {
                     relatedObjectEffectScopes[removedRuleKey].stop();
                     delete relatedObjectEffectScopes[removedRuleKey];
@@ -82,7 +71,7 @@ export function useObjectRelated({
             for (const addedRuleKey of addedRuleKeys) {
                 relatedObjectEffectScopes[addedRuleKey] = effectScope();
                 relatedObjectEffectScopes[addedRuleKey].run(() => {
-                    state.relatedObjectObjects[addedRuleKey] = computed(() => {
+                    state.relatedObject[addedRuleKey] = computed(() => {
                         // deal with computed objects being passed.
                         const ruleObjects = unref(state.relatedObjectRules?.[addedRuleKey]?.objects);
                         const rulePkKey = state.relatedObjectRules?.[addedRuleKey]?.pkKey || addedRuleKey;
@@ -111,6 +100,7 @@ export function useObjectRelated({
         });
 
         state.relatedRunning = toRef(watchesRunning.state, "running");
+        state.running = computed(() => loadingCombine(watchesRunning.state.running, parentState.running));
 
         onScopeDispose(() => {
             for (const key in relatedObjectEffectScopes) {

package/use/objectSubscription.js

@@ -1,6 +1,6 @@
 import { assignReactiveObject, loadingCombine } from "../utils/index.js";
 import { useCancellableIntent } from "./cancellableIntent.js";
-import { useObjectInstance } from "./objectInstance.js";
+import { useObjectInstance, objectInstanceStateKeys } from "./objectInstance.js";
 import { computed, effectScope, reactive, toRef } from "vue";
 
 export class ObjectSubscriptionError extends Error {
@@ -10,13 +10,22 @@ export class ObjectSubscriptionError extends Error {
     }
 }
 
-const defaultCrud = {
-    subscribe: undefined,
-};
-
-export function setObjectSubscriptionCrud({ subscribe }) {
-    defaultCrud.subscribe = subscribe;
-}
+export const objectSubscriptionStateKeys = [
+    "subscriptionLoading",
+    "subscriptionErrored",
+    "subscriptionError",
+    "subscribed",
+    "intendToRetrieve",
+    "intendToSubscribe",
+];
+
+export const objectSubscriptionFunctions = [
+    "subscribe",
+    "unsubscribe",
+    "updateFromSubscription",
+    "deleteFromSubscription",
+    "clearError",
+];
 
 export function useObjectSubscriptions(subscriptionArgs) {
     const subscriptions = {};
@@ -26,23 +35,9 @@ export function useObjectSubscriptions(subscriptionArgs) {
     return subscriptions;
 }
 
-export function useObjectSubscription({
-    objectInstance,
-    props,
-    passThroughPropertyNames = [
-        // instance
-        "crud",
-        "deleted",
-        // "error",
-        // "errored",
-        "id",
-        // "loading",
-        "object",
-        "retrieveArgs",
-    ],
-}) {
+export function useObjectSubscription({ objectInstance, props, functions }) {
     if (!objectInstance) {
-        objectInstance = useObjectInstance({ props });
+        objectInstance = useObjectInstance({ props, functions });
     } else {
         if (!("id" in props)) {
             console.error("id not set, must be true for intendToRetrieve or intendToSubscribe to work.");
@@ -50,9 +45,11 @@ export function useObjectSubscription({
         if (!("retrieveArgs" in props)) {
             console.error("retrieveArgs not set, must be true for intendToRetrieve or intendToSubscribe to work.");
         }
-    }
-    if (!objectInstance.state.crud.subscribe) {
-        objectInstance.state.crud.subscribe = defaultCrud.subscribe;
+        if (functions) {
+            console.error(
+                "functions passed to useObjectSubscription, but objectInstance was passed. functions ignored."
+            );
+        }
     }
     const parentState = objectInstance.state;
     const state = reactive({
@@ -169,7 +166,7 @@ export function useObjectSubscription({
         state.errored = computed(() => parentState.errored || state.subscriptionErrored);
         state.error = computed(() => parentState.error || state.subscriptionError);
 
-        for (const key of passThroughPropertyNames) {
+        for (const key of objectInstanceStateKeys.filter((key) => !["loading", "errored", "error"].includes(key))) {
             state[key] = toRef(parentState, key);
         }