@cadenza.io/service 2.10.0 → 2.11.0

package/dist/index.mjs

@@ -4768,6 +4768,7 @@ var SignalController = class _SignalController {
 };
 
 // src/graph/controllers/GraphMetadataController.ts
+import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
@@ -5001,6 +5002,123 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       };
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
+    const actorSessionStateInsertTask = CadenzaService.get("dbInsertActorSessionState") ?? CadenzaService.get("Insert actor_session_state in CadenzaDB") ?? CadenzaService.createCadenzaDBInsertTask(
+      "actor_session_state",
+      {},
+      { concurrency: 100, isSubMeta: true }
+    );
+    const validateActorSessionStatePersistenceTask = CadenzaService.createMetaTask(
+      "Validate actor session state persistence",
+      (ctx) => {
+        if (ctx.errored || ctx.failed || ctx.__success !== true) {
+          throw new Error(
+            String(
+              ctx.__error ?? ctx.error ?? "actor_session_state persistence query failed"
+            )
+          );
+        }
+        const rowCount = Number(ctx.rowCount ?? 0);
+        if (!Number.isFinite(rowCount) || rowCount <= 0) {
+          throw new Error(
+            "actor_session_state persistence did not affect any rows (possible stale durable_version)"
+          );
+        }
+        return {
+          __success: true,
+          persisted: true,
+          actor_name: ctx.actor_name,
+          actor_version: ctx.actor_version,
+          actor_key: ctx.actor_key,
+          service_name: ctx.service_name,
+          durable_version: ctx.durable_version
+        };
+      },
+      "Enforces strict actor session persistence success contract.",
+      { isSubMeta: true, concurrency: 100 }
+    );
+    const insertAndValidateActorSessionStateTask = actorSessionStateInsertTask.then(
+      validateActorSessionStatePersistenceTask
+    );
+    CadenzaService.createMetaTask(
+      "Persist 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 durableVersion = Number(ctx.durable_version);
+        if (!actorName) {
+          throw new Error("actor_name is required for actor session persistence");
+        }
+        if (!actorKey) {
+          throw new Error("actor_key is required for actor session persistence");
+        }
+        if (!Number.isInteger(actorVersion) || actorVersion < 1) {
+          throw new Error("actor_version must be a positive integer");
+        }
+        if (!Number.isInteger(durableVersion) || durableVersion < 0) {
+          throw new Error("durable_version must be a non-negative integer");
+        }
+        if (typeof ctx.durable_state !== "object" || ctx.durable_state === null || Array.isArray(ctx.durable_state)) {
+          throw new Error("durable_state must be a non-null object");
+        }
+        const serviceName = CadenzaService.serviceRegistry.serviceName;
+        if (!serviceName) {
+          throw new Error("service_name is not available for actor session persistence");
+        }
+        let expiresAt = null;
+        if (ctx.expires_at !== void 0 && ctx.expires_at !== null) {
+          if (ctx.expires_at instanceof Date) {
+            expiresAt = ctx.expires_at.toISOString();
+          } else if (typeof ctx.expires_at === "string" && ctx.expires_at.trim().length > 0) {
+            expiresAt = ctx.expires_at;
+          } else {
+            throw new Error("expires_at must be null, Date, or non-empty string");
+          }
+        }
+        const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          ...ctx,
+          actor_name: actorName,
+          actor_key: actorKey,
+          actor_version: actorVersion,
+          durable_version: durableVersion,
+          expires_at: expiresAt,
+          service_name: serviceName,
+          queryData: {
+            data: {
+              actor_name: actorName,
+              actor_version: actorVersion,
+              actor_key: actorKey,
+              service_name: serviceName,
+              durable_state: ctx.durable_state,
+              durable_version: durableVersion,
+              expires_at: expiresAt,
+              updated: updatedAt
+            },
+            onConflict: {
+              target: [
+                "actor_name",
+                "actor_version",
+                "actor_key",
+                "service_name"
+              ],
+              action: {
+                do: "update",
+                set: {
+                  durable_state: "excluded",
+                  durable_version: "excluded",
+                  expires_at: "excluded",
+                  updated: "excluded"
+                },
+                where: "actor_session_state.durable_version <= excluded.durable_version"
+              }
+            }
+          }
+        };
+      },
+      "Validates and prepares actor_session_state payload for strict write-through persistence.",
+      { isSubMeta: true, concurrency: 100 }
+    ).then(insertAndValidateActorSessionStateTask).respondsTo(META_ACTOR_SESSION_STATE_PERSIST_INTENT);
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
       const intentName = ctx.data?.name;
       return {