cabloy 5.1.207 → 5.1.209

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

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { getPersistenceQueue, PersistenceQueue } from '../../src/lib/persistenceQueue.js';
+
+function deferred() {
+  let resolve!: () => void;
+  const promise = new Promise<void>(done => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+test('async saves finish before removal and flush waits for durable completion', async () => {
+  const queue = new PersistenceQueue();
+  const write = deferred();
+  const calls: string[] = [];
+  let stored: string | undefined;
+  const save = queue.enqueue(async () => {
+    calls.push('save');
+    await write.promise;
+    stored = 'draft';
+  });
+  const remove = queue.enqueue(() => {
+    calls.push('remove');
+    stored = undefined;
+  });
+  let flushed = false;
+  const flush = queue.flush().then(() => {
+    flushed = true;
+  });
+  await Promise.resolve();
+  assert.deepEqual(calls, ['save']);
+  assert.equal(flushed, false);
+  write.resolve();
+  await Promise.all([save, remove, flush]);
+  assert.deepEqual(calls, ['save', 'remove']);
+  assert.equal(stored, undefined);
+  assert.equal(flushed, true);
+});
+
+test('an unawaited storage failure is observed by flush without poisoning later operations', async () => {
+  const queue = new PersistenceQueue();
+  const error = new Error('storage unavailable');
+  queue.enqueue(() => {
+    throw error;
+  });
+  let saved = false;
+  await queue.enqueue(() => {
+    saved = true;
+  });
+  assert.equal(saved, true);
+  await assert.rejects(queue.flush(), failure => failure === error);
+  await queue.flush();
+  await queue.enqueue(() => {
+    saved = false;
+  });
+  await queue.flush();
+  assert.equal(saved, false);
+});
+
+test('save serialization failures are awaited and the queue recovers', async () => {
+  const queue = new PersistenceQueue();
+  const error = new Error('serialization failed');
+  await assert.rejects(
+    queue.enqueue(() => {
+      throw error;
+    }),
+    failure => failure === error,
+  );
+  await assert.rejects(queue.flush(), failure => failure === error);
+  await queue.enqueue(() => undefined);
+  await queue.flush();
+});
+
+test('a clear barrier drains earlier writes and invalidates delayed writers and restores', async () => {
+  const queue = new PersistenceQueue();
+  const write = deferred();
+  let stored: string | undefined;
+  const generation = queue.generation('draft');
+  const save = queue.enqueue(async () => {
+    await write.promise;
+    stored = 'accepted draft';
+  });
+  queue.invalidateAll();
+  const clear = queue.enqueue(() => {
+    stored = undefined;
+  });
+  const lateSave = queue.enqueue(() => {
+    if (generation === queue.generation('draft')) stored = 'late draft';
+  });
+  assert.notEqual(generation, queue.generation('draft'));
+  write.resolve();
+  await Promise.all([save, clear, lateSave]);
+  await queue.flush();
+  assert.equal(stored, undefined);
+});
+
+test('per-key invalidation discards a late restore without affecting other keys', async () => {
+  const queue = new PersistenceQueue();
+  const read = deferred();
+  const firstGeneration = queue.generation('first');
+  const secondGeneration = queue.generation('second');
+  const restore = queue.enqueue(async () => {
+    await read.promise;
+    return firstGeneration === queue.generation('first') ? 'old data' : undefined;
+  });
+  await Promise.resolve();
+  queue.invalidate('first');
+  read.resolve();
+  assert.equal(await restore, undefined);
+  assert.equal(secondGeneration, queue.generation('second'));
+});
+
+test('all models using one storage share ordering while separate stores remain independent', async () => {
+  const storage = {};
+  const otherStorage = {};
+  const first = getPersistenceQueue(storage);
+  assert.equal(first, getPersistenceQueue(storage));
+  assert.notEqual(first, getPersistenceQueue(otherStorage));
+  const pending = deferred();
+  const calls: string[] = [];
+  const save = first.enqueue(async () => {
+    await pending.promise;
+    calls.push('save');
+  });
+  const clear = getPersistenceQueue(storage).enqueue(() => {
+    calls.push('clear');
+  });
+  await getPersistenceQueue(otherStorage).enqueue(() => {
+    calls.push('other');
+  });
+  assert.deepEqual(calls, ['other']);
+  pending.resolve();
+  await Promise.all([save, clear]);
+  assert.deepEqual(calls, ['other', 'save', 'clear']);
+});

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

@@ -0,0 +1,129 @@
+import { QueryClient, QueryObserver } from '@tanstack/query-core';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { stripTypeScriptTypes } from 'node:module';
+import test from 'node:test';
+
+import { ModelPersistenceContext } from '../../src/lib/modelPersistence.js';
+
+const tick = () => new Promise<void>(resolve => setTimeout(resolve, 0));
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>(done => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+test('outgoing transition cancels and resets immediately without active refetch; later login still refetches', async () => {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, gcTime: Infinity } },
+  });
+  const persistence = new ModelPersistenceContext(client, 'admin');
+  persistence.update({ instanceId: 2, siteId: 'admin', userId: 1 }, { initial: true });
+  await tick();
+  const outgoing = deferred<string>();
+  let accessToken: string | undefined = 'token-1';
+  const requests: Array<string | undefined> = [];
+  let aborted = false;
+  const observer = new QueryObserver(client, {
+    queryKey: ['protected'],
+    initialData: 'private',
+    queryFn: ({ signal }) => {
+      requests.push(accessToken);
+      if (requests.length === 1) {
+        signal.addEventListener('abort', () => {
+          aborted = true;
+        });
+        return outgoing.promise;
+      }
+      return Promise.resolve(`data:${accessToken}`);
+    },
+  });
+  const local = client.getQueryCache().build(client, {
+    queryKey: ['local'],
+    initialData: 'local-value',
+    meta: { persister: { storage: 'local' } },
+  });
+  const unsubscribe = observer.subscribe(() => undefined);
+  const query = observer.getCurrentQuery();
+  const previous = persistence.capture();
+  let notifications = 0;
+  const stop = persistence.subscribe(token => {
+    notifications++;
+    assert.equal(persistence.current(token), true);
+    assert.equal(persistence.current(previous), false);
+    assert.equal(aborted, true);
+    assert.equal(query.state.data, undefined);
+    assert.equal(query.state.error, null);
+    assert.equal(query.state.dataUpdatedAt, 0);
+    assert.equal(query.state.fetchStatus, 'idle');
+    assert.equal(query.state.status, 'pending');
+  });
+  try {
+    assert.deepEqual(requests, ['token-1']);
+    accessToken = undefined;
+    persistence.update(
+      { instanceId: null, siteId: 'admin', userId: null },
+      { refetchActive: false },
+    );
+    assert.equal(notifications, 1);
+    assert.equal(persistence.epoch, previous.epoch + 1);
+    assert.deepEqual(persistence.capture().scope, [null, 'admin', null]);
+    assert.equal(observer.getCurrentQuery(), query);
+    assert.equal(query.getObserversCount(), 1);
+    assert.equal(local.state.data, 'local-value');
+    await tick();
+    assert.deepEqual(requests, ['token-1']);
+    outgoing.resolve('obsolete-private');
+    await tick();
+    assert.equal(query.state.data, undefined);
+    assert.equal(query.state.error, null);
+    stop();
+
+    // Ordinary login must use its already-installed token and must not inherit
+    // the preceding outgoing transition's no-refetch policy.
+    accessToken = 'token-3';
+    persistence.update({ instanceId: 4, siteId: 'admin', userId: 3 });
+    assert.equal(query.state.data, undefined);
+    await tick();
+    assert.deepEqual(requests, ['token-1', 'token-3']);
+    assert.equal(query.state.data, 'data:token-3');
+
+    accessToken = 'token-5';
+    persistence.update({ instanceId: 4, siteId: 'admin', userId: 5 }, { refetchActive: true });
+    await tick();
+    assert.deepEqual(requests, ['token-1', 'token-3', 'token-5']);
+    assert.equal(query.state.data, 'data:token-5');
+  } finally {
+    stop();
+    unsubscribe();
+    outgoing.resolve('obsolete-private');
+    client.clear();
+  }
+});
+
+test('ServiceStorage forwards outgoing refetch policy unchanged', () => {
+  const source = readFileSync(new URL('../../src/service/storage.ts', import.meta.url), 'utf8')
+    .replace(/^import[\s\S]*?;\n/gm, '')
+    .replace(/^@Service[^\n]*\n/gm, '');
+  const javascript = stripTypeScriptTypes(source).replace(
+    'export class ServiceStorage',
+    'class ServiceStorage',
+  );
+  const ServiceStorage = new Function('BeanBase', `${javascript}\nreturn ServiceStorage;`)(
+    class BeanBase {},
+  );
+  const storage = new ServiceStorage();
+  const calls: any[] = [];
+  storage._persistence = { update: (...args: any[]) => calls.push(args) };
+  const identity = { instanceId: null, siteId: 'admin', userId: null };
+  const options = { refetchActive: false };
+  storage.update(identity, options);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0][0], identity);
+  assert.equal(calls[0][1], options);
+  storage.update({ instanceId: 4, siteId: 'admin', userId: 3 });
+  assert.equal(calls[1][1], undefined);
+});

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

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

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

