cabloy 5.1.148 → 5.1.150

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": [

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/lib/schema.ts

@@ -21,7 +21,7 @@ export function loadSchemaProperties(
   schema: SchemaObject | undefined,
   onGetSchema: (schemaName: string) => SchemaObject | undefined,
   schemaScene?: TypeSchemaScene,
-): SchemaObject[] | undefined {
+): ISchemaObjectExtensionField[] | undefined {
   if (!schema) return;
   const properties = schema.properties!;
   const result: ISchemaObjectExtensionField[] = [];
@@ -32,12 +32,26 @@ export function loadSchemaProperties(
       property = onGetSchema(property.$ref)!;
     }
     if (!property) continue;
-    const fieldSource = property.rest?.fieldSource;
+    const schemaKey = key;
+    const propertyRest = deepExtend(
+      {},
+      property.rest,
+      schemaScene && ['form-view', 'form-create', 'filter'].includes(schemaScene)
+        ? property.rest?.form
+        : undefined,
+      schemaScene ? property.rest?.[schemaScene] : undefined,
+    );
+    const fieldSource = propertyRest?.fieldSource;
     if (fieldSource) {
       const parts = fieldSource.split('.');
-      const propertyParent: any =
-        parts[0] === key ? property : result.find(item => item.key === parts[0]);
-      property = propertyParent?.properties[parts[1]];
+      let propertyParent =
+        parts[0] === schemaKey
+          ? property
+          : (properties[parts[0]] as ISchemaObjectExtensionField | undefined);
+      if (propertyParent?.$ref) {
+        propertyParent = onGetSchema(propertyParent.$ref)!;
+      }
+      property = propertyParent?.properties?.[parts[1]] as ISchemaObjectExtensionField;
       key = fieldSource;
     }
     if (!property) continue;
@@ -49,6 +63,14 @@ export function loadSchemaProperties(
         : undefined,
       schemaScene ? { rest: property.rest?.[schemaScene] ?? {} } : undefined,
     );
+    if (schemaKey !== key) {
+      property.schemaKey = schemaKey;
+    }
+    const propertyExisting = result.find(item => item.key === key);
+    if (propertyExisting) {
+      propertyExisting.schemaKeys = [...(propertyExisting.schemaKeys ?? []), schemaKey];
+      continue;
+    }
     result.push(property);
   }
   // sort

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/model/sdk.ts

@@ -20,7 +20,7 @@ import {
   schemaToZodSchema,
 } from '../lib/schema.js';
 import { TypeOpenapiPermissions } from '../types/permissions.js';
-import { TypeSchemaScene } from '../types/rest.js';
+import { ISchemaObjectExtensionField, TypeSchemaScene } from '../types/rest.js';
 import { IOpenapiSchemas, TypeOpenapiSchemasSdk } from '../types/schema.js';
 import { TypeRequestMethod } from '../types/sdk.js';
 
