cabloy 5.1.207 → 5.1.209

package/zova/src/suite/a-home/modules/home-passport/src/model/passport.ts

@@ -25,6 +25,8 @@ export class ModelPassport extends BeanModelBase {
   accessToken?: string;
   expireTime?: number;
   schemaLogin?: SchemaObject;
+  private _passportRevision = 0;
+  private _identityUpdating = false;
 
   protected async __init__() {}
 
@@ -43,6 +45,28 @@ export class ModelPassport extends BeanModelBase {
     if (process.env.CLIENT) {
       this._setLocaleTz();
     }
+    this._syncPersistenceIdentity(true);
+    this.$watch(
+      () => [this.passport?.instanceId, this.passport?.user?.id, this.sys.env.SITE_ID],
+      () => {
+        if (this._identityUpdating) return;
+        ++this._passportRevision;
+        this._syncPersistenceIdentity();
+      },
+      { flush: 'sync' },
+    );
+  }
+
+  private _syncPersistenceIdentity(initial = false, options: { refetchActive?: boolean } = {}) {
+    const passport = this.passport;
+    this.$modelPersistence.update(
+      {
+        instanceId: passport?.user ? passport.instanceId : null,
+        siteId: this.sys.env.SITE_ID,
+        userId: passport?.user?.id,
+      },
+      { initial, ...options },
+    );
   }
 
   get apiSchemasLogin() {
@@ -199,17 +223,20 @@ export class ModelPassport extends BeanModelBase {
 
   async refreshCurrent() {
     if (this.$ssr.cookieDisabledOnServer || !this.accessToken) return;
-    this.passport = await this.$api.homeUserPassport.current();
+    const revision = this._passportRevision;
+    const passport = await this.$api.homeUserPassport.current();
+    if (revision !== this._passportRevision) return this.passport;
+    this._setPassport(passport);
     this._setLocaleTz();
     return this.passport;
   }
 
   async requireRelogin(returnTo?: string | boolean, cause?: string) {
-    this._setPassportJwt();
+    this._setPassportJwt(undefined, { refetchActive: false });
     // page: login
     await this.app.$gotoLogin(returnTo, cause);
     // clear: should after goto login page, avoid home-layoutadmin use some cache data
-    this.$clear(); // not await
+    await this.$clear();
   }
 
   private _isTempAuthTokenExpired(
@@ -239,17 +266,24 @@ export class ModelPassport extends BeanModelBase {
     }
   }
 
-  private _setPassportJwt(data?: ApiApiHomeUserPassportloginResponseBody) {
-    this._setPassport(data?.passport);
-    this._setJwt(data?.jwt);
+  private _setPassportJwt(
+    data?: ApiApiHomeUserPassportloginResponseBody,
+    options: { refetchActive?: boolean } = {},
+  ) {
+    this._identityUpdating = true;
+    try {
+      this._setPassport(data?.passport);
+      this._setJwt(data?.jwt);
+    } finally {
+      this._identityUpdating = false;
+      this._syncPersistenceIdentity(false, options);
+    }
   }
 
   private _setPassport(passport?: ApiApiHomeUserPassportloginResponseBody['passport']) {
-    if (passport) {
-      this.passport = passport;
-    } else {
-      this.passport = undefined;
-    }
+    ++this._passportRevision;
+    this.passport = passport;
+    if (!this._identityUpdating) this._syncPersistenceIdentity();
   }
 
   private _setJwt(jwt?: ApiApiHomeUserPassportloginResponseBody['jwt']) {

package/zova/src/suite/a-home/modules/home-passport/test/lib/persistenceIdentity.test.ts

@@ -0,0 +1,229 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { stripTypeScriptTypes } from 'node:module';
+import test from 'node:test';
+import { effectScope, reactive, watch } from 'vue';
+
+async function createRuntime(initialPassport?: any) {
+  const updates: any[] = [];
+  const calls: string[] = [];
+  const scope = effectScope();
+  let current: () => Promise<any> = async () => undefined;
+  let gotoLogin: () => Promise<void> = async () => undefined;
+  class BeanModelBase {
+    sys = { env: { SITE_ID: 'admin' } };
+    scope = { config: { accessToken: { expireTimeDelay: 0 } } };
+    $ssr = { cookieDisabledOnServer: false };
+    app = {
+      meta: { cookie: { getItem: () => undefined }, locale: {} },
+      $gotoReturnTo() {
+        calls.push('navigate');
+      },
+      async $gotoLogin() {
+        calls.push('login');
+        await gotoLogin();
+      },
+    };
+
+    $api = { homeUserPassport: { current: () => current() } };
+    $modelPersistence = {
+      update: (identity: any, options: any) => {
+        updates.push({ identity, options, token: (this as any).accessToken });
+        calls.push('scope');
+      },
+    };
+
+    $computed() {}
+    $useStateLocal(options: any) {
+      if (options.queryKey[0] === 'passport') return initialPassport;
+    }
+
+    $useStateMem(options: any) {
+      return this.$useStateLocal(options);
+    }
+
+    $useStateCookie() {
+      return 'initial-token';
+    }
+
+    $watch(source: any, callback: any, options: any) {
+      return scope.run(() => watch(source, callback, options));
+    }
+
+    async $clear() {
+      calls.push('clear');
+    }
+  }
+  const source = readFileSync(new URL('../../src/model/passport.ts', import.meta.url), 'utf8')
+    .replace(/^import[\s\S]*?;\n/gm, '')
+    .replace(/^@Model[^\n]*\n/gm, '');
+  const javascript = stripTypeScriptTypes(source).replace(
+    'export class ModelPassport',
+    'class ModelPassport',
+  );
+  const ModelPassport = new Function('BeanModelBase', `${javascript}\nreturn ModelPassport;`)(
+    BeanModelBase,
+  );
+  const passport = reactive(new ModelPassport());
+  await passport.appInitialize();
+  return {
+    passport,
+    updates,
+    calls,
+    setCurrent(callback: () => Promise<any>) {
+      current = callback;
+    },
+    setGotoLogin(callback: () => Promise<void>) {
+      gotoLogin = callback;
+    },
+    dispose() {
+      scope.stop();
+    },
+  };
+}
+
+function identity(id = 1, instanceId: number | null = 2) {
+  return { instanceId, user: { id, name: 'User' }, roles: [] };
+}
+
+function loginData(id = 1, instanceId: number | null = 2) {
+  return {
+    passport: identity(id, instanceId),
+    jwt: { accessToken: `token-${id}`, expiresIn: 3600, refreshToken: `refresh-${id}` },
+  };
+}
+
+function deferred() {
+  let resolve!: (value: any) => void;
+  const promise = new Promise<any>(done => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+test('Passport initialization supplies null identity without introducing a readiness gate', async () => {
+  const runtime = await createRuntime();
+  try {
+    assert.deepEqual(runtime.updates, [
+      {
+        identity: { instanceId: null, siteId: 'admin', userId: undefined },
+        options: { initial: true },
+        token: 'initial-token',
+      },
+    ]);
+  } finally {
+    runtime.dispose();
+  }
+});
+
+test('Passport initial identity is adopted and login publishes only after installing its token', async () => {
+  const runtime = await createRuntime(identity());
+  try {
+    assert.equal(runtime.updates[0].options.initial, true);
+    assert.deepEqual(runtime.updates[0].identity, { instanceId: 2, siteId: 'admin', userId: 1 });
+    runtime.updates.length = 0;
+    runtime.calls.length = 0;
+    runtime.passport.afterLogin(loginData(3, 4));
+    assert.deepEqual(runtime.updates, [
+      {
+        identity: { instanceId: 4, siteId: 'admin', userId: 3 },
+        options: { initial: false },
+        token: 'token-3',
+      },
+    ]);
+    assert.deepEqual(runtime.calls, ['scope', 'navigate']);
+  } finally {
+    runtime.dispose();
+  }
+});
+
+test('direct Passport and site changes synchronize the same neutral context', async () => {
+  const runtime = await createRuntime(identity());
+  try {
+    runtime.passport.passport = identity(1, 8);
+    assert.deepEqual(runtime.updates.at(-1).identity, {
+      instanceId: 8,
+      siteId: 'admin',
+      userId: 1,
+    });
+    runtime.passport.sys.env.SITE_ID = 'web';
+    assert.deepEqual(runtime.updates.at(-1).identity, { instanceId: 8, siteId: 'web', userId: 1 });
+    runtime.passport.passport = undefined;
+    assert.deepEqual(runtime.updates.at(-1).identity, {
+      instanceId: null,
+      siteId: 'web',
+      userId: undefined,
+    });
+  } finally {
+    runtime.dispose();
+  }
+});
+
+test('requireRelogin immediately publishes anonymous identity without refetch before navigation and clear', async () => {
+  const runtime = await createRuntime(identity());
+  const navigation = deferred();
+  runtime.setGotoLogin(() => navigation.promise);
+  runtime.updates.length = 0;
+  runtime.calls.length = 0;
+  try {
+    const relogin = runtime.passport.requireRelogin();
+    assert.equal(runtime.passport.passport, undefined);
+    assert.equal(runtime.passport.accessToken, undefined);
+    assert.deepEqual(runtime.updates, [
+      {
+        identity: { instanceId: null, siteId: 'admin', userId: undefined },
+        options: { initial: false, refetchActive: false },
+        token: undefined,
+      },
+    ]);
+    assert.deepEqual(runtime.calls, ['scope', 'login']);
+    await Promise.resolve();
+    assert.deepEqual(runtime.calls, ['scope', 'login']);
+    navigation.resolve(undefined);
+    await relogin;
+    assert.deepEqual(runtime.calls, ['scope', 'login', 'clear']);
+
+    runtime.passport.afterLogin(loginData(3, 4));
+    assert.equal(runtime.updates.at(-1)!.token, 'token-3');
+    assert.notEqual(runtime.updates.at(-1)!.options.refetchActive, false);
+    runtime.passport.passport = identity(3, 8);
+    assert.notEqual(runtime.updates.at(-1)!.options.refetchActive, false);
+    runtime.passport.sys.env.SITE_ID = 'web';
+    assert.notEqual(runtime.updates.at(-1)!.options.refetchActive, false);
+  } finally {
+    navigation.resolve(undefined);
+    runtime.dispose();
+  }
+});
+
+test('refreshCurrent updates identity but a late response cannot undo login or logout', async () => {
+  const runtime = await createRuntime(identity());
+  try {
+    runtime.setCurrent(async () => identity(1, 7));
+    await runtime.passport.refreshCurrent();
+    assert.equal(runtime.passport.passport.instanceId, 7);
+    assert.equal(runtime.updates.at(-1).identity.instanceId, 7);
+
+    const pending = deferred();
+    runtime.setCurrent(() => pending.promise);
+    const refreshing = runtime.passport.refreshCurrent();
+    runtime.passport.afterLogin(loginData(3, 4));
+    pending.resolve(identity(1, 7));
+    await refreshing;
+    assert.equal(runtime.passport.user.id, 3);
+
+    const outgoing = deferred();
+    runtime.setCurrent(() => outgoing.promise);
+    const outgoingRefresh = runtime.passport.refreshCurrent();
+    runtime.calls.length = 0;
+    await runtime.passport.requireRelogin();
+    assert.deepEqual(runtime.calls, ['scope', 'login', 'clear']);
+    assert.equal(runtime.updates.at(-1).identity.instanceId, null);
+    assert.equal(runtime.updates.at(-1).token, undefined);
+    outgoing.resolve(identity(3, 4));
+    await outgoingRefresh;
+    assert.equal(runtime.passport.user, undefined);
+  } finally {
+    runtime.dispose();
+  }
+});

package/zova/src/suite/cabloy-basic/modules/basic-pageentry/package.json

@@ -49,5 +49,13 @@
       "exports.\\..import"
     ]
   },
-  "title": "basic-pageentry"
+  "title": "basic-pageentry",
+  "zovaModule": {
+    "capabilities": {
+      "monkey": true
+    },
+    "dependencies": {
+      "a-zova": "5.0.0"
+    }
+  }
 }

package/zova/src/suite/cabloy-basic/modules/basic-pageentry/src/.metadata/index.ts

@@ -1,4 +1,70 @@
 // eslint-disable
+/** model: begin */
+export * from '../model/draft.js';
+import { IModelOptionsDraft } from '../model/draft.js';
+import 'zova-module-a-model';
+declare module 'zova-module-a-model' {
+
+    export interface IModelRecord {
+      'basic-pageentry:draft': IModelOptionsDraft;
+    }
+
+
+}
+declare module 'zova-module-basic-pageentry' {
+
+        export interface ModelDraft {
+          /** @internal */
+          get scope(): ScopeModuleBasicPageentry;
+        }
+
+        export interface ModelDraft {
+          get $beanFullName(): 'basic-pageentry.model.draft';
+          get $onionName(): 'basic-pageentry:draft';
+          get $onionOptions(): IModelOptionsDraft;
+        }
+}
+/** model: end */
+/** model: begin */
+import type { ModelDraft } from '../model/draft.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'basic-pageentry.model.draft': ModelDraft;
+  }
+}
+/** model: end */
+/** bean: begin */
+export * from '../bean/bean.draftCoordinator.js';
+
+import 'zova';
+declare module 'zova' {
+
+
+}
+declare module 'zova-module-basic-pageentry' {
+
+        export interface BeanDraftCoordinator {
+          /** @internal */
+          get scope(): ScopeModuleBasicPageentry;
+        }
+
+        export interface BeanDraftCoordinator {
+          get $beanFullName(): 'basic-pageentry.bean.draftCoordinator';
+          get $onionName(): 'basic-pageentry:draftCoordinator';
+
+        }
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanDraftCoordinator } from '../bean/bean.draftCoordinator.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'basic-pageentry.bean.draftCoordinator': BeanDraftCoordinator;
+  }
+}
+/** bean: end */
 /** controller: begin */
 export * from '../component/blockForm/controller.jsx';
 export * from '../component/blockPageEntry/controller.jsx';
