@ariestools/aries-dapp-core 0.1.14 → 0.1.16

package/dist/node/index.mjs

@@ -11,163 +11,12 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/actor/AbstractActor.ts
-import {
-  AbstractCreatable,
-  assertEx,
-  IdLogger
-} from "@ariestools/sdk";
-function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  void promise.catch(() => {
-  });
-  return {
-    promise,
-    reject,
-    resolve
-  };
-}
-var AbstractActor = class extends AbstractCreatable {
-  _intervals = /* @__PURE__ */ new Map();
-  _timeouts = /* @__PURE__ */ new Map();
-  _abortController = new AbortController();
-  _idLogger;
-  _inFlight = /* @__PURE__ */ new Map();
-  _readyDeferred = createDeferred();
-  _readyError;
-  _readyState = "pending";
-  get logger() {
-    this._idLogger ??= new IdLogger(
-      assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`),
-      () => this.name
-    );
-    return this._idLogger;
-  }
-  get readyError() {
-    return this._readyError;
-  }
-  get readyState() {
-    return this._readyState;
-  }
-  get context() {
-    return this.locator.context;
-  }
-  get locator() {
-    return this.params.locator;
-  }
-  /** Abort signal cancelled when the actor stops (or is replaced on restart). */
-  get signal() {
-    return this._abortController.signal;
-  }
-  static async paramsHandler(params) {
-    const inParams = params ?? {};
-    const baseParams = await super.paramsHandler({ ...inParams, name: inParams.name ?? "UnknownActor" });
-    const locator = assertEx(inParams.locator, () => `params.locator is required for actor ${String(baseParams.name)}.`);
-    return { ...baseParams, locator };
-  }
-  /** Override to prove the actor can do useful work. Default: no-op. */
-  async readyHandler() {
-  }
-  /**
-   * Register a recurring task. The first invocation fires after `dueTimeMs`
-   * (the documented first-run delay); subsequent invocations fire every
-   * `periodMs` while the actor is `started`. A run is skipped if the previous
-   * one is still in flight, so a slow pass can never stack on top of itself.
-   * Must be called from `startHandler` (guards on `starting` status).
-   */
-  registerTimer(timerName, callback, dueTimeMs, periodMs) {
-    if (this.status !== "starting") {
-      this.logger.warn(`Cannot register timer '${timerName}' because actor is not starting.`);
-      return;
-    }
-    const tick = () => {
-      if (this.status !== "started") return;
-      if (this._inFlight.has(timerName)) {
-        this.logger.warn(`Skipping timer '${this.name}:${timerName}' because the previous run is still in flight.`);
-        return;
-      }
-      const run = (async () => {
-        const startTime = Date.now();
-        try {
-          await callback();
-        } catch (error) {
-          const err = error instanceof Error ? error : new Error(String(error));
-          this.logger.error(`Error in timer '${this.name}:${timerName}': ${err.message}`);
-        } finally {
-          const duration = Date.now() - startTime;
-          if (duration > periodMs) {
-            this.logger.warn(`Timer '${this.name}:${timerName}' took ${duration}ms, longer than its ${periodMs}ms period.`);
-          }
-        }
-      })();
-      this._inFlight.set(timerName, run.finally(() => {
-        this._inFlight.delete(timerName);
-      }));
-    };
-    const timeoutId = setTimeout(() => {
-      if (this.status !== "started") return;
-      this._intervals.set(timerName, setInterval(tick, periodMs));
-      tick();
-    }, dueTimeMs);
-    this._timeouts.set(timerName, timeoutId);
-  }
-  /**
-   * Run the warm-pass once. The standard boot path invokes this after
-   * `start()` so readiness either resolves or rejects.
-   */
-  async runReadyHandler() {
-    if (this._readyState !== "pending") return;
-    try {
-      await this.readyHandler();
-      this._readyState = "ready";
-      this._readyDeferred.resolve();
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this._readyState = "failed";
-      this._readyError = err;
-      this._readyDeferred.reject(err);
-      throw err;
-    }
-  }
-  async startHandler() {
-    if (this._abortController.signal.aborted) {
-      this._abortController = new AbortController();
-    }
-    await super.startHandler();
-  }
-  async stopHandler() {
-    await super.stopHandler();
-    this._abortController.abort();
-    for (const timeoutRef of this._timeouts.values()) clearTimeout(timeoutRef);
-    this._timeouts.clear();
-    for (const intervalRef of this._intervals.values()) clearInterval(intervalRef);
-    this._intervals.clear();
-    const inFlight = [...this._inFlight.values()];
-    this._inFlight.clear();
-    const timeoutMs = this.params.shutdownTimeoutMs;
-    if (timeoutMs === void 0) {
-      await Promise.allSettled(inFlight);
-      return;
-    }
-    await Promise.race([
-      Promise.allSettled(inFlight),
-      new Promise((resolve) => {
-        setTimeout(resolve, timeoutMs);
-      })
-    ]);
-  }
-  async whenReady() {
-    await this._readyDeferred.promise;
-  }
-};
+// src/boot/bootDappActors.ts
+import { bootActors } from "@ariestools/actor";
 
 // src/DappActor.ts
-import { creatable } from "@ariestools/sdk";
+import { PeriodicActor } from "@ariestools/actor";
+import { assertEx, creatable } from "@ariestools/sdk";
 
 // src/providers/capabilities.ts
 var ReadOnlyStoreError = class extends Error {
@@ -324,38 +173,22 @@ function failureStatusFields(prior, consecutiveFailures, error, now) {
 
 // src/DappActor.ts
 var DEFAULT_REDUCE_INTERVAL_MS = 5e3;
-var DEFAULT_FIRST_RUN_DELAY_MS = 2e3;
-var REDUCE_TIMER = "DappReduce";
-function createDeferred2() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  void promise.catch(() => {
-  });
-  return {
-    promise,
-    reject,
-    resolve
-  };
-}
 function withDefaultGenerationRoot(result) {
   if (result === void 0) return;
   if (result.generation === void 0 || result.generationRoot !== void 0) return result;
   return { ...result, generationRoot: HEAD_KEY };
 }
-var DappActor = class extends AbstractActor {
+var DappActor = class extends PeriodicActor {
   _data;
   _index;
   _state;
-  _consecutiveFailures = 0;
-  _firstPass = createDeferred2();
-  _firstPassSettled = false;
-  /** Consecutive reduce failures since the last success. */
-  get consecutiveFailures() {
-    return this._consecutiveFailures;
+  /** Dapp actors require a logger in the locator context (see {@link DappContext}). */
+  get logger() {
+    return assertEx(super.logger, () => `Logger is required in context for actor ${this.name}.`);
+  }
+  /** Reduce cadence: `reduceIntervalMs` names the interval in dapp configs. */
+  get intervalMs() {
+    return this.params.reduceIntervalMs ?? DEFAULT_REDUCE_INTERVAL_MS;
   }
   async createHandler() {
     await super.createHandler();
@@ -364,23 +197,27 @@ var DappActor = class extends AbstractActor {
     this._state = await this.locator.getInstance(DappStateStoreMoniker);
     this._index = await this.locator.getInstance(DappIndexStoreMoniker);
   }
-  async readyHandler() {
-    await this._firstPass.promise;
-  }
   async startHandler() {
     await super.startHandler();
-    const interval = this.params.reduceIntervalMs ?? DEFAULT_REDUCE_INTERVAL_MS;
-    const firstRunDelay = this.params.firstRunDelayMs ?? DEFAULT_FIRST_RUN_DELAY_MS;
-    this.registerTimer(REDUCE_TIMER, async () => {
-      await this.runReducePass();
-    }, firstRunDelay, interval);
     this.logger.info(
-      `DappActor started: reducer '${this.params.reducer.name}' every ${interval}ms (first run in ${firstRunDelay}ms)`
+      `DappActor started: reducer '${this.params.reducer.name}' every ${this.intervalMs}ms (first run in ${this.firstRunDelayMs}ms)`
     );
   }
-  async stopHandler() {
-    this.settleFirstPass(new Error("Actor stopped before first reduce pass completed"));
-    await super.stopHandler();
+  /** Failure side-channel: publish durable failure status (count already incremented). */
+  async onPassError(error) {
+    await this.safePublishStatus(void 0, error);
+  }
+  async runPass({ signal }) {
+    const result = await this.params.reducer.reduce({
+      data: this._data,
+      index: this._index,
+      logger: this.logger,
+      signal,
+      state: this._state
+    });
+    if (signal.aborted) return;
+    const progress = withDefaultGenerationRoot(result === void 0 ? void 0 : result);
+    await this.safePublishStatus(progress);
   }
   async publishStatusFromProgress(progress, error) {
     if (this.params.publishStatus === false) return;
@@ -391,44 +228,9 @@ var DappActor = class extends AbstractActor {
       prior = void 0;
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const fields = error === void 0 ? successStatusFields(progress, prior, now) : failureStatusFields(prior, this._consecutiveFailures, error, now);
+    const fields = error === void 0 ? successStatusFields(progress, prior, now) : failureStatusFields(prior, this.consecutiveFailures, error, now);
     await writeIndexerStatus(this._state, fields);
   }
-  async runReducePass() {
-    const signal = this.signal;
-    try {
-      const result = await this.params.reducer.reduce({
-        data: this._data,
-        index: this._index,
-        logger: this.logger,
-        signal,
-        state: this._state
-      });
-      if (signal.aborted) return;
-      const progress = withDefaultGenerationRoot(result === void 0 ? void 0 : result);
-      this._consecutiveFailures = 0;
-      await this.safePublishStatus(progress);
-      this.settleFirstPass();
-    } catch (error) {
-      if (signal.aborted) return;
-      const err = error instanceof Error ? error : new Error(String(error));
-      this._consecutiveFailures += 1;
-      await this.safePublishStatus(void 0, err);
-      this.settleFirstPass(err);
-      this.logger.error(
-        `Error in reduce pass for '${this.params.reducer.name}': ${err.message}`
-      );
-      const max = this.params.maxConsecutiveFailures;
-      if (max !== void 0 && this._consecutiveFailures >= max) {
-        this.logger.error(
-          `Reducer '${this.params.reducer.name}' failed ${this._consecutiveFailures} consecutive times; stopping actor`
-        );
-        setTimeout(() => {
-          void this.stop();
-        }, 0);
-      }
-    }
-  }
   async safePublishStatus(progress, error) {
     try {
       await this.publishStatusFromProgress(progress, error);
@@ -436,12 +238,6 @@ var DappActor = class extends AbstractActor {
       this.logger.error(`Failed to publish indexer status: ${String(statusError)}`);
     }
   }
-  settleFirstPass(error) {
-    if (this._firstPassSettled) return;
-    this._firstPassSettled = true;
-    if (error === void 0) this._firstPass.resolve();
-    else this._firstPass.reject(error);
-  }
 };
 __publicField(DappActor, "dependencies", [
   DappDataStoreMoniker,
@@ -454,36 +250,22 @@ DappActor = __decorateClass([
 
 // src/boot/bootDappActors.ts
 async function bootDappActors(locator, specs) {
-  const actors = [];
-  try {
-    for (const spec of specs) {
-      const params = {
-        locator,
-        name: spec.name,
-        reducer: spec.reducer,
-        ...spec.reduceIntervalMs !== void 0 && { reduceIntervalMs: spec.reduceIntervalMs },
-        ...spec.firstRunDelayMs !== void 0 && { firstRunDelayMs: spec.firstRunDelayMs },
-        ...spec.maxConsecutiveFailures !== void 0 && { maxConsecutiveFailures: spec.maxConsecutiveFailures },
-        ...spec.publishStatus !== void 0 && { publishStatus: spec.publishStatus },
-        ...spec.shutdownTimeoutMs !== void 0 && { shutdownTimeoutMs: spec.shutdownTimeoutMs }
-      };
-      const actor = await DappActor.create(params);
-      await actor.start();
-      actors.push(actor);
-      if (spec.runReady !== false) {
-        await actor.runReadyHandler();
-      }
-    }
-    return actors;
-  } catch (error) {
-    for (const actor of [...actors].reverse()) {
-      try {
-        await actor.stop();
-      } catch {
-      }
-    }
-    throw error;
-  }
+  return await bootActors(specs.map((spec) => {
+    const params = {
+      locator,
+      name: spec.name,
+      reducer: spec.reducer,
+      ...spec.reduceIntervalMs !== void 0 && { reduceIntervalMs: spec.reduceIntervalMs },
+      ...spec.firstRunDelayMs !== void 0 && { firstRunDelayMs: spec.firstRunDelayMs },
+      ...spec.maxConsecutiveFailures !== void 0 && { maxConsecutiveFailures: spec.maxConsecutiveFailures },
+      ...spec.publishStatus !== void 0 && { publishStatus: spec.publishStatus },
+      ...spec.shutdownTimeoutMs !== void 0 && { shutdownTimeoutMs: spec.shutdownTimeoutMs }
+    };
+    return {
+      create: () => DappActor.create(params),
+      ...spec.runReady !== void 0 && { runReady: spec.runReady }
+    };
+  }));
 }
 
 // src/locator/createDappLocator.ts
@@ -1923,7 +1705,6 @@ var noopReducer = {
   }
 };
 export {
-  AbstractActor,
   CACHE_CONTROL_IMMUTABLE,
   CACHE_CONTROL_REVALIDATE,
   CAS_PREFIX,