@@ -8,6 +8,7 @@ import type { ModelSdk } from './model/sdk.js';
 
 export class Monkey extends BeanSimple implements IMonkeyBeanInit, IMonkeyAppInitialize {
   private _modelSdk: Ref<ModelSdk | undefined> = ref();
+  private _sdkGeneration = 0;
 
   async beanInit(bean: BeanContainer, beanInstance: BeanBase) {
     const self = this;
@@ -36,10 +37,11 @@ export class Monkey extends BeanSimple implements IMonkeyBeanInit, IMonkeyAppIni
   }
 
   private async _loadSdk() {
-    this._modelSdk.value = await this.app.bean._getBeanSelector(
-      'a-openapi.model.sdk',
-      true,
-      this.app.meta.locale.current,
-    );
+    const generation = ++this._sdkGeneration;
+    const locale = this.app.meta.locale.current;
+    const sdk = await this.app.bean._getBeanSelector('a-openapi.model.sdk', true, locale);
+    if (generation === this._sdkGeneration && locale === this.app.meta.locale.current) {
+      this._modelSdk.value = sdk;
+    }
   }
 }

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

@@ -35,6 +35,7 @@ export interface ISchemaObjectExtensionFieldRest extends ITableColumnOptions {
   'visible'?: boolean;
   'disableNotifyChanged'?: boolean;
   'readonly'?: boolean;
+  'draft'?: boolean;
   'onEffect'?: TypeFormFieldOnEffect;
   //
   'render'?: TypeFormFieldRenderComponentNormal | TypeTableCellRenderComponentNormal;
@@ -70,6 +71,7 @@ export type TypeSchemaScene = 'table' | TypeFormSchemaScene;
 export type TypeFormSchemaScene = 'form' | 'form-view' | 'form-create' | 'filter';
 
 export const renderFormFieldTopPropsSystem = [
+  'draft',
   'order',
   'table',
   'form',

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

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-router",
-  "version": "5.1.41",
+  "version": "5.1.42",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "router",
   "keywords": [

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

@@ -9,10 +9,12 @@ import type {
 import { BeanBase, Use } from 'zova';
 import { Bean } from 'zova-module-a-bean';
 
+import { dispatchRouteDiscard } from '../lib/routeDiscard.js';
 import { RouterGuardDisposers } from '../lib/routerGuardDisposers.js';
 import { BeanRouterViewBase } from '../lib/routerViewBase.js';
 import { ModelPageData } from '../model/pageData.js';
 import { IPageMeta } from '../types/pageMeta.js';
+import { IRouteDiscardItem, TypeRouteDiscardReason } from '../types/routeDiscard.js';
 import { TypeErrorListener } from '../types/router.js';
 import { SysRouter } from './sys.router.js';
 
@@ -124,6 +126,18 @@ export class BeanRouter extends BeanBase {
     }
   }
 
+  notifyRouteDiscard(
+    reason: TypeRouteDiscardReason,
+    items: readonly IRouteDiscardItem[],
+    ownerSelector?: string,
+  ): Promise<void> {
+    return dispatchRouteDiscard(
+      { router: this, reason, items, ownerSelector },
+      event => this.app.meta.event.emitSync('a-router:routeDiscard', event),
+      () => console.error('Route discard cleanup failed'),
+    );
+  }
+
   afterEachBackRoute(route: RouteLocationNormalizedLoadedGeneric) {
     for (const routerView of this._routerViews) {
       const res = routerView.backRoute(route);

package/zova/src/suite-vendor/a-zova/modules/a-router/src/lib/routeDiscard.ts

@@ -0,0 +1,26 @@
+import type { IRouteDiscardEvent } from '../types/routeDiscard.js';
+
+export function dispatchRouteDiscard(
+  event: Omit<IRouteDiscardEvent, 'waitUntil'>,
+  emit: (event: IRouteDiscardEvent) => void,
+  onError: (error: unknown) => void,
+): Promise<void> {
+  const cleanups: Promise<void>[] = [];
+  const items = event.items.map(item => ({ ...item }));
+  try {
+    emit({
+      ...event,
+      items,
+      waitUntil: cleanup => {
+        cleanups.push(cleanup);
+      },
+    });
+  } catch (error) {
+    onError(error);
+  }
+  return Promise.allSettled(cleanups).then(results => {
+    for (const result of results) {
+      if (result.status === 'rejected') onError(result.reason);
+    }
+  });
+}

package/zova/src/suite-vendor/a-zova/modules/a-router/src/service/routerGuards.ts

@@ -86,10 +86,13 @@ export class ServiceRouterGuards extends BeanRouterGuardsBase {
     info: NavigationInformation | undefined,
   ) {
     if (!info) return;
-    const needBack =
-      (info.type === NavigationType.pop && info.direction === NavigationDirection.back) ||
-      (info.type === NavigationType.push && info.replace);
+    const isBack = info.type === NavigationType.pop && info.direction === NavigationDirection.back;
+    const needBack = isBack || (info.type === NavigationType.push && info.replace);
     if (!needBack) return;
+    if (isBack) {
+      // afterEach is synchronous; listeners register and invalidate outgoing work immediately.
+      void router.notifyRouteDiscard('back', [{ fullPath: from.fullPath }]);
+    }
     router.afterEachBackRoute(from);
   }
 

package/zova/src/suite-vendor/a-zova/modules/a-router/src/types/index.ts

@@ -1,5 +1,6 @@
 export * from './pageHost.js';
 export * from './pageMeta.js';
+export * from './routeDiscard.js';
 export * from './router.js';
 export * from './routerView.js';
 export * from './utils.js';

package/zova/src/suite-vendor/a-zova/modules/a-router/src/types/routeDiscard.ts

@@ -0,0 +1,24 @@
+import type { BeanRouter } from '../bean/bean.router.js';
+
+export type TypeRouteDiscardReason = 'back' | 'taskClose' | 'workspaceClose';
+
+export interface IRouteDiscardItem {
+  readonly fullPath: string;
+  readonly componentKey?: string;
+  readonly tabKey?: string;
+}
+
+export interface IRouteDiscardEvent {
+  readonly router: BeanRouter;
+  readonly reason: TypeRouteDiscardReason;
+  readonly items: readonly IRouteDiscardItem[];
+  readonly ownerSelector?: string;
+  // Register cleanup synchronously so outgoing writers can be invalidated before navigation.
+  readonly waitUntil: (cleanup: Promise<void>) => void;
+}
+
+declare module 'zova' {
+  export interface IEventRecord {
+    'a-router:routeDiscard': { data: IRouteDiscardEvent; result: void };
+  }
+}

package/zova/src/suite-vendor/a-zova/modules/a-router/test/lib/routeDiscard.test.ts

@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import type { BeanRouter } from '../../src/bean/bean.router.js';
+import type { IRouteDiscardEvent } from '../../src/types/routeDiscard.js';
+
+import { dispatchRouteDiscard } from '../../src/lib/routeDiscard.js';
+
+const router = {} as BeanRouter;
+
+test('route discard invalidates synchronously and awaits registered cleanup', async () => {
+  const calls: string[] = [];
+  let finish!: () => void;
+  const cleanup = new Promise<void>(resolve => {
+    finish = resolve;
+  });
+  const completion = dispatchRouteDiscard(
+    { router, reason: 'back', items: [{ fullPath: '/entry/create' }] },
+    event => {
+      calls.push('invalidate');
+      event.waitUntil(
+        cleanup.then(() => {
+          calls.push('cleanup');
+        }),
+      );
+    },
+    () => assert.fail('unexpected cleanup error'),
+  ).then(() => {
+    calls.push('complete');
+  });
+
+  assert.deepEqual(calls, ['invalidate']);
+  await Promise.resolve();
+  assert.deepEqual(calls, ['invalidate']);
+  finish();
+  await completion;
+  assert.deepEqual(calls, ['invalidate', 'cleanup', 'complete']);
+});
+
+test('route discard captures detached inactive workspace identities', async () => {
+  const items = [
+    { fullPath: '/entry/1/edit', componentKey: 'edit-1', tabKey: 'workspace' },
+    { fullPath: '/entry/2/edit', componentKey: 'edit-2', tabKey: 'workspace' },
+  ];
+  let captured!: IRouteDiscardEvent;
+  await dispatchRouteDiscard(
+    { router, reason: 'workspaceClose', items, ownerSelector: 'admin' },
+    event => {
+      captured = event;
+    },
+    () => assert.fail('unexpected cleanup error'),
+  );
+  items[0].fullPath = '/newly-active';
+  items.pop();
+
+  assert.equal(captured.router, router);
+  assert.equal(captured.ownerSelector, 'admin');
+  assert.equal(captured.reason, 'workspaceClose');
+  assert.deepEqual(captured.items, [
+    { fullPath: '/entry/1/edit', componentKey: 'edit-1', tabKey: 'workspace' },
+    { fullPath: '/entry/2/edit', componentKey: 'edit-2', tabKey: 'workspace' },
+  ]);
+});
+
+test('failed cleanup is reported without skipping other cleanup or rejecting navigation', async () => {
+  const error = new Error('unavailable');
+  const reported: unknown[] = [];
+  let completed = false;
+  await dispatchRouteDiscard(
+    { router, reason: 'taskClose', items: [{ fullPath: '/entry/create' }] },
+    event => {
+      event.waitUntil(Promise.reject(error));
+      event.waitUntil(
+        Promise.resolve().then(() => {
+          completed = true;
+        }),
+      );
+    },
+    failure => reported.push(failure),
+  );
+
+  assert.equal(completed, true);
+  assert.deepEqual(reported, [error]);
+});
+
+test('a synchronous listener failure still drains registered cleanup', async () => {
+  const error = new Error('listener failed');
+  const reported: unknown[] = [];
+  let completed = false;
+  await dispatchRouteDiscard(
+    { router, reason: 'back', items: [{ fullPath: '/entry/create' }] },
+    event => {
+      event.waitUntil(
+        Promise.resolve().then(() => {
+          completed = true;
+        }),
+      );
+      throw error;
+    },
+    failure => reported.push(failure),
+  );
+
+  assert.equal(completed, true);
+  assert.deepEqual(reported, [error]);
+});

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

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