@@ -28,9 +94,9 @@ declare module 'zova-module-basic-pageentry' {
 }
 /** controller: end */
 /** controller: begin */
-import { ControllerBlockForm } from '../component/blockForm/controller.jsx';
-import { ControllerBlockPageEntry } from '../component/blockPageEntry/controller.jsx';
-import { ControllerBlockToolbarRow } from '../component/blockToolbarRow/controller.jsx';
+import type { ControllerBlockForm } from '../component/blockForm/controller.jsx';
+import type { ControllerBlockPageEntry } from '../component/blockPageEntry/controller.jsx';
+import type { ControllerBlockToolbarRow } from '../component/blockToolbarRow/controller.jsx';
 import 'zova';
 declare module 'zova' {
   export interface IBeanRecordLocal {
@@ -67,11 +133,18 @@ export interface IZovaComponentRecord {
 }
 }
 /** components: end */
+/** config: begin */
+export * from '../config/config.js';
+import { config } from '../config/config.js';
+/** config: end */
 /** locale: begin */
 import { locales } from './locales.js';
 /** locale: end */
+/** monkey: begin */
+export * from '../monkey.js';
+/** monkey: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil, TypeModuleLocales, TypeLocaleBase } from 'zova';
+import { BeanScopeBase, type BeanScopeUtil, TypeModuleConfig, TypeModuleLocales, TypeLocaleBase } from 'zova';
 import { Scope } from 'zova-module-a-bean';
 
 @Scope()
@@ -79,6 +152,7 @@ export class ScopeModuleBasicPageentry extends BeanScopeBase {}
 
 export interface ScopeModuleBasicPageentry {
   util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
 locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
 }
 
@@ -88,7 +162,9 @@ declare module 'zova' {
     'basic-pageentry': ScopeModuleBasicPageentry;
   }
 
-
+  export interface IBeanScopeConfig {
+    'basic-pageentry': ReturnType<typeof config>;
+  }
 
   export interface IBeanScopeLocale {
     'basic-pageentry': (typeof locales)[TypeLocaleBase];

package/zova/src/suite/cabloy-basic/modules/basic-pageentry/src/bean/bean.draftCoordinator.ts

@@ -0,0 +1,158 @@
+import type { BeanRouter, IRouteDiscardEvent } from 'zova-module-a-router';
+
+import { BeanBase } from 'zova';
+import { Bean } from 'zova-module-a-bean';
+
+import type { ModelDraft } from '../model/draft.js';
+import type { IDraftEditor, IDraftEnvelope, IDraftIdentity } from '../types/draft.js';
+
+interface IDraftSession {
+  generation: number;
+  barrier: Promise<void>;
+  owner?: ModelDraft;
+}
+
+@Bean()
+export class BeanDraftCoordinator extends BeanBase {
+  private _sessions = new Map<string, IDraftSession>();
+  private _identityPaths = new Map<string, IDraftIdentity>();
+  private _offDiscard?: () => void;
+  private _offContext?: () => void;
+
+  protected async __init__() {
+    if (!process.env.CLIENT) return;
+    this._offContext = this.$modelPersistence.subscribe(() => {
+      for (const session of this._sessions.values()) ++session.generation;
+      this._sessions.clear();
+      this._identityPaths.clear();
+    });
+    this._offDiscard = this.app.meta.event.on('a-router:routeDiscard', (event, next) => {
+      this._discardRoutes(event);
+      return next();
+    });
+  }
+
+  protected __dispose__() {
+    this._offDiscard?.();
+    this._offContext?.();
+  }
+
+  identity(
+    router: BeanRouter,
+    fullPath: string,
+    resource?: string,
+    mode?: 'create' | 'edit',
+    id?: string | number,
+  ): IDraftIdentity | undefined {
+    const user = this.$passport.user;
+    if (
+      !process.env.CLIENT ||
+      !this.$passport.isAuthenticated ||
+      !user ||
+      user.anonymous ||
+      user.id == null
+    ) {
+      return;
+    }
+    const route = router.resolve(fullPath);
+    if (!resource) {
+      if (route.name === 'rest-resource:entryCreate') {
+        mode = 'create';
+      } else if (route.name === 'rest-resource:entry' && route.params.formScene === 'edit') {
+        mode = 'edit';
+        id = String(route.params.id);
+      } else {
+        return;
+      }
+      resource = String(route.params.resource);
+    }
+    if (!mode) return;
+    return {
+      context: this.$modelPersistence.capture(),
+      resource,
+      mode,
+      id: mode === 'edit' ? String(id) : undefined,
+      path: route.path,
+    };
+  }
+
+  key(identity: IDraftIdentity) {
+    return JSON.stringify([identity.resource, identity.mode, identity.id ?? null, identity.path]);
+  }
+
+  private _session(key: string) {
+    let session = this._sessions.get(key);
+    if (!session) {
+      session = { generation: 0, barrier: Promise.resolve() };
+      this._sessions.set(key, session);
+    }
+    return session;
+  }
+
+  async open(identity: IDraftIdentity): Promise<IDraftEditor | undefined> {
+    if (!this.isCurrent(identity)) return;
+    const key = this.key(identity);
+    this._identityPaths.set(identity.path, identity);
+    const session = this._session(key);
+    const generation = session.generation;
+    await session.barrier;
+    if (generation !== session.generation || !this.isCurrent(identity)) return;
+    const owner = await this.app.bean._getBeanSelector('basic-pageentry.model.draft', true, key);
+    session.owner = owner;
+    await owner.load();
+    if (generation !== session.generation || !this.isCurrent(identity)) return;
+    return { key, generation, owner, identity };
+  }
+
+  current(editor: IDraftEditor) {
+    return (
+      this._session(editor.key).generation === editor.generation && this.isCurrent(editor.identity)
+    );
+  }
+
+  async save(editor: IDraftEditor, identity: IDraftIdentity, envelope: IDraftEnvelope) {
+    if (editor.key !== this.key(identity) || !this.current(editor) || !this.isCurrent(identity))
+      return;
+    const session = this._session(editor.key);
+    await session.barrier;
+    if (!this.current(editor) || !this.isCurrent(identity)) return;
+    await editor.owner.save(envelope);
+  }
+
+  remove(identity: IDraftIdentity): Promise<void> {
+    if (!this.isCurrent(identity)) return Promise.resolve();
+    const key = this.key(identity);
+    const session = this._session(key);
+    ++session.generation;
+    const cleanup = session.barrier.then(async () => {
+      if (!this.isCurrent(identity)) return;
+      const owner =
+        session.owner ??
+        (await this.app.bean._getBeanSelector('basic-pageentry.model.draft', true, key));
+      if (!this.isCurrent(identity)) return;
+      session.owner = owner;
+      await owner.remove();
+    });
+    session.barrier = cleanup.catch(() => {});
+    return cleanup;
+  }
+
+  isCurrent(identity: IDraftIdentity) {
+    return (
+      this.$passport.isAuthenticated &&
+      !this.$passport.user?.anonymous &&
+      this.$modelPersistence.current(identity.context)
+    );
+  }
+
+  private _discardRoutes(event: IRouteDiscardEvent) {
+    for (const item of event.items) {
+      const path = event.router.resolve(item.fullPath).path;
+      const known = this._identityPaths.get(path);
+      const identity =
+        known && this.isCurrent(known) ? known : this.identity(event.router, item.fullPath);
+      if (!identity || !this.isCurrent(identity)) continue;
+      event.waitUntil(this.remove(identity));
+    }
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-pageentry/src/component/blockForm/controller.tsx

@@ -38,12 +38,19 @@ export class ControllerBlockForm extends BeanControllerBase {
         class={this.$props.class}
         controllerRef={ref => {
           this.formRef = ref;
-          $$pageEntry.formRef = ref;
+          $$pageEntry.formReady(ref);
         }}
         formTag="div"
-        data={$$pageEntry.formData}
+        data={$$pageEntry.editorData}
         schema={$$pageEntry.formSchema}
         schemaScene={$$pageEntry.schemaScene}
+        localePresentationRefresh={{
+          identity: JSON.stringify([
+            $$pageEntry.resource,
+            $$pageEntry.entryId ?? null,
+            $$pageEntry.formScene,
+          ]),
+        }}
         formMeta={$$pageEntry.formMeta}
         formProvider={$$pageEntry.formProvider}
         blocks={this.$props.blocks}
@@ -56,8 +63,9 @@ export class ControllerBlockForm extends BeanControllerBase {
           });
         }}
         onChanged={data => {
-          $$pageEntry.setPageMeta(data, true);
+          $$pageEntry.formChanged(data);
         }}
+        onSchemaRefreshed={data => $$pageEntry.formSchemaRefreshed(data)}
       ></ZForm>
     );
   }