@le-space/core 0.1.16 → 0.1.18

package/index.d.ts

@@ -334,6 +334,20 @@ declare function retainSuccessfulDeployments(args: {
         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);
@@ -918,6 +938,73 @@ async function classifyForgetHashes(args) {
     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;
@@ -944,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(),
@@ -964,25 +1054,40 @@ async function retainSuccessfulDeployments(args) {
     apiHost: args.apiHost,
     now: args.now
   });
-  let forgetResult = null;
-  let followUpForgetResults = [];
+  const forgetReason = args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`;
+  const forgetStageResults = [];
   let forgottenHashes = [];
   let outstandingForgetHashes = [];
   let forgetStatuses = {};
-  if (forgetHashes.length > 0) {
-    const initiallyOutstanding = await classifyForgetHashes({
-      hashes: forgetHashes,
+  let forgetResult = null;
+  const followUpForgetResults = [];
+  if (instanceForgetHashes.length > 0) {
+    const instanceStage = await executeForgetStage({
+      sender: args.sender,
+      hashes: instanceForgetHashes,
+      reason: forgetReason,
+      signer: args.signer,
+      hasher: args.hasher,
       fetch: args.fetch,
-      apiHost: args.apiHost
+      channel: args.channel,
+      apiHost: args.apiHost,
+      now: args.now
     });
-    forgottenHashes = initiallyOutstanding.forgottenHashes;
-    outstandingForgetHashes = initiallyOutstanding.outstandingForgetHashes;
-    forgetStatuses = initiallyOutstanding.statuses;
-    if (outstandingForgetHashes.length > 0) {
-      forgetResult = await forgetAlephMessages({
+    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: outstandingForgetHashes,
-        reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
+        hashes: dependentForgetHashes,
+        reason: forgetReason,
         signer: args.signer,
         hasher: args.hasher,
         fetch: args.fetch,
@@ -990,40 +1095,38 @@ async function retainSuccessfulDeployments(args) {
         apiHost: args.apiHost,
         now: args.now
       });
-      let postBatch = await classifyForgetHashes({
-        hashes: forgetHashes,
+      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
       });
-      forgottenHashes = postBatch.forgottenHashes;
-      outstandingForgetHashes = postBatch.outstandingForgetHashes;
-      forgetStatuses = postBatch.statuses;
-      if (outstandingForgetHashes.length > 0) {
-        for (const hash of outstandingForgetHashes) {
-          const result = await forgetAlephMessages({
-            sender: args.sender,
-            hashes: [hash],
-            reason: args.reason ?? `Prune successful deployments beyond retention limit ${keepCount}`,
-            signer: args.signer,
-            hasher: args.hasher,
-            fetch: args.fetch,
-            channel: args.channel,
-            apiHost: args.apiHost,
-            now: args.now
-          });
-          followUpForgetResults.push({ hash, result });
-        }
-        postBatch = await classifyForgetHashes({
-          hashes: forgetHashes,
-          fetch: args.fetch,
-          apiHost: args.apiHost
-        });
-        forgottenHashes = postBatch.forgottenHashes;
-        outstandingForgetHashes = postBatch.outstandingForgetHashes;
-        forgetStatuses = postBatch.statuses;
-      }
+      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,
@@ -1036,7 +1139,8 @@ async function retainSuccessfulDeployments(args) {
     outstandingForgetHashes,
     forgetStatuses,
     forgetResult,
-    followUpForgetResults
+    followUpForgetResults,
+    forgetStageResults
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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.16"
+    "@le-space/shared-types": "0.1.18"
   }
 }