zova-module-a-model 5.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present Zova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "zova-module-a-model",
+  "version": "5.0.9",
+  "title": "a-model",
+  "zovaModule": {
+    "capabilities": {
+      "monkey": true
+    },
+    "bundle": {
+      "vendors": [
+        {
+          "match": [
+            "@tanstack"
+          ],
+          "output": "tanstack"
+        },
+        {
+          "match": [
+            "js-cookie"
+          ],
+          "output": "js-cookie"
+        },
+        {
+          "match": [
+            "localforage"
+          ],
+          "output": "localforage"
+        }
+      ]
+    }
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "description": "core",
+  "keywords": [
+    "Zova Module"
+  ],
+  "author": "zhennann",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "clean": "tsc -b --clean",
+    "tsc:publish": "npm run clean && tsc -b",
+    "prepublishOnly": "npm run tsc:publish"
+  },
+  "dependencies": {
+    "@tanstack/query-persist-client-core": "^5.45.0",
+    "@tanstack/vue-query": "^5.45.0",
+    "@types/js-cookie": "^3.0.6",
+    "js-cookie": "^3.0.5",
+    "localforage": "^1.10.0"
+  },
+  "gitHead": "6633ccc421b46bbbc08a2a3a6ec7d92544a222de"
+}

package/src/api/index.ts

@@ -0,0 +1,2 @@
+export * from './interface/index.js';
+export * from './service/index.js';

package/src/api/interface/index.ts

@@ -0,0 +1 @@
+export {};

package/src/api/service/index.ts

@@ -0,0 +1 @@
+export const services = {};

package/src/assets/css/module.scss

@@ -0,0 +1 @@
+

package/src/bean/bean.model/bean.model.cookie.ts

@@ -0,0 +1,30 @@
+import { Query } from '@tanstack/vue-query';
+import { BeanModelPersister } from './bean.model.persister.js';
+
+export class BeanModelCookie<TScopeModule = unknown> extends BeanModelPersister<TScopeModule> {
+  $serializeCookie(obj?: Query) {
+    return String(obj?.state?.data ?? '');
+  }
+
+  $deserializeCookie(value?: string) {
+    return {
+      state: {
+        data: value,
+        dataUpdateCount: 0,
+        dataUpdatedAt: Date.now(),
+        error: null,
+        errorUpdateCount: 0,
+        errorUpdatedAt: 0,
+        fetchFailureCount: 0,
+        fetchFailureReason: null,
+        fetchMeta: null,
+        isInvalidated: false,
+        status: 'success',
+        fetchStatus: 'idle',
+      },
+      queryKey: undefined,
+      queryHash: undefined,
+      buster: this._getPersisterBuster(),
+    };
+  }
+}

package/src/bean/bean.model/bean.model.first.ts

@@ -0,0 +1,3 @@
+import { BeanModelUseMutation } from './bean.model.useMutation.js';
+
+export class BeanModelFirst<TScopeModule = unknown> extends BeanModelUseMutation<TScopeModule> {}

package/src/bean/bean.model/bean.model.last.ts

@@ -0,0 +1,13 @@
+import { BeanBase, Cast } from 'zova';
+import { BeanModelBase } from '../virtual.model.js';
+import { ScopeModule, __ThisModule__ } from '../../resource/this.js';
+
+export class BeanModelLast<TScopeModule = unknown> extends BeanBase<TScopeModule> {
+  get self() {
+    return Cast<BeanModelBase>(this);
+  }
+
+  get scopeSelf(): ScopeModule {
+    return this.getScope(__ThisModule__);
+  }
+}

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

