cabloy 5.1.149 → 5.1.151

package/zova/src/suite-vendor/a-zova/modules/a-form/test/lib/formLayout.test.ts

@@ -0,0 +1,157 @@
+import type { IFormLayout, ISchemaObjectExtensionField } from 'zova-module-a-openapi';
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { resolveFormLayout } from '../../src/lib/formLayout.js';
+
+function createProperties(...properties: ISchemaObjectExtensionField[]) {
+  return properties;
+}
+
+function createTabsLayout(name: string): IFormLayout {
+  return {
+    children: [
+      {
+        type: 'tabs',
+        children: [
+          {
+            type: 'tab',
+            title: 'Content',
+            children: [{ type: 'section', children: [{ type: 'field', name }] }],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function getTabFieldNames(resolved: ReturnType<typeof resolveFormLayout>) {
+  const tabs = resolved.children[0] as any;
+  return tabs.children[0].children[0].children.map((item: any) => item.name);
+}
+
+test('Form Layout resolves a real relation name to its unique canonical source', () => {
+  const resolved = resolveFormLayout(
+    createTabsLayout('content'),
+    createProperties({ key: 'content.descriptionMarkdown', type: 'string' }),
+  );
+
+  assert.deepEqual(getTabFieldNames(resolved), ['content.descriptionMarkdown']);
+  assert.deepEqual(resolved.fieldTabPaths, {
+    'content.descriptionMarkdown': [{ tabsId: 'tabs-0', tabId: 'tab-0-0' }],
+  });
+  assert.deepEqual(resolved.diagnostics, []);
+});
+
+test('Form Layout resolves a virtual schema alias to its canonical source', () => {
+  const resolved = resolveFormLayout(
+    createTabsLayout('_descriptionMarkdown'),
+    createProperties({
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      type: 'string',
+    }),
+  );
+
+  assert.deepEqual(getTabFieldNames(resolved), ['content.descriptionMarkdown']);
+  assert.deepEqual(resolved.fieldTabPaths, {
+    'content.descriptionMarkdown': [{ tabsId: 'tabs-0', tabId: 'tab-0-0' }],
+  });
+  assert.deepEqual(resolved.diagnostics, []);
+});
+
+test('Form Layout accepts every preserved alias for the same canonical source', () => {
+  const resolved = resolveFormLayout(
+    createTabsLayout('studentContentForm'),
+    createProperties({
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      schemaKeys: ['studentContentForm'],
+      type: 'string',
+    }),
+  );
+
+  assert.deepEqual(getTabFieldNames(resolved), ['content.descriptionMarkdown']);
+  assert.deepEqual(resolved.diagnostics, []);
+});
+
+test('Form Layout prefers an exact canonical field over a colliding alias', () => {
+  const resolved = resolveFormLayout(
+    { children: [{ type: 'field', name: 'content' }] },
+    createProperties(
+      { key: 'content', type: 'object' },
+      {
+        key: 'content.descriptionMarkdown',
+        schemaKey: 'content',
+        type: 'string',
+      },
+    ),
+  );
+
+  assert.deepEqual(resolved.children, [
+    { type: 'field', name: 'content' },
+    { type: 'field', name: 'content.descriptionMarkdown' },
+  ]);
+  assert.deepEqual(resolved.diagnostics, []);
+});
+
+test('Form Layout detects duplicate alias and canonical declarations by canonical key', () => {
+  const resolved = resolveFormLayout(
+    {
+      children: [
+        { type: 'field', name: '_descriptionMarkdown' },
+        { type: 'field', name: 'content.descriptionMarkdown' },
+      ],
+    },
+    createProperties({
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      type: 'string',
+    }),
+  );
+
+  assert.deepEqual(resolved.children, [{ type: 'field', name: 'content.descriptionMarkdown' }]);
+  assert.deepEqual(resolved.diagnostics, [
+    { type: 'duplicateField', value: 'content.descriptionMarkdown' },
+  ]);
+});
+
+test('Form Layout keeps ambiguous aliases and relation prefixes unknown', () => {
+  const resolved = resolveFormLayout(
+    {
+      children: [
+        { type: 'field', name: '_content' },
+        { type: 'field', name: 'content' },
+      ],
+    },
+    createProperties(
+      { key: 'content.descriptionMarkdown', schemaKey: '_content', type: 'string' },
+      { key: 'content.descriptionHtml', schemaKey: '_content', type: 'string' },
+    ),
+  );
+
+  assert.deepEqual(resolved.children, [
+    { type: 'field', name: 'content.descriptionMarkdown' },
+    { type: 'field', name: 'content.descriptionHtml' },
+  ]);
+  assert.deepEqual(resolved.diagnostics, [
+    { type: 'unknownField', value: '_content' },
+    { type: 'unknownField', value: 'content' },
+  ]);
+});
+
+test('Form Layout does not resolve or append invisible aliases', () => {
+  const resolved = resolveFormLayout(
+    { children: [{ type: 'field', name: '_descriptionMarkdown' }] },
+    createProperties({
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      type: 'string',
+      rest: { visible: false },
+    }),
+  );
+
+  assert.deepEqual(resolved.children, []);
+  assert.deepEqual(resolved.diagnostics, [{ type: 'unknownField', value: '_descriptionMarkdown' }]);
+});

package/zova/src/suite-vendor/a-zova/modules/a-model/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-model",
-  "version": "5.1.35",
+  "version": "5.1.36",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "core",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-model/src/bean/bean.model/bean.model.persister.ts

@@ -7,6 +7,7 @@ import { SymbolBeanFullName } from 'zova';
 import type { QueryMetaPersister } from '../../types/index.js';
 
 import { CookieWrapper } from '../../common/cookieWrapper.js';
+import { createQueryPersister } from '../../lib/queryPersister.js';
 import { resolveMaxAgeTime } from '../../types/index.js';
 import { BeanModelLast } from './bean.model.last.js';
 
@@ -145,13 +146,14 @@ export class BeanModelPersister extends BeanModelLast {
   protected _createPersister(options?: QueryMetaPersister | boolean): any {
     options = this._adjustPersisterOptions(options);
     if (!options) return undefined;
-    return experimental_createQueryPersister({
+    const persisterFn = experimental_createQueryPersister({
       storage: this._getPersisterStorage(options) as any,
       maxAge: options.maxAge as number,
       refetchOnRestore: options.refetchOnRestore,
       prefix: options.prefix,
       buster: options.buster,
     }).persisterFn;
+    return createQueryPersister(persisterFn);
   }
 
   protected _adjustPersisterOptions(options?: QueryMetaPersister | boolean) {

package/zova/src/suite-vendor/a-zova/modules/a-model/src/bean/bean.model/bean.model.useQuery.ts

@@ -1,12 +1,4 @@
-import type {
-  DefaultError,
-  QueryClient,
-  QueryKey,
-  UseQueryDefinedReturnType,
-  UseQueryOptions,
-  UseQueryReturnType,
-} from '@tanstack/vue-query';
-import type { UnwrapNestedRefs } from 'vue';
+import type { DefaultError, QueryClient, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
 
 import { checkErrorJwtExpired } from '@cabloy/utils';
 import { useQuery } from '@tanstack/vue-query';
@@ -16,7 +8,9 @@ import type {
   DefinedInitialQueryOptions,
   UndefinedInitialQueryOptions,
 } from '../../common/types.js';
+import type { ModelUseQueryDefinedReturnType, ModelUseQueryReturnType } from '../../types/query.js';
 
+import { createQueryRefetch } from '../../lib/queryRefetch.js';
 import { resolveStaleTime } from '../../types/index.js';
 import { BeanModelQuery } from './bean.model.query.js';
 
@@ -29,7 +23,7 @@ export class BeanModelUseQuery extends BeanModelQuery {
   >(
     options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useQuery<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -38,7 +32,7 @@ export class BeanModelUseQuery extends BeanModelQuery {
   >(
     options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
+  ): ModelUseQueryDefinedReturnType<TData, TError>;
   $useQuery<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -47,7 +41,7 @@ export class BeanModelUseQuery extends BeanModelQuery {
   >(
     options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useQuery(options, queryClient) {
     const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
     const persister = this._createPersister(options.meta?.persister);
@@ -81,7 +75,11 @@ export class BeanModelUseQuery extends BeanModelQuery {
       };
     }
     return this.ctx.util.instanceScope(() => {
-      return useQuery(options, queryClient);
+      const query = useQuery(options, queryClient) as unknown as ModelUseQueryReturnType<any, any>;
+      query.refetch = createQueryRefetch(query.refetch, () =>
+        this.$queryFind({ queryKey }),
+      ) as typeof query.refetch;
+      return query;
     });
   }
 }

package/zova/src/suite-vendor/a-zova/modules/a-model/src/bean/bean.model/bean.model.useState.ts

@@ -4,11 +4,8 @@ import type {
   QueryClient,
   QueryKey,
   QueryMeta,
-  UseQueryDefinedReturnType,
   UseQueryOptions,
-  UseQueryReturnType,
 } from '@tanstack/vue-query';
-import type { UnwrapNestedRefs } from 'vue';
 
 import { hashKey } from '@tanstack/vue-query';
 import { deepExtend } from 'zova';
@@ -17,7 +14,12 @@ import type {
   DefinedInitialQueryOptions,
   UndefinedInitialQueryOptions,
 } from '../../common/types.js';
-import type { QueryMetaPersister, UseQueryComputedOptions } from '../../types/query.js';
+import type {
+  ModelUseQueryDefinedReturnType,
+  ModelUseQueryReturnType,
+  QueryMetaPersister,
+  UseQueryComputedOptions,
+} from '../../types/query.js';
 
 import { BeanModelUseQuery } from './bean.model.useQuery.js';
 
@@ -311,7 +313,7 @@ export class BeanModelUseState extends BeanModelUseQuery {
   >(
     options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useStateData<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -320,7 +322,7 @@ export class BeanModelUseState extends BeanModelUseQuery {
   >(
     options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
+  ): ModelUseQueryDefinedReturnType<TData, TError>;
   $useStateData<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -329,7 +331,7 @@ export class BeanModelUseState extends BeanModelUseQuery {
   >(
     options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useStateData(options, queryClient) {
     const queryKey = this.self._forceQueryKeyPrefix(options.queryKey);
     const queryHash = hashKey(queryKey);

package/zova/src/suite-vendor/a-zova/modules/a-model/src/bean/bean.model/bean.model.useStateGeneral.ts

@@ -1,17 +1,10 @@
-import type {
-  DefaultError,
-  QueryClient,
-  QueryKey,
-  UseQueryDefinedReturnType,
-  UseQueryOptions,
-  UseQueryReturnType,
-} from '@tanstack/vue-query';
-import type { UnwrapNestedRefs } from 'vue';
+import type { DefaultError, QueryClient, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
 
 import type {
   DefinedInitialQueryOptions,
   UndefinedInitialQueryOptions,
 } from '../../common/types.js';
+import type { ModelUseQueryDefinedReturnType, ModelUseQueryReturnType } from '../../types/query.js';
 import type { StateType } from '../../types/query.js';
 
 import { BeanModelUseState } from './bean.model.useState.js';
@@ -56,7 +49,7 @@ export class BeanModelUseStateGeneral extends BeanModelUseState {
     stateType: 'data',
     options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useState<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -66,7 +59,7 @@ export class BeanModelUseStateGeneral extends BeanModelUseState {
     stateType: 'data',
     options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryDefinedReturnType<TData, TError>>;
+  ): ModelUseQueryDefinedReturnType<TData, TError>;
   $useState<
     TQueryFnData = unknown,
     TError = DefaultError,
@@ -76,7 +69,7 @@ export class BeanModelUseStateGeneral extends BeanModelUseState {
     stateType: 'data',
     options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
     queryClient?: QueryClient,
-  ): UnwrapNestedRefs<UseQueryReturnType<TData, TError>>;
+  ): ModelUseQueryReturnType<TData, TError>;
   $useState(stateType: StateType, options, queryClient) {
     switch (stateType) {
       case 'localAsync':

package/zova/src/suite-vendor/a-zova/modules/a-model/src/lib/queryPersister.ts

@@ -0,0 +1,17 @@
+import type { QueryPersister } from '@tanstack/query-core';
+
+// TanStack's FetchMeta is internal to the public QueryPersister call path.
+type QueryFetchMeta = {
+  bypassPersister?: boolean;
+};
+
+export function createQueryPersister<T, TQueryKey extends readonly unknown[]>(
+  persisterFn: QueryPersister<T, TQueryKey>,
+): QueryPersister<T, TQueryKey> {
+  return (queryFn, context, query) => {
+    if ((query.state.fetchMeta as QueryFetchMeta | null)?.bypassPersister === true) {
+      return queryFn(context);
+    }
+    return persisterFn(queryFn, context, query);
+  };
+}

package/zova/src/suite-vendor/a-zova/modules/a-model/src/lib/queryRefetch.ts

@@ -0,0 +1,34 @@
+import type { Query, RefetchOptions } from '@tanstack/query-core';
+
+import type { QueryRefetchOptions } from '../types/query.js';
+
+type QueryRefetch<TResult> = (options?: RefetchOptions) => Promise<TResult>;
+type QueryRefetchWithFetchOptions<TResult> = (
+  options?: RefetchOptions & { meta?: { bypassPersister?: boolean } },
+) => Promise<TResult>;
+
+export function createQueryRefetch<TResult>(
+  refetch: QueryRefetch<TResult>,
+  getQuery: () => Query | undefined,
+): (options?: QueryRefetchOptions) => Promise<TResult> {
+  return async (refetchOptions?: QueryRefetchOptions) => {
+    const { bypassPersister, ...options } = refetchOptions ?? {};
+    if (!bypassPersister) return refetch(options);
+
+    const query = getQuery();
+    // A cold query may already be fetching before its result is returned. Query.fetch
+    // deduplicates that request before applying the new fetch metadata, so wait for it
+    // before issuing the marked fetch.
+    if (query && query.state.fetchStatus !== 'idle' && query.state.data === undefined) {
+      await refetch({ cancelRefetch: false });
+    }
+
+    // TanStack's public RefetchOptions does not expose the internal fetch metadata
+    // forwarded by the installed QueryObserver implementation.
+    const refetchWithFetchOptions = refetch as QueryRefetchWithFetchOptions<TResult>;
+    return await refetchWithFetchOptions({
+      ...options,
+      meta: { bypassPersister: true },
+    });
+  };
+}

package/zova/src/suite-vendor/a-zova/modules/a-model/src/types/query.ts

@@ -3,8 +3,11 @@ import type {
   DehydratedState,
   Query,
   QueryKey,
+  QueryObserverResult,
+  RefetchOptions,
+  UseQueryDefinedReturnType as TanStackUseQueryDefinedReturnType,
+  UseQueryReturnType as TanStackUseQueryReturnType,
   useMutation,
-  useQuery,
   useQueryClient,
 } from '@tanstack/vue-query';
 import type { DebuggerOptions, UnwrapNestedRefs } from 'vue';
@@ -32,6 +35,26 @@ declare module '@tanstack/vue-query' {
 
 export type { UseQueryOptions } from '@tanstack/vue-query';
 
+export type QueryRefetchOptions = RefetchOptions & {
+  bypassPersister?: boolean;
+};
+
+type QueryRefetch<TResult> = (options?: QueryRefetchOptions) => Promise<TResult>;
+
+export type ModelUseQueryReturnType<TData, TError> = Omit<
+  UnwrapNestedRefs<TanStackUseQueryReturnType<TData, TError>>,
+  'refetch'
+> & {
+  refetch: QueryRefetch<QueryObserverResult<TData, TError>>;
+};
+
+export type ModelUseQueryDefinedReturnType<TData, TError> = Omit<
+  UnwrapNestedRefs<TanStackUseQueryDefinedReturnType<TData, TError>>,
+  'refetch'
+> & {
+  refetch: QueryRefetch<QueryObserverResult<TData, TError>>;
+};
+
 export interface MyQueryMetaBase extends Record<string, unknown> {
   defaultData?: (() => any) | any;
   ssr?: QueryMetaSSR;
@@ -108,8 +131,9 @@ export interface QueryMetaPersister {
   refetchOnRestore?: boolean | 'always';
 }
 
-export type DataQuery<TData, TError = Error | null> = UnwrapNestedRefs<
-  ReturnType<typeof useQuery<TData | undefined, TError>>
+export type DataQuery<TData, TError = Error | null> = ModelUseQueryReturnType<
+  TData | undefined,
+  TError
 >;
 
 export type DataMutation<TData = unknown, TVariables = void, TContext = unknown> = UnwrapNestedRefs<

package/zova/src/suite-vendor/a-zova/modules/a-model/test/lib/queryPersister.test.ts

@@ -0,0 +1,115 @@
+import { QueryClient, QueryObserver } from '@tanstack/query-core';
+import { experimental_createQueryPersister } from '@tanstack/query-persist-client-core';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createQueryPersister } from '../../src/lib/queryPersister.js';
+
+type Value = { value: string };
+
+function createStorage(initialValue?: Value) {
+  const stored = initialValue
+    ? JSON.stringify({
+        state: { data: initialValue, dataUpdatedAt: Date.now(), errorUpdatedAt: 0 },
+        queryKey: ['summary'],
+        queryHash: '["summary"]',
+        buster: '',
+      })
+    : undefined;
+  let value = stored;
+  let reads = 0;
+  let writes = 0;
+
+  return {
+    storage: {
+      getItem() {
+        reads++;
+        return value;
+      },
+      setItem(_key: string, nextValue: string) {
+        writes++;
+        value = nextValue;
+      },
+      removeItem() {
+        value = undefined;
+      },
+    },
+    get reads() {
+      return reads;
+    },
+    get writes() {
+      return writes;
+    },
+  };
+}
+
+function createObserver(storage: ReturnType<typeof createStorage>, queryFn: () => Promise<Value>) {
+  const client = new QueryClient();
+  const persisterFn = experimental_createQueryPersister({ storage: storage.storage }).persisterFn;
+  const observer = new QueryObserver(client, {
+    queryKey: ['summary'],
+    queryFn,
+    enabled: false,
+    persister: createQueryPersister(persisterFn),
+  });
+
+  return { client, observer };
+}
+
+test('bypassPersister fetches fresh data without restoring or saving persisted data', async () => {
+  const storage = createStorage({ value: 'old' });
+  let calls = 0;
+  const { client, observer } = createObserver(storage, async () => ({ value: `fresh-${++calls}` }));
+
+  try {
+    const result = await observer
+      .getCurrentQuery()
+      .fetch(undefined, { meta: { bypassPersister: true } as any });
+
+    assert.deepEqual(result, { value: 'fresh-1' });
+    assert.deepEqual(observer.getCurrentQuery().state.data, { value: 'fresh-1' });
+    assert.equal(calls, 1);
+    assert.equal(storage.reads, 0);
+    assert.equal(storage.writes, 0);
+  } finally {
+    client.clear();
+  }
+});
+
+test('ordinary refetch still restores persisted data after a bypassed fetch', async () => {
+  const storage = createStorage({ value: 'old' });
+  let calls = 0;
+  const { client, observer } = createObserver(storage, async () => ({ value: `fresh-${++calls}` }));
+
+  try {
+    const bypassed = await observer
+      .getCurrentQuery()
+      .fetch(undefined, { meta: { bypassPersister: true } as any });
+    assert.deepEqual(bypassed, { value: 'fresh-1' });
+
+    client.removeQueries({ queryKey: ['summary'] });
+    const restored = await observer.refetch();
+
+    assert.deepEqual(restored.data, { value: 'old' });
+    assert.equal(calls, 1);
+    assert.equal(storage.reads, 1);
+  } finally {
+    client.clear();
+  }
+});
+
+test('ordinary refetch restores persisted data without invoking the query function', async () => {
+  const storage = createStorage({ value: 'old' });
+  let calls = 0;
+  const { client, observer } = createObserver(storage, async () => ({ value: `fresh-${++calls}` }));
+
+  try {
+    const result = await observer.refetch();
+
+    assert.deepEqual(result.data, { value: 'old' });
+    assert.equal(calls, 0);
+    assert.equal(storage.reads, 1);
+  } finally {
+    client.clear();
+  }
+});

package/zova/src/suite-vendor/a-zova/modules/a-model/test/lib/queryRefetch.test.ts

@@ -0,0 +1,84 @@
+import type { Query, RefetchOptions } from '@tanstack/query-core';
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createQueryRefetch } from '../../src/lib/queryRefetch.js';
+
+type Result = { data: string };
+
+function createQuery(state: Query['state']) {
+  return { state } as Query;
+}
+
+test('bypassPersister waits for a cold initial fetch before starting its own marked fetch', async () => {
+  let resolveInitial: (() => void) | undefined;
+  const initial = new Promise<void>(resolve => {
+    resolveInitial = resolve;
+  });
+  const calls: Array<RefetchOptions | undefined> = [];
+  const query = createQuery({
+    fetchStatus: 'fetching',
+    data: undefined,
+    fetchMeta: null,
+  } as Query['state']);
+  const refetch = async (options?: RefetchOptions): Promise<Result> => {
+    calls.push(options);
+    if (calls.length === 1) {
+      await initial;
+      query.state.fetchStatus = 'idle';
+      return { data: 'initial' };
+    }
+    return { data: 'fresh' };
+  };
+  const wrapped = createQueryRefetch(refetch, () => query);
+
+  const result = wrapped({ bypassPersister: true, cancelRefetch: false, throwOnError: true });
+  assert.deepEqual(calls, [{ cancelRefetch: false }]);
+
+  resolveInitial!();
+  assert.deepEqual(await result, { data: 'fresh' });
+  assert.deepEqual(calls, [
+    { cancelRefetch: false },
+    { cancelRefetch: false, throwOnError: true, meta: { bypassPersister: true } },
+  ]);
+});
+
+test('ordinary refetch forwards native options unchanged', async () => {
+  const calls: Array<RefetchOptions | undefined> = [];
+  const refetch = async (options?: RefetchOptions): Promise<Result> => {
+    calls.push(options);
+    return { data: 'result' };
+  };
+  const wrapped = createQueryRefetch(refetch, () => undefined);
+  const options = { cancelRefetch: false, throwOnError: true };
+
+  assert.deepEqual(await wrapped(options), { data: 'result' });
+  assert.deepEqual(calls, [options]);
+});
+
+test('false bypassPersister retains native refetch behavior', async () => {
+  const calls: Array<RefetchOptions | undefined> = [];
+  const refetch = async (options?: RefetchOptions): Promise<Result> => {
+    calls.push(options);
+    return { data: 'result' };
+  };
+  const wrapped = createQueryRefetch(refetch, () => undefined);
+
+  assert.deepEqual(await wrapped({ bypassPersister: false }), { data: 'result' });
+  assert.deepEqual(calls, [{}]);
+});
+
+test('bypassPersister leaves the caller options object unchanged', async () => {
+  const calls: Array<RefetchOptions | undefined> = [];
+  const refetch = async (options?: RefetchOptions): Promise<Result> => {
+    calls.push(options);
+    return { data: 'result' };
+  };
+  const wrapped = createQueryRefetch(refetch, () => undefined);
+  const options = { bypassPersister: true, cancelRefetch: false };
+
+  await wrapped(options);
+  assert.deepEqual(options, { bypassPersister: true, cancelRefetch: false });
+  assert.deepEqual(calls, [{ cancelRefetch: false, meta: { bypassPersister: true } }]);
+});

package/zova/src/suite-vendor/a-zova/modules/a-openapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-openapi",
-  "version": "5.1.50",
+  "version": "5.1.51",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [