@le-space/core 0.1.15 → 0.1.17

package/index.d.ts

@@ -320,6 +320,9 @@ declare function retainSuccessfulDeployments(args: {
     retainedRecords: RetentionRecord[];
     prunedRecords: RetentionRecord[];
     forgetHashes: string[];
+    forgottenHashes: string[];
+    outstandingForgetHashes: string[];
+    forgetStatuses: Record<string, string>;
     forgetResult: {
         sender: string;
         itemHash: string;
@@ -327,6 +330,24 @@ declare function retainSuccessfulDeployments(args: {
         httpStatus: number;
         status: _shared_aleph_shared_types.MessageStatus;
     } | null;
+    followUpForgetResults: {
+        hash: string;
+        result: Awaited<ReturnType<typeof forgetAlephMessages>>;
+    }[];
+    forgetStageResults: {
+        stage: "instances" | "dependents";
+        hashes: string[];
+        skipped?: boolean;
+        skippedReason?: string;
+        forgottenHashes: string[];
+        outstandingForgetHashes: string[];
+        statuses: Record<string, string>;
+        forgetResult: Awaited<ReturnType<typeof forgetAlephMessages>> | null;
+        followUpForgetResults: Array<{
+            hash: string;
+            result: Awaited<ReturnType<typeof forgetAlephMessages>>;
+        }>;
+    }[];
 }>;
 
 declare function createPortForwardAggregateContent(args: {

package/index.js

@@ -841,6 +841,26 @@ function retentionRecordId(record) {
 function hashesFromRetentionRecord(record) {
   return [record.instance_item_hash, record.rootfs_item_hash, record.site_item_hash].filter(Boolean);
 }
+function uniqueHashes(hashes) {
+  return [...new Set(hashes.filter(Boolean))];
+}
+function dependentHashesFromRetentionRecord(record) {
+  return [record.rootfs_item_hash, record.site_item_hash].filter(Boolean);
+}
+function splitForgetStages(args) {
+  const instanceForgetHashes = uniqueHashes(args.prunedRecords.map((record) => record.instance_item_hash)).filter(
+    (hash) => !args.retainedHashes.has(hash)
+  );
+  const dependentForgetHashes = uniqueHashes([
+    ...args.prunedRecords.flatMap(dependentHashesFromRetentionRecord),
+    ...args.extraForgetHashes
+  ]).filter((hash) => !args.retainedHashes.has(hash) && !instanceForgetHashes.includes(hash));
+  return {
+    instanceForgetHashes,
+    dependentForgetHashes,
+    orderedForgetHashes: [...instanceForgetHashes, ...dependentForgetHashes]
+  };
+}
 async function fetchAggregateKey(args) {
   const requestUrl = new URL(`/api/v0/aggregates/${args.address}.json`, args.apiHost ?? "https://api2.aleph.im");
   requestUrl.searchParams.set("keys", args.key);
@@ -893,6 +913,98 @@ async function publishAggregateKey(args) {
     httpStatus
   };
 }
+async function fetchMessageStatus(args) {
+  const requestUrl = new URL(`/api/v0/messages/${args.hash}`, args.apiHost ?? "https://api2.aleph.im");
+  const response = await args.fetch(requestUrl.toString(), { cache: "no-cache" });
+  if (response.status === 404) return "missing";
+  if (!response.ok) return "unknown";
+  const payload = await response.json();
+  return asString3(payload?.status) ?? "unknown";
+}
+async function classifyForgetHashes(args) {
+  const statuses = {};
+  for (const hash of args.hashes) {
+    statuses[hash] = await fetchMessageStatus({
+      hash,
+      fetch: args.fetch,
+      apiHost: args.apiHost
+    });
+  }
+  const forgottenHashes = args.hashes.filter((hash) => statuses[hash] === "forgotten");
+  const outstandingForgetHashes = args.hashes.filter((hash) => statuses[hash] !== "forgotten");
+  return {
+    forgottenHashes,
+    outstandingForgetHashes,
+    statuses
+  };
+}
+async function executeForgetStage(args) {
+  const stageHashes = uniqueHashes(args.hashes);
+  let forgetResult = null;
+  const followUpForgetResults = [];
+  if (stageHashes.length === 0) {
+    return {
+      hashes: stageHashes,
+      forgottenHashes: [],
+      outstandingForgetHashes: [],
+      statuses: {},
+      forgetResult,
+      followUpForgetResults
+    };
+  }
+  let classified = await classifyForgetHashes({
+    hashes: stageHashes,
+    fetch: args.fetch,
+    apiHost: args.apiHost
+  });
+  if (classified.outstandingForgetHashes.length > 0) {
+    forgetResult = await forgetAlephMessages({
+      sender: args.sender,
+      hashes: classified.outstandingForgetHashes,
+      reason: args.reason,
+      signer: args.signer,
+      hasher: args.hasher,
+      fetch: args.fetch,
+      channel: args.channel,
+      apiHost: args.apiHost,
+      now: args.now
+    });
+    classified = await classifyForgetHashes({
+      hashes: stageHashes,
+      fetch: args.fetch,
+      apiHost: args.apiHost
+    });
+    if (classified.outstandingForgetHashes.length > 0) {
+      for (const hash of classified.outstandingForgetHashes) {
+        const result = await forgetAlephMessages({
+          sender: args.sender,
+          hashes: [hash],
+          reason: args.reason,
+          signer: args.signer,
+          hasher: args.hasher,
+          fetch: args.fetch,
+          channel: args.channel,
+          apiHost: args.apiHost,
+          now: args.now
+        });
+        followUpForgetResults.push({ hash, result });
+      }
+      classified = await classifyForgetHashes({
+        hashes: stageHashes,
+        fetch: args.fetch,
+        apiHost: args.apiHost
+      });
+    }
+  }
+  return {
+    hashes: stageHashes,
+    forgottenHashes: classified.forgottenHashes,
+    outstandingForgetHashes: classified.outstandingForgetHashes,
+    statuses: classified.statuses,
+    forgetResult,
+    followUpForgetResults
+  };
+}
 async function retainSuccessfulDeployments(args) {
   const keepCount = Math.max(0, Number.parseInt(String(args.keepCount ?? 0), 10) || 0);
   const aggregateKey = asString3(args.aggregateKey) ?? SUCCESSFUL_DEPLOYMENTS_AGGREGATE_KEY;
@@ -919,10 +1031,13 @@ async function retainSuccessfulDeployments(args) {
   const retainedRecords = keepCount > 0 ? uniqueRecords.slice(0, keepCount) : [];
   const prunedRecords = keepCount > 0 ? uniqueRecords.slice(keepCount) : uniqueRecords;
   const retainedHashes = new Set(retainedRecords.flatMap(hashesFromRetentionRecord));
-  const extraForgetHashes = [...new Set((args.extraForgetHashes ?? []).filter(Boolean))];
-  const forgetHashes = [.../* @__PURE__ */ new Set([...prunedRecords.flatMap(hashesFromRetentionRecord), ...extraForgetHashes])].filter(
-    (hash) => !retainedHashes.has(hash)
-  );
+  const extraForgetHashes = uniqueHashes(args.extraForgetHashes ?? []);
+  const { instanceForgetHashes, dependentForgetHashes, orderedForgetHashes } = splitForgetStages({
+    prunedRecords,
+    extraForgetHashes,
+    retainedHashes
+  });
+  const forgetHashes = orderedForgetHashes;
   const aggregateContent = {
     keep: keepCount,
     updated_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -939,12 +1054,18 @@ async function retainSuccessfulDeployments(args) {
     apiHost: args.apiHost,
     now: args.now
   });
+  const forgetReason = args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`;
+  const forgetStageResults = [];
+  let forgottenHashes = [];
+  let outstandingForgetHashes = [];
+  let forgetStatuses = {};
   let forgetResult = null;
-  if (forgetHashes.length > 0) {
-    forgetResult = await forgetAlephMessages({
+  const followUpForgetResults = [];
+  if (instanceForgetHashes.length > 0) {
+    const instanceStage = await executeForgetStage({
       sender: args.sender,
-      hashes: forgetHashes,
-      reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
+      hashes: instanceForgetHashes,
+      reason: forgetReason,
       signer: args.signer,
       hasher: args.hasher,
       fetch: args.fetch,
@@ -952,7 +1073,60 @@ async function retainSuccessfulDeployments(args) {
       apiHost: args.apiHost,
       now: args.now
     });
+    forgetStageResults.push({ stage: "instances", ...instanceStage });
+    forgottenHashes.push(...instanceStage.forgottenHashes);
+    outstandingForgetHashes.push(...instanceStage.outstandingForgetHashes);
+    forgetStatuses = { ...forgetStatuses, ...instanceStage.statuses };
+    if (!forgetResult && instanceStage.forgetResult) {
+      forgetResult = instanceStage.forgetResult;
+    }
+    followUpForgetResults.push(...instanceStage.followUpForgetResults);
+  }
+  if (dependentForgetHashes.length > 0) {
+    if (outstandingForgetHashes.length === 0) {
+      const dependentStage = await executeForgetStage({
+        sender: args.sender,
+        hashes: dependentForgetHashes,
+        reason: forgetReason,
+        signer: args.signer,
+        hasher: args.hasher,
+        fetch: args.fetch,
+        channel: args.channel,
+        apiHost: args.apiHost,
+        now: args.now
+      });
+      forgetStageResults.push({ stage: "dependents", ...dependentStage });
+      forgottenHashes.push(...dependentStage.forgottenHashes);
+      outstandingForgetHashes.push(...dependentStage.outstandingForgetHashes);
+      forgetStatuses = { ...forgetStatuses, ...dependentStage.statuses };
+      if (!forgetResult && dependentStage.forgetResult) {
+        forgetResult = dependentStage.forgetResult;
+      }
+      followUpForgetResults.push(...dependentStage.followUpForgetResults);
+    } else {
+      const dependentStageStatus = await classifyForgetHashes({
+        hashes: dependentForgetHashes,
+        fetch: args.fetch,
+        apiHost: args.apiHost
+      });
+      forgetStageResults.push({
+        stage: "dependents",
+        hashes: dependentForgetHashes,
+        skipped: true,
+        skippedReason: "Waiting for instance forget stage to complete before pruning dependent store items.",
+        forgottenHashes: dependentStageStatus.forgottenHashes,
+        outstandingForgetHashes: dependentStageStatus.outstandingForgetHashes,
+        statuses: dependentStageStatus.statuses,
+        forgetResult: null,
+        followUpForgetResults: []
+      });
+      forgottenHashes.push(...dependentStageStatus.forgottenHashes);
+      outstandingForgetHashes.push(...dependentStageStatus.outstandingForgetHashes);
+      forgetStatuses = { ...forgetStatuses, ...dependentStageStatus.statuses };
+    }
   }
+  forgottenHashes = uniqueHashes(forgottenHashes);
+  outstandingForgetHashes = uniqueHashes(outstandingForgetHashes);
   return {
     sender: args.sender,
     aggregateKey,
@@ -961,7 +1135,12 @@ async function retainSuccessfulDeployments(args) {
     retainedRecords,
     prunedRecords,
     forgetHashes,
-    forgetResult
+    forgottenHashes,
+    outstandingForgetHashes,
+    forgetStatuses,
+    forgetResult,
+    followUpForgetResults,
+    forgetStageResults
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/core",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Reusable Aleph deployment, runtime, and guest lifecycle logic.",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@le-space/shared-types": "0.1.15"
+    "@le-space/shared-types": "0.1.17"
   }
 }