@@ -0,0 +1,129 @@
+import { QueryMetaPersister } from '../../types.js';
+import { experimental_createPersister } from '@tanstack/query-persist-client-core';
+import { Query, QueryKey } from '@tanstack/vue-query';
+import { cookieStorage } from '../../common/cookieStorage.js';
+import localforage from 'localforage';
+import { SymbolBeanFullName } from 'zova';
+import { BeanModelLast } from './bean.model.last.js';
+
+export class BeanModelPersister<TScopeModule = unknown> extends BeanModelLast<TScopeModule> {
+  $persisterLoad<T>(queryKey: QueryKey): T | undefined {
+    const query = this.self.$queryFind({ queryKey });
+    if (!query) return undefined;
+    const options = this._adjustPersisterOptions(query.meta?.persister);
+    if (!options) return undefined;
+    const storage = this._getPersisterStorage(options);
+    if (!storage) return undefined;
+    const storageKey = this._getPersisterStorageKey(options, query);
+    try {
+      const storedData = storage.getItem(storageKey);
+      if (!storedData) return undefined;
+      const persistedQuery = options.deserialize!(storedData as string);
+
+      if (persistedQuery.state.dataUpdatedAt) {
+        const queryAge = Date.now() - persistedQuery.state.dataUpdatedAt;
+        const expired = queryAge > options.maxAge!;
+        const busted = persistedQuery.buster !== options.buster;
+        if (expired || busted) {
+          storage.removeItem(storageKey);
+        } else {
+          // Set proper updatedAt, since resolving in the first pass overrides those values
+          query.setState({
+            dataUpdatedAt: persistedQuery.state.dataUpdatedAt,
+            errorUpdatedAt: persistedQuery.state.errorUpdatedAt,
+          });
+          return persistedQuery.state.data as T;
+        }
+      } else {
+        storage.removeItem(storageKey);
+      }
+    } catch (err) {
+      if (process.env.NODE_ENV === 'development') {
+        console.error(err);
+        console.warn('Encountered an error attempting to restore query cache from persisted location.');
+      }
+      storage.removeItem(storageKey);
+    }
+  }
+
+  $persisterSave(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);
+    const data = options.serialize!({
+      state: query.state,
+      queryKey: query.queryKey,
+      queryHash: query.queryHash,
+      buster: options.buster,
+    });
+    if (options.sync === true) {
+      storage.setItem(storageKey, data);
+    } else {
+      // Persist if we have storage defined, we use timeout to get proper state to be persisted
+      setTimeout(() => {
+        storage.setItem(storageKey, data);
+      }, 0);
+    }
+  }
+
+  protected _createPersister(options?: QueryMetaPersister | boolean) {
+    options = this._adjustPersisterOptions(options);
+    if (!options) return undefined;
+    return experimental_createPersister({
+      storage: this._getPersisterStorage(options) as any,
+      maxAge: options.maxAge,
+      prefix: options.prefix,
+      buster: options.buster,
+    });
+  }
+
+  protected _adjustPersisterOptions(options?: QueryMetaPersister | boolean) {
+    if (options === false) return undefined;
+    if (options === undefined || options === true) {
+      options = {};
+    } else {
+      options = { ...options };
+    }
+    options.storage = options.storage ?? (options.sync ? 'local' : 'db');
+    options.maxAge =
+      options.maxAge ??
+      (options.sync ? this.scopeSelf.config.persister.sync.maxAge : this.scopeSelf.config.persister.async.maxAge);
+    options.prefix = options.prefix ?? this._getPersisterPrefix();
+    options.buster = options.buster ?? this._getPersisterBuster();
+    options.serialize = options.serialize ?? JSON.stringify;
+    options.deserialize = options.deserialize ?? JSON.parse;
+    return options;
+  }
+
+  protected _getPersisterStorageKey(options: QueryMetaPersister, query: Query) {
+    if (options.storage === 'cookie') return String(query.queryKey[query.queryKey.length - 1]);
+    return `${options.prefix}-${query.queryHash}`;
+  }
+
+  protected _getPersisterStorage(options?: QueryMetaPersister | boolean) {
+    options = this._adjustPersisterOptions(options);
+    if (!options) return undefined;
+    if (options.storage === 'cookie') return cookieStorage;
+    if (options.storage === 'local') return localStorage;
+    if (options.storage === 'db') return localforage;
+  }
+
+  protected _getPersisterPrefix() {
+    return `${this.app.config.env.appName}-query`;
+  }
+
+  protected _getPersisterBuster() {
+    return this.app.config.env.appVersion;
+  }
+
+  protected _forceQueryKeyPrefix(queryKey?: QueryKey): QueryKey {
+    if (!queryKey) queryKey = [];
+    const prefix = queryKey[0];
+    if (prefix && typeof prefix === 'string' && prefix.split('.').length === 3) return queryKey;
+    return [this[SymbolBeanFullName]].concat(queryKey as any);
+  }
+}

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

