zova-module-a-model 5.0.9 → 5.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-model",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "title": "a-model",
   "zovaModule": {
     "capabilities": {
@@ -63,5 +63,5 @@
     "js-cookie": "^3.0.5",
     "localforage": "^1.10.0"
   },
-  "gitHead": "6633ccc421b46bbbc08a2a3a6ec7d92544a222de"
+  "gitHead": "d7ecefeb8b5f566e4b4831d7b3a02e9e7a765c15"
 }

package/src/bean/bean.model/bean.model.persister.ts

@@ -70,6 +70,24 @@ export class BeanModelPersister<TScopeModule = unknown> extends BeanModelLast<TS
     }
   }
 
+  $persisterRemove(queryKey: QueryKey) {
+    const query = this.self.$queryFind({ queryKey });
+    if (!query) return;
+    const options = this._adjustPersisterOptions(query.meta?.persister);
+    if (!options) return;
+    const storage = this._getPersisterStorage(options);
+    if (!storage) return;
+    const storageKey = this._getPersisterStorageKey(options, query);
+    if (options.sync === true) {
+      storage.removeItem(storageKey);
+    } else {
+      // Persist if we have storage defined, we use timeout to get proper state to be persisted
+      setTimeout(() => {
+        storage.removeItem(storageKey);
+      }, 0);
+    }
+  }
+
   protected _createPersister(options?: QueryMetaPersister | boolean) {
     options = this._adjustPersisterOptions(options);
     if (!options) return undefined;

package/src/bean/bean.model/bean.model.query.ts

@@ -9,6 +9,7 @@ import {
   SetDataOptions,
   Updater,
 } from '@tanstack/vue-query';
+import localforage from 'localforage';
 import { MaybeRefDeep, NoUnknown } from '../../common/types.js';
 import { Cast } from 'zova';
 import { BeanModelCookie } from './bean.model.cookie.js';
@@ -33,8 +34,15 @@ export class BeanModelQuery<TScopeModule = unknown> extends BeanModelCookie<TSco
   $setQueryData(queryKey, updater, persisterSave, options) {
     queryKey = this._forceQueryKeyPrefix(queryKey);
     const data = this.$queryClient.setQueryData(queryKey, updater, options);
-    if (persisterSave) {
-      this.$persisterSave(queryKey);
+    if (data === undefined) {
+      if (persisterSave) {
+        this.$persisterRemove(queryKey);
+      }
+      this.$setQueryDataDirect(queryKey, data);
+    } else {
+      if (persisterSave) {
+        this.$persisterSave(queryKey);
+      }
     }
     return data;
   }
@@ -56,4 +64,18 @@ export class BeanModelQuery<TScopeModule = unknown> extends BeanModelCookie<TSco
     filters = { ...filters, queryKey };
     return this.$queryClient.invalidateQueries(filters, options);
   }
+
+  $setQueryDataDirect(queryKey: QueryKey, value: any) {
+    const query = this.$queryFind({ queryKey, exact: true });
+    query?.setData(value);
+  }
+
+  async $clear() {
+    const queries = this.$queryClient.getQueryCache().getAll();
+    for (const query of queries) {
+      query?.setData(undefined);
+    }
+    // remove all db cache
+    await localforage.clear();
+  }
 }

package/src/bean/bean.model/bean.model.useMutation.ts

@@ -1,15 +1,22 @@
 import {
   DefaultError,
+  MutationKey,
   MutationObserverOptions,
   QueryClient,
   UseMutationReturnType,
+  hashKey,
   useMutation,
 } from '@tanstack/vue-query';
-import { BeanModelUseQuery } from './bean.model.useQuery.js';
 import { MaybeRefDeep } from '../../common/types.js';
 import { UnwrapNestedRefs } from 'vue';
+import { Cast } from 'zova';
+import { BeanModelUseQuery } from './bean.model.useQuery.js';
+
+const SymbolUseMutations = Symbol('SymbolUseMutations');
 
 export class BeanModelUseMutation<TScopeModule = unknown> extends BeanModelUseQuery<TScopeModule> {
+  private [SymbolUseMutations]: Record<string, unknown> = {};
+
   $useMutation<TData = unknown, TVariables = void, TContext = unknown>(
     mutationOptions: MaybeRefDeep<MutationObserverOptions<TData, DefaultError, TVariables, TContext>>,
     queryClient?: QueryClient,
@@ -18,4 +25,21 @@ export class BeanModelUseMutation<TScopeModule = unknown> extends BeanModelUseQu
       return useMutation(mutationOptions, queryClient) as any;
     });
   }
+
+  $useMutationExisting<TData = unknown, TVariables = void, TContext = unknown>(
+    mutationOptions: MaybeRefDeep<MutationObserverOptions<TData, DefaultError, TVariables, TContext>>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseMutationReturnType<TData, DefaultError, TVariables, TContext>> {
+    let mutationKey: MutationKey = Cast(mutationOptions).mutationKey;
+    if (!mutationKey || mutationKey.length === 0) throw new Error('should specify mutationKey');
+    mutationKey = this.self._forceQueryKeyPrefix(mutationKey);
+    const mutationHash = hashKey(mutationKey);
+    if (!this[SymbolUseMutations][mutationHash]) {
+      mutationOptions = { ...mutationOptions, mutationKey };
+      this[SymbolUseMutations][mutationHash] = this.$useMutation(mutationOptions, queryClient);
+    }
+    return this[SymbolUseMutations][mutationHash] as UnwrapNestedRefs<
+      UseMutationReturnType<TData, DefaultError, TVariables, TContext>
+    >;
+  }
 }

