cabloy 5.1.221 → 5.1.222

package/vona/src/suite-vendor/a-vona/modules/a-executor/test/readyExistingCommit.test.ts

@@ -0,0 +1,174 @@
+import type { VonaApplication, VonaContext } from 'vona';
+import type { ServiceDb } from 'vona-module-a-orm';
+
+import assert from 'node:assert/strict';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { describe, it } from 'node:test';
+import {
+  beginCompletedInstance,
+  captureCompletedInstance,
+  createCompletedReadiness,
+  createRequestBoundary,
+  finishCompletedInstance,
+  runWithRequestBoundary,
+} from 'vona';
+import {
+  ServiceDatabaseAsyncLocalStorage,
+  ServiceTransactionAsyncLocalStorage,
+  ServiceTransactionConsistency‌,
+  ServiceTransactionState,
+} from 'vona-module-a-orm';
+
+import { VonaAsyncLocalStorage } from '../../../../../../packages-vona/vona-core/src/lib/core/asyncLocalStorage.ts';
+import {
+  beginCompletedApplication,
+  finishCompletedApplication,
+  getCompletedPublication,
+  issueExistingReadyCapability,
+  provisionCompletedInstanceForTest,
+} from '../../../../../../packages-vona/vona-core/src/lib/core/completedReadiness.ts';
+import { BeanExecutor } from '../src/bean/bean.executor.ts';
+
+// Real executor, context disposal and ORM callback queues with inert, test-owned DB ports.
+// No application singleton, persistence, environment configuration or listener is used.
+function fixture() {
+  const events: string[] = [];
+  let active = 0;
+  const database = new ServiceDatabaseAsyncLocalStorage();
+  database.dbStorage = new AsyncLocalStorage();
+  const transaction = new ServiceTransactionAsyncLocalStorage();
+  transaction.transactionStorage = new AsyncLocalStorage();
+  Object.defineProperty(transaction, 'bean', {
+    value: { _newBean: () => new ServiceTransactionState() },
+  });
+  const handle = {} as ServiceDb;
+  let storage: VonaAsyncLocalStorage;
+  const local = {
+    meta: {
+      completedReadiness: undefined as ReturnType<typeof createCompletedReadiness> | undefined,
+      ctxCounter: {
+        increment() {
+          active++;
+        },
+        decrement() {
+          active--;
+        },
+      },
+    },
+    get currentContext() {
+      return storage.getStore();
+    },
+    createAnonymousContext() {
+      const consistency = new ServiceTransactionConsistency‌();
+      return {
+        commit: (cb: () => unknown) => consistency.commit(cb),
+        commitsDone: () => consistency.commitsDone(),
+        bean: {
+          async dispose() {
+            events.push('disposed');
+          },
+        },
+      } as unknown as VonaContext;
+    },
+  };
+  storage = new VonaAsyncLocalStorage(local as unknown as VonaApplication);
+  Object.assign(local, { ctxStorage: storage });
+  const executor = Object.create(BeanExecutor.prototype) as BeanExecutor;
+  Object.defineProperties(executor, {
+    app: { value: local },
+    ctx: { get: () => local.currentContext },
+    bean: {
+      value: {
+        _getBean(selector: unknown) {
+          assert.ok(
+            selector === ServiceDatabaseAsyncLocalStorage ||
+              selector === ServiceTransactionAsyncLocalStorage,
+          );
+          return selector === ServiceDatabaseAsyncLocalStorage ? database : transaction;
+        },
+      },
+    },
+  });
+  const owner = createCompletedReadiness(local);
+  local.meta.completedReadiness = owner;
+  const registry = {},
+    route = {};
+  provisionCompletedInstanceForTest(owner, '', { registry, route, handle, isolate: false });
+  const application = beginCompletedApplication(owner);
+  const attempt = beginCompletedInstance(owner, '');
+  const row = { id: 1, name: '', disabled: false, isolate: false, config: null };
+  const captured = captureCompletedInstance(owner, '', attempt, row, {});
+  finishCompletedInstance(owner, '', attempt, captured);
+  finishCompletedApplication(owner, application, true);
+  const publication = getCompletedPublication(owner, '', registry, route);
+  assert.ok(publication);
+  const capability = issueExistingReadyCapability(owner, publication, 1_000, () => 0);
+  return {
+    local,
+    executor,
+    database,
+    transaction,
+    handle,
+    capability,
+    events,
+    active: () => active,
+  };
+}
+
+describe('ready-existing commit lifecycle', { concurrency: false }, () => {
+  it('awaits async and nested commit callbacks before disposal in the pinned scope', async () => {
+    const f = fixture();
+    const result = await runWithRequestBoundary(createRequestBoundary(), () =>
+      f.executor.newCtxReadyExisting(f.capability, async () => {
+        const context = f.local.currentContext!;
+        const state = f.transaction.transactionState;
+        f.events.push('callback');
+        context.commit(async () => {
+          f.events.push('commit');
+          assert.equal(f.local.currentContext, context);
+          assert.equal(f.database.current, f.handle);
+          assert.equal(f.transaction.transactionState, state);
+          assert.equal(f.active(), 1);
+          await Promise.resolve();
+          context.commit(() => f.events.push('nested_commit'));
+          f.events.push('commit_done');
+        });
+        return 'result';
+      }),
+    );
+    assert.equal(result, 'result');
+    assert.deepEqual(f.events, ['callback', 'commit', 'commit_done', 'nested_commit', 'disposed']);
+    assert.equal(f.active(), 0);
+    assert.equal(f.local.currentContext, undefined);
+    assert.equal(f.database.current, undefined);
+    assert.equal(f.transaction.transactionState, undefined);
+  });
+
+  for (const phase of ['callback', 'commit'] as const) {
+    it(`propagates ${phase} failure and still disposes the context`, async () => {
+      const f = fixture();
+      const failure = new Error(`controlled_${phase}_failure`);
+      await assert.rejects(
+        runWithRequestBoundary(createRequestBoundary(), () =>
+          f.executor.newCtxReadyExisting(f.capability, async () => {
+            f.events.push('callback');
+            f.local.currentContext!.commit(() => {
+              f.events.push('commit');
+              throw failure;
+            });
+            if (phase === 'callback') throw failure;
+          }),
+        ),
+        error => error === failure,
+      );
+      assert.deepEqual(
+        f.events,
+        phase === 'callback' ? ['callback', 'disposed'] : ['callback', 'commit', 'disposed'],
+      );
+      assert.equal(f.active(), 0);
+      assert.equal(f.local.currentContext, undefined);
+      assert.equal(f.database.current, undefined);
+      assert.equal(f.transaction.transactionState, undefined);
+    });
+  }
+});