@@ -0,0 +1,59 @@
+import {
+  DataTag,
+  DefaultError,
+  InvalidateOptions,
+  InvalidateQueryFilters,
+  Query,
+  QueryFilters,
+  QueryKey,
+  SetDataOptions,
+  Updater,
+} from '@tanstack/vue-query';
+import { MaybeRefDeep, NoUnknown } from '../../common/types.js';
+import { Cast } from 'zova';
+import { BeanModelCookie } from './bean.model.cookie.js';
+
+export class BeanModelQuery<TScopeModule = unknown> extends BeanModelCookie<TScopeModule> {
+  $setQueryData<
+    TQueryFnData,
+    TTaggedQueryKey extends QueryKey,
+    TData = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue> ? TaggedValue : TQueryFnData,
+  >(
+    queryKey: TTaggedQueryKey,
+    updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
+    persisterSave?: boolean,
+    options?: MaybeRefDeep<SetDataOptions>,
+  ): TData | undefined;
+  $setQueryData<TQueryFnData, TData = NoUnknown<TQueryFnData>>(
+    queryKey: MaybeRefDeep<QueryKey>,
+    updater: Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>,
+    persisterSave?: boolean,
+    options?: MaybeRefDeep<SetDataOptions>,
+  ): TData | undefined;
+  $setQueryData(queryKey, updater, persisterSave, options) {
+    queryKey = this._forceQueryKeyPrefix(queryKey);
+    const data = this.$queryClient.setQueryData(queryKey, updater, options);
+    if (persisterSave) {
+      this.$persisterSave(queryKey);
+    }
+    return data;
+  }
+
+  $queryFind<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(
+    filters: QueryFilters,
+  ): Query<TQueryFnData, TError, TData> | undefined {
+    filters = { ...filters };
+    Cast(filters).queryKey = this._forceQueryKeyPrefix(Cast(filters).queryKey);
+    return this.$queryClient.getQueryCache().find(filters as any);
+  }
+
+  $invalidateQueries(
+    filters?: MaybeRefDeep<InvalidateQueryFilters>,
+    options?: MaybeRefDeep<InvalidateOptions>,
+  ): Promise<void> {
+    if (!filters) filters = {};
+    const queryKey = this._forceQueryKeyPrefix(Cast(filters).queryKey);
+    filters = { ...filters, queryKey };
+    return this.$queryClient.invalidateQueries(filters, options);
+  }
+}

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