package/src/bean/bean.model/bean.model.useQuery.ts

@@ -17,7 +17,7 @@ import { BeanModelQuery } from './bean.model.query.js';
 const SymbolUseQueries = Symbol('SymbolUseQueries');
 
 export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TScopeModule> {
-  [SymbolUseQueries]: Record<string, unknown> = {};
+  private [SymbolUseQueries]: Record<string, unknown> = {};
 
   $useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(
     options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
@@ -40,42 +40,6 @@ export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TS
     });
   }
 
-  $useQueryExisting<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TData = TQueryFnData,
-    TQueryKey extends QueryKey = QueryKey,
-  >(
-    options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
-  $useQueryExisting<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TData = TQueryFnData,
-    TQueryKey extends QueryKey = QueryKey,
-  >(
-    options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
-  $useQueryExisting<
-    TQueryFnData = unknown,
-    TError = DefaultError,
-    TData = TQueryFnData,
-    TQueryKey extends QueryKey = QueryKey,
-  >(
-    options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
-    queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
-  $useQueryExisting(options, queryClient) {
-    const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
-    const queryHash = hashKey(queryKey);
-    if (!this[SymbolUseQueries][queryHash]) {
-      this[SymbolUseQueries][queryHash] = this.$useQuery(options, queryClient);
-    }
-    return this[SymbolUseQueries][queryHash];
-  }
-
   $useQueryLocal<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -102,21 +66,13 @@ export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TS
         persister: { storage: 'local', sync: true },
       },
     });
-    const queryKey = options.queryKey;
     const self = this;
     return useComputed({
       get() {
-        const query = self.$useQuery(options, queryClient) as any;
-        if (query.data.value === undefined) {
-          const data = self.$persisterLoad(queryKey);
-          if (data !== undefined) {
-            self.$setQueryData(queryKey, data);
-          }
-        }
-        return query.data;
+        return self._handleSyncDataGet(options, queryClient, true);
       },
       set(value) {
-        self.$setQueryData(queryKey, value, true);
+        self._handleSyncDataSet(options, queryClient, true, value);
       },
     });
   }
@@ -162,21 +118,13 @@ export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TS
         },
       },
     );
-    const queryKey = options.queryKey;
     const self = this;
     return useComputed({
       get() {
-        const query = self.$useQuery(options, queryClient) as any;
-        if (query.data.value === undefined) {
-          const data = self.$persisterLoad(queryKey);
-          if (data !== undefined) {
-            self.$setQueryData(queryKey, data);
-          }
-        }
-        return query.data;
+        return self._handleSyncDataGet(options, queryClient, true);
       },
       set(value) {
-        self.$setQueryData(queryKey, value, true);
+        self._handleSyncDataSet(options, queryClient, true, value);
       },
     });
   }
@@ -207,16 +155,81 @@ export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TS
         persister: false,
       },
     });
-    const queryKey = options.queryKey;
     const self = this;
     return useComputed({
       get() {
-        const query = self.$useQuery(options, queryClient) as any;
-        return query.data;
+        return self._handleSyncDataGet(options, queryClient, false);
       },
       set(value) {
-        self.$setQueryData(queryKey, value, false);
+        self._handleSyncDataSet(options, queryClient, false, value);
       },
     });
   }
+
+  $useQueryExisting<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(
+    options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  $useQueryExisting<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(
+    options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
+  $useQueryExisting<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(
+    options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  $useQueryExisting(options, queryClient) {
+    const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
+    const queryHash = hashKey(queryKey);
+    if (!this[SymbolUseQueries][queryHash]) {
+      this[SymbolUseQueries][queryHash] = this.$useQuery(options, queryClient);
+    }
+    return this[SymbolUseQueries][queryHash];
+  }
+
+  private _handleSyncDataGet(options, queryClient, persister) {
+    const queryKey = options.queryKey;
+    const query = this.$useQueryExisting(options, queryClient);
+    if (query.data === undefined) {
+      if (persister) {
+        const data = this.$persisterLoad(queryKey);
+        if (data !== undefined) {
+          this.$setQueryData(queryKey, data, false);
+        }
+      }
+      if (query.data === undefined) {
+        let defaultData = options.meta?.defaultData;
+        if (typeof defaultData === 'function') {
+          defaultData = defaultData();
+        }
+        if (defaultData !== undefined) {
+          // need not persister save
+          this.$setQueryData(queryKey, defaultData, false);
+        }
+      }
+    }
+    return query.data;
+  }
+
+  private _handleSyncDataSet(options, queryClient, persister, value) {
+    const queryKey = options.queryKey;
+    const query = this.$useQueryExisting(options, queryClient);
+    this.$setQueryData(queryKey, value, persister);
+    return query;
+  }
 }

package/src/types.ts

@@ -15,6 +15,7 @@ declare module '@tanstack/vue-query' {
 }
 
 export interface MyQueryMeta extends Record<string, unknown> {
+  defaultData?: (() => any) | any;
   ssr?: QueryMetaSSR;
   persister?: QueryMetaPersister | boolean;
 }