package/vona/src/suite-vendor/a-vona/modules/a-instance/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-instance",
-  "version": "5.1.14",
+  "version": "5.1.15",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "zhennann",

package/vona/src/suite-vendor/a-vona/modules/a-instance/src/bean/bean.instance.ts

@@ -1,7 +1,7 @@
 import type { IInstanceRecord, VonaConfig } from 'vona';
 
 import { isNil } from '@cabloy/utils';
-import { BeanBase } from 'vona';
+import { BeanBase, invalidateCompletedInstance } from 'vona';
 import { Bean } from 'vona-module-a-bean';
 
 import type { EntityInstance } from '../entity/instance.ts';
@@ -83,12 +83,14 @@ export class BeanInstance extends BeanBase {
   async reload(instanceName?: keyof IInstanceRecord) {
     const instanceName2 = instanceName ?? this.ctx.instanceName;
     if (isNil(instanceName2)) throw new Error('Should specify the instanceName');
+    invalidateCompletedInstance(this.app.meta.completedReadiness, instanceName2);
     await this.reloadWorker(instanceName2);
     // broadcast
     this.scope.broadcast.reload.emit(instanceName2);
   }
 
   async reloadWorker(instanceName: keyof IInstanceRecord) {
+    invalidateCompletedInstance(this.app.meta.completedReadiness, instanceName);
     await this.scope.service.instance.instanceStartupIsolate(instanceName, { force: true });
   }
 }

