@cadenza.io/service 2.19.1 → 2.20.0

package/dist/index.mjs

@@ -8549,6 +8549,8 @@ var ServiceRegistry = class _ServiceRegistry {
         }
       }
     }
+    const hasExplicitSignalRoutingRows = signalToTaskMaps.length > 0;
+    const hasExplicitIntentRoutingRows = intentToTaskMaps.length > 0;
     const latestManifestSnapshots = selectLatestServiceManifestSnapshots(manifestSnapshots);
     const explodedManifest = explodeServiceManifestSnapshots(
       latestManifestSnapshots
@@ -8629,26 +8631,30 @@ var ServiceRegistry = class _ServiceRegistry {
         row.task_version ?? 1
       ).trim()}`
     );
-    pushUnique(
-      explodedManifest.signalToTaskMaps,
-      signalToTaskMaps,
-      seenSignalMaps,
-      (row) => `${String(row.signal_name ?? "").trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
-    pushUnique(
-      explodedManifest.intentToTaskMaps,
-      intentToTaskMaps,
-      seenIntentMaps,
-      (row) => `${String(row.intent_name ?? "").trim()}|${String(
-        row.service_name ?? ""
-      ).trim()}|${String(row.task_name ?? "").trim()}|${String(
-        row.task_version ?? 1
-      ).trim()}`
-    );
+    if (!hasExplicitSignalRoutingRows) {
+      pushUnique(
+        explodedManifest.signalToTaskMaps,
+        signalToTaskMaps,
+        seenSignalMaps,
+        (row) => `${String(row.signal_name ?? "").trim()}|${String(
+          row.service_name ?? ""
+        ).trim()}|${String(row.task_name ?? "").trim()}|${String(
+          row.task_version ?? 1
+        ).trim()}`
+      );
+    }
+    if (!hasExplicitIntentRoutingRows) {
+      pushUnique(
+        explodedManifest.intentToTaskMaps,
+        intentToTaskMaps,
+        seenIntentMaps,
+        (row) => `${String(row.intent_name ?? "").trim()}|${String(
+          row.service_name ?? ""
+        ).trim()}|${String(row.task_name ?? "").trim()}|${String(
+          row.task_version ?? 1
+        ).trim()}`
+      );
+    }
     return {
       serviceInstances,
       serviceInstanceTransports,
@@ -9251,16 +9257,35 @@ var ServiceRegistry = class _ServiceRegistry {
     const authorityFullSyncResponderTask = CadenzaService.createMetaTask(
       BOOTSTRAP_FULL_SYNC_RESPONDER_TASK_NAME,
       async (ctx) => {
+        const queryOptionalAuthorityRoutingRows = async (tableName) => {
+          try {
+            return await DatabaseController.instance.queryAuthorityTableRows(
+              tableName
+            );
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes(
+              `Table '${tableName}' is not registered on the CadenzaDB PostgresActor`
+            )) {
+              return [];
+            }
+            throw error;
+          }
+        };
         const [
           serviceInstances,
           serviceInstanceTransports,
-          serviceManifests
+          serviceManifests,
+          signalToTaskMaps,
+          intentToTaskMaps
         ] = await Promise.all([
           DatabaseController.instance.queryAuthorityTableRows("service_instance"),
           DatabaseController.instance.queryAuthorityTableRows(
             "service_instance_transport"
           ),
-          DatabaseController.instance.queryAuthorityTableRows("service_manifest")
+          DatabaseController.instance.queryAuthorityTableRows("service_manifest"),
+          queryOptionalAuthorityRoutingRows("signal_to_task_map"),
+          queryOptionalAuthorityRoutingRows("intent_to_task_map")
         ]);
         return {
           ...ctx,
@@ -9268,7 +9293,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
             serviceInstanceTransports,
-            serviceManifests
+            serviceManifests,
+            signalToTaskMaps,
+            intentToTaskMaps
           })
         };
       },
@@ -15928,12 +15955,13 @@ var RuntimeValidationController = class _RuntimeValidationController {
 // src/graph/controllers/registerActorSessionPersistence.ts
 import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
 var ACTOR_SESSION_STATE_PERSIST_CONCURRENCY = 20;
+var META_ACTOR_SESSION_STATE_HYDRATE_INTENT = "meta-actor-session-state-hydrate";
 var ACTOR_SESSION_TRACE_ENABLED4 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
 function shouldAssumeSuccessfulActorSessionRowCount(ctx) {
   return ctx.__success === true && ctx.rowCount === void 0 && ctx.__status === "success" && ctx.__serviceName === "CadenzaDB" && ctx.__localTaskName === "Insert actor_session_state in CadenzaDB";
 }
 function registerActorSessionPersistenceTasks() {
-  if (CadenzaService.get("Persist actor session state")) {
+  if (CadenzaService.get("Persist actor session state") && CadenzaService.get("Hydrate actor session state")) {
     return;
   }
   const localActorSessionTaskOptions = {
@@ -15950,6 +15978,14 @@ function registerActorSessionPersistenceTasks() {
       isSubMeta: true
     }
   );
+  const actorSessionStateQueryTask = CadenzaService.getLocalCadenzaDBQueryTask("actor_session_state") ?? CadenzaService.get("dbQueryActorSessionState") ?? CadenzaService.get("Query actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBQueryTask(
+    "actor_session_state",
+    {},
+    {
+      concurrency: ACTOR_SESSION_STATE_PERSIST_CONCURRENCY,
+      isSubMeta: true
+    }
+  );
   const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
     "Validate actor session state persistence",
     (ctx) => {
@@ -15983,6 +16019,103 @@ function registerActorSessionPersistenceTasks() {
   const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
     validateActorSessionStatePersistenceTask
   );
+  const validateActorSessionStateHydrationTask = CadenzaService.createMetaTask(
+    "Validate actor session state hydration",
+    (ctx) => {
+      if (ctx.errored || ctx.failed || ctx.__success !== true) {
+        throw new Error(
+          String(
+            ctx.__error ?? ctx.error ?? "actor_session_state hydration query failed"
+          )
+        );
+      }
+      const row = ctx.actorSessionState && typeof ctx.actorSessionState === "object" && !Array.isArray(ctx.actorSessionState) ? ctx.actorSessionState : null;
+      if (!row) {
+        return {
+          __success: true,
+          hydrated: false
+        };
+      }
+      const expiresAt = typeof row.expiresAt === "string" ? row.expiresAt : typeof row.expires_at === "string" ? row.expires_at : null;
+      const expiresAtMs = expiresAt ? Date.parse(expiresAt) : Number.NaN;
+      if (Number.isFinite(expiresAtMs) && expiresAtMs <= Date.now()) {
+        return {
+          __success: true,
+          hydrated: false
+        };
+      }
+      const durableState = row.durableState ?? row.durable_state ?? null;
+      const durableVersion = Number(
+        row.durableVersion ?? row.durable_version ?? Number.NaN
+      );
+      if (typeof durableState !== "object" || durableState === null || Array.isArray(durableState)) {
+        throw new Error("actor_session_state durable_state must be a non-null object");
+      }
+      if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+        throw new Error(
+          "actor_session_state durable_version must be a non-negative integer"
+        );
+      }
+      return {
+        __success: true,
+        hydrated: true,
+        actor_name: row.actorName ?? row.actor_name,
+        actor_version: row.actorVersion ?? row.actor_version,
+        actor_key: row.actorKey ?? row.actor_key,
+        service_name: row.serviceName ?? row.service_name,
+        durable_state: durableState,
+        durable_version: durableVersion
+      };
+    },
+    "Validates and normalizes hydrated actor_session_state rows.",
+    localActorSessionTaskOptions
+  );
+  const queryAndValidateActorSessionStateTask = actorSessionStateQueryTask.then(
+    validateActorSessionStateHydrationTask
+  );
+  CadenzaService.createMetaTask(
+    "Hydrate actor session state",
+    (ctx) => {
+      const actorName = typeof ctx.actor_name === "string" ? ctx.actor_name.trim() : "";
+      const actorKey = typeof ctx.actor_key === "string" ? ctx.actor_key.trim() : "";
+      const actorVersion = Number(ctx.actor_version ?? 1);
+      const serviceName = CadenzaService.serviceRegistry.serviceName;
+      if (!actorName) {
+        throw new Error("actor_name is required for actor session hydration");
+      }
+      if (!actorKey) {
+        throw new Error("actor_key is required for actor session hydration");
+      }
+      if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+        throw new Error("actor_version must be a positive integer");
+      }
+      if (!serviceName) {
+        throw new Error("service_name is not available for actor session hydration");
+      }
+      return {
+        ...ctx,
+        actor_name: actorName,
+        actor_key: actorKey,
+        actor_version: actorVersion,
+        service_name: serviceName,
+        queryData: {
+          filter: {
+            actor_name: actorName,
+            actor_version: actorVersion,
+            actor_key: actorKey,
+            service_name: serviceName,
+            deleted: false
+          },
+          queryMode: "one",
+          sort: {
+            updated: "desc"
+          }
+        }
+      };
+    },
+    "Builds a one-row actor_session_state lookup for lazy actor hydration.",
+    localActorSessionTaskOptions
+  ).then(queryAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_HYDRATE_INTENT);
   CadenzaService.createMetaTask(
     "Persist actor session state",
     (ctx) => {
@@ -20065,6 +20198,10 @@ function resolveInquiryFailureError(inquiry, value, depth = 3, seen = /* @__PURE
   }
   return `Inquiry '${inquiry}' did not complete successfully`;
 }
+function normalizePositiveInteger2(value, fallback) {
+  const normalized = Number(value);
+  return Number.isInteger(normalized) && normalized > 0 ? normalized : fallback;
+}
 var DEFAULT_DEPUTY_TASK_CONCURRENCY = 50;
 var DEFAULT_DEPUTY_TASK_TIMEOUT_MS = 12e4;
 var DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY = 50;
@@ -21898,11 +22035,84 @@ var CadenzaService = class {
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
-    return Cadenza.createActor(spec, options);
+    return Cadenza.createActor(
+      spec,
+      this.withActorSessionHydration(
+        spec,
+        options
+      )
+    );
   }
   static createActorFromDefinition(definition, options = {}) {
     this.bootstrap();
-    return Cadenza.createActorFromDefinition(definition, options);
+    return Cadenza.createActorFromDefinition(
+      definition,
+      this.withActorSessionHydration(
+        {
+          name: definition.name,
+          description: definition.description,
+          defaultKey: definition.defaultKey,
+          kind: definition.kind,
+          loadPolicy: definition.loadPolicy,
+          writeContract: definition.writeContract,
+          consistencyProfile: definition.consistencyProfile,
+          retry: definition.retry,
+          idempotency: definition.idempotency,
+          session: definition.session,
+          runtimeReadGuard: definition.runtimeReadGuard,
+          key: definition.key,
+          state: definition.state,
+          taskBindings: definition.tasks,
+          initState: definition.state?.durable?.initState ?? definition.state?.durable?.initialState
+        },
+        options
+      )
+    );
+  }
+  static withActorSessionHydration(spec, options) {
+    if (options.hydrateDurableState || spec.session?.persistDurableState !== true) {
+      return options;
+    }
+    const actorName = String(spec.name ?? "").trim();
+    const actorVersion = 1;
+    const timeoutMs = normalizePositiveInteger2(
+      spec.session?.persistenceTimeoutMs,
+      5e3
+    );
+    return {
+      ...options,
+      hydrateDurableState: async (actorKey) => {
+        registerActorSessionPersistenceTasks();
+        const response = await Cadenza.inquire(
+          META_ACTOR_SESSION_STATE_HYDRATE_INTENT,
+          {
+            actor_name: actorName,
+            actor_version: actorVersion,
+            actor_key: actorKey
+          },
+          {
+            timeout: timeoutMs,
+            requireComplete: true,
+            rejectOnTimeout: true
+          }
+        );
+        if (!response || typeof response !== "object" || response.__success !== true) {
+          throw new Error(
+            resolveInquiryFailureError(
+              META_ACTOR_SESSION_STATE_HYDRATE_INTENT,
+              response
+            )
+          );
+        }
+        if (response.hydrated !== true) {
+          return null;
+        }
+        return {
+          durableState: response.durable_state,
+          durableVersion: Number(response.durable_version)
+        };
+      }
+    };
   }
   /**
    * Creates and registers a new task with the provided name, function, and optional details.