@@ -236,7 +236,7 @@ export class ModelSdk extends BeanModelBase {
   public loadSchemaProperties(
     schema: SchemaObject | undefined,
     schemaScene?: TypeSchemaScene,
-  ): SchemaObject[] | undefined {
+  ): ISchemaObjectExtensionField[] | undefined {
     return loadSchemaProperties(schema, schemaName => this.getSchema(schemaName).data, schemaScene);
   }
 

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/types/rest.ts

@@ -47,6 +47,10 @@ export interface ISchemaObjectExtensionFieldFilter {
 
 export interface ISchemaObjectExtensionField extends SchemaObject {
   key?: string;
+  /** Original property name before fieldSource normalization. */
+  schemaKey?: string;
+  /** Additional schema aliases that resolve to this canonical key. */
+  schemaKeys?: string[];
   rest?: ISchemaObjectExtensionFieldRest;
   filter?: ISchemaObjectExtensionFieldFilter;
 }

package/zova/src/suite-vendor/a-zova/modules/a-openapi/src/types/schema.ts

@@ -1,6 +1,5 @@
-import type { DefaultError, UseQueryReturnType } from '@tanstack/vue-query';
 import type { OpenAPIObject, SchemaObject } from 'openapi3-ts/oas31';
-import type { UnwrapNestedRefs } from 'vue';
+import type { ModelUseQueryReturnType } from 'zova-module-a-model';
 
 import type { IOpenapiSdkItem } from './sdk.js';
 
@@ -11,9 +10,7 @@ export interface IOpenapiSchema {
 
 export interface IOpenapiSchemaMeta {}
 
-export type TypeOpenapiSchemasSdk = UnwrapNestedRefs<
-  UseQueryReturnType<IOpenapiSdkItem, DefaultError>
->;
+export type TypeOpenapiSchemasSdk = ModelUseQueryReturnType<IOpenapiSdkItem, Error>;
 
 export interface IOpenapiSchemas {
   sdk: TypeOpenapiSchemasSdk;

package/zova/src/suite-vendor/a-zova/modules/a-openapi/test/lib/schema.test.ts

@@ -0,0 +1,179 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import type { ISchemaObjectExtensionField } from '../../src/types/rest.js';
+
+import { loadSchemaProperties } from '../../src/lib/schema.js';
+
+const onGetSchema = () => undefined;
+
+function field(field: ISchemaObjectExtensionField) {
+  return field;
+}
+
+test('schema properties preserve the canonical fieldSource key and original schema key', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({
+              type: 'string',
+              rest: { render: 'start-markdown:formFieldMarkdown' as any },
+            }),
+          },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: 'content',
+      type: 'string',
+      rest: { render: 'start-markdown:formFieldMarkdown' },
+    },
+  ]);
+});
+
+test('schema properties preserve virtual aliases without changing the form key', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { visible: false },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties?.[1], {
+    key: 'content.descriptionMarkdown',
+    schemaKey: '_descriptionMarkdown',
+    type: 'string',
+  });
+});
+
+test('schema properties normalize a scene-specific fieldSource', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { visible: false },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { form: { fieldSource: 'content.descriptionMarkdown' } },
+        }),
+      },
+    },
+    onGetSchema,
+    'form',
+  );
+
+  assert.deepEqual(properties?.[1], {
+    key: 'content.descriptionMarkdown',
+    schemaKey: '_descriptionMarkdown',
+    type: 'string',
+  });
+});
+
+test('schema properties coalesce aliases when the source property has fieldSource', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+        studentContentForm: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: 'content',
+      schemaKeys: ['_descriptionMarkdown', 'studentContentForm'],
+      type: 'string',
+    },
+  ]);
+});
+
+test('schema properties coalesce aliases declared before their fieldSource parent', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        _descriptionMarkdown: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+        }),
+        content: field({
+          type: 'object',
+          rest: { fieldSource: 'content.descriptionMarkdown' },
+          properties: {
+            descriptionMarkdown: field({ type: 'string' }),
+          },
+        }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [
+    {
+      key: 'content.descriptionMarkdown',
+      schemaKey: '_descriptionMarkdown',
+      schemaKeys: ['content'],
+      type: 'string',
+    },
+  ]);
+});
+
+test('ordinary schema properties do not gain a schema alias', () => {
+  const properties = loadSchemaProperties(
+    {
+      type: 'object',
+      properties: {
+        name: field({ type: 'string' }),
+      },
+    },
+    onGetSchema,
+  );
+
+  assert.deepEqual(properties, [{ key: 'name', type: 'string' }]);
+});

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

@@ -1,6 +1,6 @@
 {
   "name": "zova-suite-a-zova",
-  "version": "5.1.152",
+  "version": "5.1.154",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "zova",
   "license": "MIT",
@@ -16,13 +16,13 @@
     "zova-module-a-boundary": "^5.1.22",
     "zova-module-a-command": "^5.1.34",
     "zova-module-a-fetch": "^5.1.25",
-    "zova-module-a-form": "^5.1.48",
+    "zova-module-a-form": "^5.1.50",
     "zova-module-a-icon": "^5.1.27",
     "zova-module-a-interceptor": "^5.1.31",
     "zova-module-a-logger": "^5.1.28",
     "zova-module-a-meta": "^5.1.22",
-    "zova-module-a-model": "^5.1.35",
-    "zova-module-a-openapi": "^5.1.50",
+    "zova-module-a-model": "^5.1.36",
+    "zova-module-a-openapi": "^5.1.51",
     "zova-module-a-router": "^5.1.34",
     "zova-module-a-routerstack": "^5.1.27",
     "zova-module-a-routertabs": "^5.1.34",