package/vona/src/suite-vendor/a-vona/modules/a-instance/src/lib/existingReadyAdmission.ts

@@ -0,0 +1,125 @@
+import type { CompletedReadiness, ExistingReadyCapability } from 'vona';
+
+import { captureRequestBoundary, resolveExistingReadyCapability } from 'vona';
+
+export type ExistingReadyOutcome =
+  | 'ready'
+  | 'invalid_input'
+  | 'boundary_required'
+  | 'busy'
+  | 'expired'
+  | 'unavailable';
+export type ExistingReadyResult = Readonly<
+  | { outcome: 'ready'; capability: ExistingReadyCapability }
+  | { outcome: Exclude<ExistingReadyOutcome, 'ready'> }
+>;
+
+interface AdmissionDependencies {
+  readonly owner: CompletedReadiness;
+  readonly registry: object;
+  readonly route: object;
+  readonly read: (name: string) => unknown | Promise<unknown>;
+  readonly now: () => number;
+  readonly getCompletedPublication: (
+    owner: CompletedReadiness,
+    name: string,
+    registry: object,
+    route: object,
+  ) => object | undefined;
+  readonly matchesCompletedRow: (publication: object, row: unknown) => boolean;
+  readonly issueExistingReadyCapability: (
+    owner: CompletedReadiness,
+    publication: object,
+    deadline: number,
+    now: () => number,
+  ) => ExistingReadyCapability;
+}
+
+// Deliberately unregistered and implementation-file-only. Production read-port provisioning
+// and driver diagnostics require their own qualification, not adoption of caller handles.
+export function createExistingReadyAdmissionForTest(dependencies: AdmissionDependencies) {
+  if (captureRequestBoundary()) throw new Error('Provisioning requires lifecycle boundary');
+  const {
+    owner,
+    registry,
+    route,
+    read,
+    now,
+    getCompletedPublication,
+    matchesCompletedRow,
+    issueExistingReadyCapability,
+  } = dependencies;
+  let active = false;
+  const outcome = (value: Exclude<ExistingReadyOutcome, 'ready'>): ExistingReadyResult =>
+    Object.freeze({ outcome: value });
+  async function check(
+    name: unknown,
+    deadlineAt?: number,
+    prior?: ExistingReadyCapability,
+  ): Promise<ExistingReadyResult> {
+    const boundary = captureRequestBoundary();
+    if (!boundary || boundary.snapshot().portFault) return outcome('boundary_required');
+    if (
+      typeof name !== 'string' ||
+      !name.isWellFormed() ||
+      name.includes('\0') ||
+      Buffer.byteLength(name) > 256
+    ) {
+      return outcome('invalid_input');
+    }
+    if (active) return outcome('busy');
+    active = true;
+    try {
+      const started = now();
+      if (!Number.isFinite(started) || (deadlineAt !== undefined && !Number.isFinite(deadlineAt)))
+        return outcome('invalid_input');
+      const deadline = Math.min(deadlineAt ?? started + 1_000, started + 1_000);
+      if (started >= deadline) return outcome('expired');
+      const publication = getCompletedPublication(owner, name, registry, route);
+      const previous = prior && resolveExistingReadyCapability(owner, prior);
+      if (!publication || (prior && previous?.publication !== publication))
+        return outcome('unavailable');
+      const result = await read(name);
+      const ended = now();
+      if (!Number.isFinite(ended) || ended < started || ended >= deadline)
+        return outcome('expired');
+      if (
+        boundary.snapshot().portFault ||
+        getCompletedPublication(owner, name, registry, route) !== publication ||
+        (prior && resolveExistingReadyCapability(owner, prior)?.publication !== publication)
+      ) {
+        return outcome('unavailable');
+      }
+      if (!result || typeof result !== 'object') return outcome('unavailable');
+      const descriptor = Object.getOwnPropertyDescriptor(result, 'outcome');
+      const row = Object.getOwnPropertyDescriptor(result, 'row');
+      if (
+        !descriptor ||
+        !('value' in descriptor) ||
+        descriptor.value !== 'found' ||
+        !row ||
+        !('value' in row) ||
+        !matchesCompletedRow(publication, row.value)
+      ) {
+        return outcome('unavailable');
+      }
+      return Object.freeze({
+        outcome: 'ready',
+        capability: prior ?? issueExistingReadyCapability(owner, publication, deadline, now),
+      });
+    } catch {
+      return outcome('unavailable');
+    } finally {
+      active = false;
+    }
+  }
+  return Object.freeze({
+    admit: (name: string, deadlineAt?: number) => check(name, deadlineAt),
+    recheck: (capability: ExistingReadyCapability, deadlineAt?: number) => {
+      const resolved = resolveExistingReadyCapability(owner, capability);
+      return resolved
+        ? check(resolved.name, deadlineAt, capability)
+        : Promise.resolve(outcome('unavailable'));
+    },
+  });
+}