@@ -0,0 +1,21 @@
+import {
+  DefaultError,
+  MutationObserverOptions,
+  QueryClient,
+  UseMutationReturnType,
+  useMutation,
+} from '@tanstack/vue-query';
+import { BeanModelUseQuery } from './bean.model.useQuery.js';
+import { MaybeRefDeep } from '../../common/types.js';
+import { UnwrapNestedRefs } from 'vue';
+
+export class BeanModelUseMutation<TScopeModule = unknown> extends BeanModelUseQuery<TScopeModule> {
+  $useMutation<TData = unknown, TVariables = void, TContext = unknown>(
+    mutationOptions: MaybeRefDeep<MutationObserverOptions<TData, DefaultError, TVariables, TContext>>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseMutationReturnType<TData, DefaultError, TVariables, TContext>> {
+    return this.ctx.meta.util.instanceScope(() => {
+      return useMutation(mutationOptions, queryClient) as any;
+    });
+  }
+}

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

@@ -0,0 +1,222 @@
+import {
+  DefaultError,
+  QueryKey,
+  useQuery,
+  QueryClient,
+  UseQueryReturnType,
+  UseQueryDefinedReturnType,
+  UseQueryOptions,
+  Query,
+  hashKey,
+} from '@tanstack/vue-query';
+import { UnwrapNestedRefs } from 'vue';
+import { useComputed } from 'zova';
+import { DefinedInitialQueryOptions, UndefinedInitialQueryOptions } from '../../common/types.js';
+import { BeanModelQuery } from './bean.model.query.js';
+
+const SymbolUseQueries = Symbol('SymbolUseQueries');
+
+export class BeanModelUseQuery<TScopeModule = unknown> extends BeanModelQuery<TScopeModule> {
+  [SymbolUseQueries]: Record<string, unknown> = {};
+
+  $useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(
+    options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  $useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(
+    options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
+  $useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(
+    options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
+    queryClient?: QueryClient,
+  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  $useQuery(options, queryClient) {
+    const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
+    const persister = this._createPersister(options.meta?.persister);
+    options = { ...options, queryKey, persister };
+    return this.ctx.meta.util.instanceScope(() => {
+      return useQuery(options, queryClient);
+    });
+  }
+
+  $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,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryLocal<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryLocal<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryLocal(options, queryClient) {
+    options = this.app.meta.util.extend({}, options, {
+      enabled: false,
+      staleTime: Infinity,
+      meta: {
+        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;
+      },
+      set(value) {
+        self.$setQueryData(queryKey, value, true);
+      },
+    });
+  }
+
+  $useQueryCookie<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryCookie<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryCookie<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryCookie(options, queryClient) {
+    options = this.app.meta.util.extend(
+      {
+        meta: {
+          persister: {
+            serialize: (obj?: Query) => {
+              return this.$serializeCookie(obj);
+            },
+            deserialize: (value?: string) => {
+              return this.$deserializeCookie(value);
+            },
+          },
+        },
+      },
+      options,
+      {
+        enabled: false,
+        staleTime: Infinity,
+        meta: {
+          persister: { storage: 'cookie', 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;
+      },
+      set(value) {
+        self.$setQueryData(queryKey, value, true);
+      },
+    });
+  }
+
+  $useQueryMem<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryMem<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryMem<
+    TQueryFnData = unknown,
+    TError = DefaultError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey,
+  >(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): TData;
+  $useQueryMem(options, queryClient) {
+    options = this.app.meta.util.extend({}, options, {
+      enabled: false,
+      staleTime: Infinity,
+      meta: {
+        persister: false,
+      },
+    });
+    const queryKey = options.queryKey;
+    const self = this;
+    return useComputed({
+      get() {
+        const query = self.$useQuery(options, queryClient) as any;
+        return query.data;
+      },
+      set(value) {
+        self.$setQueryData(queryKey, value, false);
+      },
+    });
+  }
+}

package/src/bean/virtual.model.ts

@@ -0,0 +1,5 @@
+import { Virtual } from 'zova';
+import { BeanModelFirst } from './bean.model/bean.model.first.js';
+
+@Virtual()
+export class BeanModelBase<TScopeModule = unknown> extends BeanModelFirst<TScopeModule> {}

package/src/common/cookieStorage.ts

@@ -0,0 +1,13 @@
+import Cookies from 'js-cookie';
+
+export const cookieStorage = {
+  getItem(key: string): string | undefined {
+    return Cookies.get(key);
+  },
+  setItem(key: string, value: string): void {
+    Cookies.set(key, value);
+  },
+  removeItem(key: string): void {
+    Cookies.remove(key);
+  },
+};

package/src/common/types.ts

@@ -0,0 +1,58 @@
+import { DefaultError, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import { Ref, UnwrapRef } from 'vue';
+import { Functionable } from 'zova';
+
+export type NonUndefinedGuard<T> = T extends undefined ? never : T;
+
+export type UndefinedInitialQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+  initialData?: undefined;
+};
+export type DefinedInitialQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> & {
+  initialData: NonUndefinedGuard<TQueryFnData> | (() => NonUndefinedGuard<TQueryFnData>);
+};
+
+export type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+export type UnwrapLeaf =
+  | Primitive
+  | Functionable
+  | Date
+  | Error
+  | RegExp
+  | Map<any, any>
+  | WeakMap<any, any>
+  | Set<any>
+  | WeakSet<any>;
+export type MaybeRef<T> = Ref<T> | T;
+export type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
+export type MaybeRefDeep<T> = MaybeRef<
+  T extends Functionable
+    ? T
+    : T extends object
+      ? {
+          [Property in keyof T]: MaybeRefDeep<T[Property]>;
+        }
+      : T
+>;
+export type NoUnknown<T> = Equal<unknown, T> extends true ? never : T;
+export type Equal<TTargetA, TTargetB> =
+  (<T>() => T extends TTargetA ? 1 : 2) extends <T>() => T extends TTargetB ? 1 : 2 ? true : false;
+export type DeepUnwrapRef<T> = T extends UnwrapLeaf
+  ? T
+  : T extends Ref<infer U>
+    ? DeepUnwrapRef<U>
+    : T extends {}
+      ? {
+          [Property in keyof T]: DeepUnwrapRef<T[Property]>;
+        }
+      : UnwrapRef<T>;
+export type DistributiveOmit<T, TKeyOfAny extends keyof any> = T extends any ? Omit<T, TKeyOfAny> : never;

package/src/config/config.ts

@@ -0,0 +1,14 @@
+import { ZovaApplication } from 'zova';
+
+export const config = (_app: ZovaApplication) => {
+  return {
+    persister: {
+      sync: {
+        maxAge: Infinity,
+      },
+      async: {
+        maxAge: 1000 * 60 * 60 * 24, // 24 hours
+      },
+    },
+  };
+};

package/src/config/constants.ts

@@ -0,0 +1 @@
+export const constants = null;

package/src/config/errors.ts

@@ -0,0 +1 @@
+export enum Errors {}

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export * from './locales.js';
+export * from './errors.js';
+export * from './config.js';
+export * from './constants.js';

package/src/config/locale/en-us.ts

@@ -0,0 +1 @@
+export default {};

package/src/config/locale/zh-cn.ts

@@ -0,0 +1 @@
+export default {};

package/src/config/locales.ts

@@ -0,0 +1,7 @@
+import en_us from './locale/en-us.js';
+import zh_cn from './locale/zh-cn.js';
+
+export const locales = {
+  'en-us': en_us,
+  'zh-cn': zh_cn,
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+import './assets/css/module.scss';
+export * from './config/index.js';
+export * from './resource/index.js';
+export * from './api/index.js';
+export * from './routes.js';
+export * from './types.js';
+export * from './monkey.js';
+
+import './typings.js';

package/src/local/storage.ts

@@ -0,0 +1,31 @@
+import { BeanBase, Local } from 'zova';
+import { ScopeModule } from '../resource/this.js';
+import { VueQueryPlugin, VueQueryPluginOptions, defaultShouldDehydrateQuery } from '@tanstack/vue-query';
+
+@Local()
+export class Storage extends BeanBase<ScopeModule> {
+  protected async __init__() {
+    const vueQueryPluginOptions: VueQueryPluginOptions = {
+      queryClientConfig: {
+        defaultOptions: {
+          queries: {
+            retry: false,
+            refetchOnWindowFocus: false,
+            refetchOnMount: false,
+            refetchOnReconnect: false,
+            // gcTime: 1000 * 60 * 5,
+          },
+          dehydrate: {
+            shouldDehydrateQuery(query) {
+              if (query.meta?.ssr?.dehydrate === false) return false;
+              return defaultShouldDehydrateQuery(query);
+            },
+          },
+        },
+      },
+    };
+    this.app.vue.use(VueQueryPlugin, vueQueryPluginOptions);
+  }
+
+  protected __dispose__() {}
+}

package/src/monkey.ts

@@ -0,0 +1,27 @@
+import { BeanBase, BeanContainer, BeanSimple, IMonkeySystem } from 'zova';
+import { Storage } from './local/storage.js';
+import { useQueryClient } from '@tanstack/vue-query';
+import { markRaw } from 'vue';
+
+export class Monkey extends BeanSimple implements IMonkeySystem {
+  storage: Storage;
+
+  async appInitialize(bean: BeanContainer) {
+    // storage
+    this.storage = await bean._newBean(Storage, false);
+  }
+  async appInitialized(_bean: BeanContainer) {}
+
+  async beanInit(bean: BeanContainer, beanInstance: BeanBase) {
+    bean.defineProperty(beanInstance, '$queryClient', {
+      enumerable: false,
+      configurable: true,
+      get() {
+        return markRaw(useQueryClient());
+      },
+    });
+  }
+  async beanInited(_bean: BeanContainer, _beanInstance: BeanBase) {}
+  beanDispose(_bean: BeanContainer, _beanInstance: BeanBase) {}
+  beanDisposed(_bean: BeanContainer, _beanInstance: BeanBase) {}
+}

package/src/resource/beans.ts

@@ -0,0 +1,5 @@
+export * from '../bean/virtual.model.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecord {}
+}

package/src/resource/components.ts

@@ -0,0 +1 @@
+export const components = {};

package/src/resource/index.ts

@@ -0,0 +1,3 @@
+export * from './scope.js';
+export * from './beans.js';
+export * from './components.js';

package/src/resource/scope.ts

@@ -0,0 +1,32 @@
+import { BeanScopeBase, Scope, TypeLocaleBase, TypeModuleResource } from 'zova';
+import { config, Errors, locales, constants } from '../config/index.js';
+import { components } from './components.js';
+import { services } from '../api/service/index.js';
+
+@Scope()
+export class ScopeModuleAModel extends BeanScopeBase {}
+
+export interface ScopeModuleAModel
+  extends TypeModuleResource<
+    typeof components,
+    typeof config,
+    typeof Errors,
+    (typeof locales)[TypeLocaleBase],
+    typeof constants,
+    typeof services
+  > {}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'a-model': ScopeModuleAModel;
+  }
+
+  export interface IBeanScopeConfig {
+    'a-model': ReturnType<typeof config>;
+  }
+
+  export interface IBeanScopeLocale {
+    'a-model': (typeof locales)[TypeLocaleBase];
+  }
+}

package/src/resource/this.ts

@@ -0,0 +1,4 @@
+export const __ThisModule__ = 'a-model';
+export type __ThisModuleType__ = typeof __ThisModule__;
+
+export { ScopeModuleAModel as ScopeModule } from './scope.js';

package/src/routes.ts

@@ -0,0 +1,3 @@
+import { IModuleRoute } from 'zova-module-a-router';
+
+export const routes: IModuleRoute[] = [];

package/src/types.ts

@@ -0,0 +1,54 @@
+import 'zova';
+import { DefaultError, useMutation, useQuery, useQueryClient } from '@tanstack/vue-query';
+import { UnwrapNestedRefs } from 'vue';
+declare module 'zova' {
+  export interface BeanBase {
+    $queryClient: ReturnType<typeof useQueryClient>;
+  }
+}
+
+declare module '@tanstack/vue-query' {
+  export interface Register {
+    queryMeta: MyQueryMeta;
+    mutationMeta: MyQueryMeta;
+  }
+}
+
+export interface MyQueryMeta extends Record<string, unknown> {
+  ssr?: QueryMetaSSR;
+  persister?: QueryMetaPersister | boolean;
+}
+
+export interface QueryMetaSSR {
+  /** default is true */
+  dehydrate?: boolean;
+}
+
+export type QueryMetaPersisterStorage = 'cookie' | 'local' | 'db' | undefined;
+
+export interface QueryMetaPersister {
+  /** default is false */
+  sync?: boolean;
+  /** default is db if async, local if sync */
+  storage?: QueryMetaPersisterStorage;
+  /** default is 24 hours */
+  maxAge?: number;
+  /**
+   * How to serialize the data to storage.
+   * @default `JSON.stringify`
+   */
+  serialize?: (persistedQuery: any) => any;
+  /**
+   * How to deserialize the data from storage.
+   * @default `JSON.parse`
+   */
+  deserialize?: (cachedString: any) => any;
+  prefix?: string;
+  buster?: string;
+}
+
+export type DataQuery<TData> = UnwrapNestedRefs<ReturnType<typeof useQuery<TData | undefined, Error | null>>>;
+
+export type DataMutation<TData = unknown, TVariables = void, TContext = unknown> = UnwrapNestedRefs<
+  ReturnType<typeof useMutation<TData, DefaultError, TVariables, TContext>>
+>;

package/src/typings.ts

@@ -0,0 +1 @@
+export {};