package/vona/src/suite-vendor/a-vona/modules/a-instance/src/service/instance.ts

@@ -3,7 +3,15 @@ import type { IInstanceStartupOptions } from 'vona-module-a-startup';
 
 import { isNil, sleep } from '@cabloy/utils';
 import async from 'async';
-import { BeanBase, deepExtend } from 'vona';
+import { AsyncResource } from 'node:async_hooks';
+import {
+  BeanBase,
+  beginCompletedInstance,
+  captureCompletedInstance,
+  deepExtend,
+  finishCompletedInstance,
+  invalidateCompletedInstance,
+} from 'vona';
 import { Service } from 'vona-module-a-bean';
 
 import type { IInstanceStartupQueueInfo } from '../entity/instance.ts';
@@ -73,6 +81,9 @@ export class ServiceInstance extends BeanBase {
 
   async resetAllCaches() {
     const instanceNames = Object.keys(this.__cacheIntancesConfig);
+    for (const instanceName of instanceNames) {
+      invalidateCompletedInstance(this.app.meta.completedReadiness, instanceName);
+    }
     for (const instanceName of instanceNames) {
       await this.app.bean.executor.newCtx(
         async () => {
@@ -84,26 +95,41 @@ export class ServiceInstance extends BeanBase {
   }
 
   async resetCache(instanceName: keyof IInstanceRecord) {
+    invalidateCompletedInstance(this.app.meta.completedReadiness, instanceName);
     await this._cacheInstanceConfig(instanceName, true);
   }
 
-  private async _cacheInstanceConfig(instanceName: keyof IInstanceRecord, force?: boolean) {
+  private async _cacheInstanceConfig(
+    instanceName: keyof IInstanceRecord,
+    force?: boolean,
+    attempt?: object,
+    preparedBase?: ConfigInstanceBase,
+  ) {
     if (this.__cacheIntancesConfig[instanceName] && !force) return;
     let instance = await this.bean.instance.get(instanceName);
     if (!instance) this.app.throw(403);
     instance = instance!;
-    // config
-    const configInstanceBase = this.getConfigInstanceBase(instanceName);
-    const instanceConfigDb = instance.config ? JSON.parse(instance.config) : undefined;
+    // Capture persisted input before any other lifecycle operation can replace its cache.
+    const row = {
+      id: instance.id,
+      name: instance.name,
+      disabled: instance.disabled,
+      isolate: instance.isolate,
+      config: instance.config ?? null,
+    };
+    const configInstanceBase = preparedBase ?? this.getConfigInstanceBase(instanceName);
+    const instanceConfigDb = row.config ? JSON.parse(row.config) : undefined;
     // cache configs
-    this.__cacheIntancesConfig[instanceName] = deepExtend(
-      {},
-      this.app.config,
-      configInstanceBase?.config,
-      instanceConfigDb,
-      {
-        instance: undefined,
-      },
+    const merged = deepExtend({}, this.app.config, configInstanceBase?.config, instanceConfigDb, {
+      instance: undefined,
+    });
+    this.__cacheIntancesConfig[instanceName] = merged;
+    return captureCompletedInstance(
+      this.app.meta.completedReadiness,
+      instanceName,
+      attempt,
+      row,
+      merged,
     );
   }
 
@@ -111,6 +137,7 @@ export class ServiceInstance extends BeanBase {
     instanceName: keyof IInstanceRecord,
     options?: IInstanceStartupOptions,
   ) {
+    invalidateCompletedInstance(this.app.meta.completedReadiness, instanceName);
     await this.bean.executor.newCtx(
       async () => {
         await this.instanceStartup(instanceName, options);
@@ -121,27 +148,35 @@ export class ServiceInstance extends BeanBase {
 
   // options: force/instanceBase
   async instanceStartup(instanceName: keyof IInstanceRecord, options?: IInstanceStartupOptions) {
-    if (!options) options = {};
+    const owner = this.app.meta.completedReadiness;
+    const attempt = beginCompletedInstance(owner, instanceName);
+    options = { ...options };
     if (!options.configInstanceBase) {
       const configInstanceBase = this.getConfigInstanceBase(instanceName);
       options.configInstanceBase = configInstanceBase;
     }
-    // cache instance config
-    await this._cacheInstanceConfig(instanceName, options?.force);
+    // Preparation is serialized with startup below; publication never rereads a later cache.
+    const startupOptions = options;
+    const prepare = async () =>
+      this._cacheInstanceConfig(
+        instanceName,
+        startupOptions.force,
+        attempt,
+        startupOptions.configInstanceBase,
+      );
     // queue within the same worker
     if (!this.__queueInstanceStartup[instanceName]) {
       this.__queueInstanceStartup[instanceName] = async.queue(
-        (info: IInstanceStartupQueueInfo, cb: Function) => {
+        (
+          info: IInstanceStartupQueueInfo & { execute: (skip: boolean) => Promise<void> },
+          cb: Function,
+        ) => {
           // check again
           const force = info.options?.force;
-          if (this.ctx.app.meta.appReadyInstances[info.instanceName] && !force) {
-            info.resolve();
-            cb();
-            return;
-          }
+          const skip = !!this.app.meta.appReadyInstances[info.instanceName] && !force;
           // startup
-          this.$scope.startup.service.startup
-            .runStartupInstance(info.instanceName, info.options)
+          info
+            .execute(skip)
             .then(() => {
               info.resolve();
               cb();
@@ -158,7 +193,19 @@ export class ServiceInstance extends BeanBase {
       // options
       if (!options) options = { force: false, configInstanceBase: undefined };
       // queue push
-      const info: IInstanceStartupQueueInfo = { resolve, reject, instanceName, options };
+      const info: IInstanceStartupQueueInfo & { execute: (skip: boolean) => Promise<void> } = {
+        resolve,
+        reject,
+        instanceName,
+        options,
+        // The queue advances in the preceding worker's async context, not this caller's.
+        execute: AsyncResource.bind(async skip => {
+          const captured = await prepare();
+          if (skip) return;
+          await this.$scope.startup.service.startup.runStartupInstance(instanceName, options);
+          finishCompletedInstance(owner, instanceName, attempt, captured);
+        }),
+      };
       this.__queueInstanceStartup[instanceName].push(info);
     });
   }