@telecrypt-io/storage 0.5.23 → 0.5.26

package/dist/TeleCryptIOStorage.js

@@ -7,6 +7,7 @@ import { FileTooLargeError, RecoveryAlreadyConfiguredError, RecoveryRestoreError
 import { MAX_MEDIA_FILE_BYTES, MAX_MATRIX_IDENTIFIER_LENGTH, validateCanonicalMatrixUserId, validateMatrixDeviceId, validateMatrixEventId, validateMatrixRoomId, } from "./core/constants.js";
 import { raceWithAbort, readBoundedResponseBody } from "./core/http.js";
 import { validateName } from "./core/validation.js";
+import { isTreeDeleted } from "./deletion-markers.js";
 const recoveryMutationQueues = new WeakMap();
 const treeMutationQueues = new WeakMap();
 const TREE_SYNC_TIMEOUT_MS = 15000;
@@ -1244,6 +1245,8 @@ export class TeleCryptIOStorage {
         for (const room of rooms) {
             if (signal?.aborted)
                 throw new StorageError("operation cancelled");
+            if (isTreeDeleted(this.client, room.roomId))
+                continue;
             const tree = this.client.unstableGetFileTreeSpace(room.roomId);
             if (tree)
                 trees.push(this.decorateTreeSpace(tree));
@@ -1373,6 +1376,8 @@ export class TeleCryptIOStorage {
         }, signal);
     }
     getTree(roomId) {
+        if (isTreeDeleted(this.client, roomId))
+            return null;
         const tree = this.client.unstableGetFileTreeSpace(roomId);
         return tree ? this.decorateTreeSpace(tree) : null;
     }

package/dist/core/operations.js

@@ -18,6 +18,7 @@ import { FileTooLargeError, MutationPartialError, MutationOutcomeUnknownError, N
 import { waitForCondition } from "./poll.js";
 import { validateMatrixEventId } from "./constants.js";
 import { validateName } from "./validation.js";
+import { getDeletedTreeIds, isFileDeleted, isTreeDeleted, markFileDeleted, markTreeDeleted, } from "../deletion-markers.js";
 /**
  * Production Synapse enforces the built-in rc_messages budget (per-account
  * burst 10, refill 1/5s) on every room/state mutation the tree operations
@@ -175,12 +176,27 @@ async function resolveTree(storage, treeId, signal) {
         throw new StorageError("storage space not found");
     }
 }
+function isMarkedTreeDeleted(storage, treeId) {
+    if (typeof storage.getClient !== "function")
+        return false;
+    return isTreeDeleted(storage.getClient(), treeId);
+}
+function isMarkedFileDeleted(storage, treeId, fileId) {
+    if (typeof storage.getClient !== "function")
+        return false;
+    return isFileDeleted(storage.getClient(), treeId, fileId);
+}
 /** As `resolveTree`, but for a specific file within an already-resolved
  * vault or folder — covers the same settling window for a file another
  * process/session just uploaded. */
-async function resolveFile(tree, fileId, signal) {
+async function resolveFile(storage, tree, fileId, signal) {
+    if (signal?.aborted)
+        throw new StorageError("operation cancelled");
+    if (isMarkedFileDeleted(storage, tree.id, fileId)) {
+        throw new StorageError("file not found");
+    }
     try {
-        return await waitForCondition(() => tree.getFile(fileId), { timeoutMs: 15000, signal });
+        return await waitForCondition(() => (isMarkedFileDeleted(storage, tree.id, fileId) ? null : tree.getFile(fileId)), { timeoutMs: 15000, signal });
     }
     catch {
         if (signal?.aborted)
@@ -225,12 +241,15 @@ function snapshotTreeSpaces(root, tooLargeMessage = "storage tree is too large")
  * observe each result before removing their containing room.  This also
  * prevents a folder/vault delete from silently deleting a nested shared tree.
  */
-function assertTreeEmptyForDeletion(tree, spaces) {
+function assertTreeEmptyForDeletion(storage, tree, spaces) {
     if (spaces.length !== 1)
         throw new NonEmptyTreeError(tree.id);
     let files;
     try {
-        files = tree.listAllFiles();
+        files = tree
+            .listAllFiles()
+            .filter((file) => !isMarkedFileDeleted(storage, tree.id, file.id) &&
+            !isConfirmedDeletedFile(storage.getClient(), tree.id, file));
     }
     catch {
         throw new StorageError("could not enumerate storage files safely");
@@ -315,6 +334,26 @@ function isActiveRelationEvent(event) {
         !Array.isArray(content) &&
         Object.keys(content).length > 0);
 }
+/**
+ * A deleted MSC3089 branch is represented by an authoritative empty state
+ * event. Inactive branches with metadata are historical versions, and a
+ * missing or malformed state cannot prove that the file was deleted.
+ */
+function isConfirmedDeletedFile(client, treeId, file) {
+    if (file.isActive)
+        return false;
+    const stateEvents = readRelationEvents(client, treeId, UNSTABLE_MSC3089_BRANCH.name, file.id);
+    if (!stateEvents || stateEvents.length !== 1)
+        return false;
+    const stateEvent = stateEvents[0];
+    if (relationStateKey(stateEvent) !== file.id)
+        return false;
+    const content = stateEvent.getContent?.();
+    return (typeof content === "object" &&
+        content !== null &&
+        !Array.isArray(content) &&
+        Object.keys(content).length === 0);
+}
 /**
  * Deletion is intentionally narrower than MSC3089TreeSpace.delete(): a local
  * child graph is not proof that the rooms are exclusively owned by this tree.
@@ -480,8 +519,6 @@ async function relinkExternalParents(storage, rootId, externalParents, signal) {
         }
     }
 }
-const deletedTreeIds = new WeakMap();
-const deletedRoomIds = new WeakMap();
 function isGoneError(error) {
     return (error instanceof MatrixError &&
         (error.errcode === "M_NOT_FOUND" || error.errcode === "M_UNKNOWN"));
@@ -540,12 +577,7 @@ async function deleteRoomDeterministically(storage, roomId, signal) {
             throw error;
     }
     removeRoomFromLocalStore(client, roomId);
-    let deleted = deletedRoomIds.get(client);
-    if (!deleted) {
-        deleted = new Set();
-        deletedRoomIds.set(client, deleted);
-    }
-    deleted.add(roomId);
+    markTreeDeleted(client, roomId);
 }
 /**
  * The SDK normally evicts a room as part of forget(). Keep the local-store
@@ -693,6 +725,8 @@ export async function listPendingInvites(storage, options) {
         const invites = [];
         for (const room of rooms) {
             ensureOperationActive(signal);
+            if (isMarkedTreeDeleted(storage, room.roomId))
+                continue;
             if (room.getMyMembership() !== "invite")
                 continue;
             if (hasActiveSpaceParent(room))
@@ -991,7 +1025,9 @@ export async function listFiles(storage, treeId, options) {
         try {
             await storage.refreshRoomState(treeId, { signal });
             ensureOperationActive(signal);
-            const files = tree.listFiles();
+            const files = tree
+                .listFiles()
+                .filter((file) => !isMarkedFileDeleted(storage, tree.id, file.id));
             if (files.length > MAX_LIST_ITEMS)
                 throw new StorageError("file list is too large");
             return files.map((f) => ({ id: f.id, name: f.getName() }));
@@ -1011,7 +1047,9 @@ export async function listSubfolders(storage, parentId, options) {
         const tree = await resolveTree(storage, parentId, signal);
         await storage.refreshRoomState(parentId, { signal });
         ensureOperationActive(signal);
-        const directories = tree.getDirectories();
+        const directories = tree
+            .getDirectories()
+            .filter((directory) => !isMarkedTreeDeleted(storage, directory.id));
         if (directories.length > MAX_LIST_ITEMS)
             throw new StorageError("folder list is too large");
         return directories.map((d) => ({ id: d.id, name: d.room.name }));
@@ -1084,21 +1122,16 @@ export async function renameFolder(storage, folderId, name, options) {
 async function deleteTree(storage, treeId, options) {
     const operation = createOperationDeadline(options);
     const client = storage.getClient();
-    let deleted = deletedTreeIds.get(client);
-    if (!deleted) {
-        deleted = new Set();
-        deletedTreeIds.set(client, deleted);
-    }
     try {
         ensureOperationActive(operation.signal);
         const pending = withTreeMutation(client, async () => {
-            if (deleted.has(treeId))
+            if (isTreeDeleted(client, treeId))
                 return { id: treeId, deleted: true };
             const tree = await resolveTree(storage, treeId, operation.signal);
             // Read reconciliation state after this operation reaches the single
             // client queue; a preceding delete may have populated the set while we
             // were waiting for its turn.
-            const removedRooms = deletedRoomIds.get(client) ?? new Set();
+            const removedRooms = getDeletedTreeIds(client);
             let graph;
             try {
                 // Re-read every locally visible room before taking the immutable graph
@@ -1110,12 +1143,11 @@ async function deleteTree(storage, treeId, options) {
                 const ids = new Set(activeSpaces.map((space) => space.id));
                 if (!ids.has(tree.id)) {
                     if (removedRooms.has(tree.id)) {
-                        deleted.add(treeId);
                         return { id: treeId, deleted: true };
                     }
                     throw new StorageError("delete graph is unsafe");
                 }
-                assertTreeEmptyForDeletion(tree, activeSpaces);
+                assertTreeEmptyForDeletion(storage, tree, activeSpaces);
                 graph = validateDeletionGraph(client, tree, ids, removedRooms);
             }
             catch (error) {
@@ -1165,7 +1197,6 @@ async function deleteTree(storage, treeId, options) {
                     throw error;
                 throw new StorageError("delete failed");
             }
-            deleted.add(treeId);
             return { id: treeId, deleted: true };
         }, operation.signal);
         return await raceOperationDeadline(operation, pending, "mutation");
@@ -1186,7 +1217,7 @@ export async function renameFile(storage, treeId, fileId, name, options) {
     validateName(name, "file name");
     return withOperationDeadline(options, async (signal) => {
         const tree = await resolveTree(storage, treeId, signal);
-        const branch = await resolveFile(tree, fileId, signal);
+        const branch = await resolveFile(storage, tree, fileId, signal);
         try {
             const client = typeof storage.getClient === "function" ? storage.getClient() : undefined;
             await withRateLimitRetry(() => client ? withMatrixMutationAbort(client, () => branch.setName(name), signal) : branch.setName(name), signal);
@@ -1291,7 +1322,7 @@ async function deleteFileMedia(storage, mediaIds, signal) {
 export async function deleteFile(storage, treeId, fileId, options) {
     return withOperationDeadline(options, async (signal) => {
         const tree = await resolveTree(storage, treeId, signal);
-        const branch = await resolveFile(tree, fileId, signal);
+        const branch = await resolveFile(storage, tree, fileId, signal);
         const versions = await resolveFileVersions(branch, signal);
         const mediaIds = [...new Set(versions.map(({ mediaId }) => mediaId))];
         await deleteFileMedia(storage, mediaIds, signal);
@@ -1328,6 +1359,9 @@ export async function deleteFile(storage, treeId, fileId, options) {
             const detail = "Matrix deletion completed but the inactive file state could not be verified";
             throw new MutationPartialError("delete file", completedIds, detail);
         }
+        for (const { branch: version } of versions) {
+            markFileDeleted(storage.getClient(), tree.id, version.id);
+        }
         ensureOperationActive(signal);
         return { id: fileId, deleted: true };
     }, "mutation");
@@ -1370,7 +1404,7 @@ export async function uploadFile(storage, treeId, name, bytes, mimetype, options
 export async function downloadFile(storage, treeId, fileId, options) {
     return withOperationDeadline(options, async (signal) => {
         const tree = await resolveTree(storage, treeId, signal);
-        const branch = await resolveFile(tree, fileId, signal);
+        const branch = await resolveFile(storage, tree, fileId, signal);
         let result;
         try {
             result = await storage.downloadFile(branch, signal);
@@ -1404,7 +1438,7 @@ function tsToIso(ts) {
 export async function getFileDetails(storage, treeId, fileId, options) {
     return withOperationDeadline(options, async (signal) => {
         const tree = await resolveTree(storage, treeId, signal);
-        const branch = await resolveFile(tree, fileId, signal);
+        const branch = await resolveFile(storage, tree, fileId, signal);
         const name = branch.getName();
         let mimetype = null;
         let size = null;

package/dist/deletion-markers.d.ts

@@ -0,0 +1,8 @@
+import type { MatrixClient } from "matrix-js-sdk";
+/** Records a confirmed room deletion for this MatrixClient's lifetime. */
+export declare function markTreeDeleted(client: MatrixClient, roomId: string): void;
+/** Records a confirmed file deletion for this MatrixClient's lifetime. */
+export declare function markFileDeleted(client: MatrixClient, roomId: string, fileId: string): void;
+export declare function isTreeDeleted(client: MatrixClient, roomId: string): boolean;
+export declare function getDeletedTreeIds(client: MatrixClient): ReadonlySet<string>;
+export declare function isFileDeleted(client: MatrixClient, roomId: string, fileId: string): boolean;

package/dist/deletion-markers.js

@@ -0,0 +1,32 @@
+const markersByClient = new WeakMap();
+function markersFor(client) {
+    let markers = markersByClient.get(client);
+    if (!markers) {
+        markers = { trees: new Set(), files: new Map() };
+        markersByClient.set(client, markers);
+    }
+    return markers;
+}
+/** Records a confirmed room deletion for this MatrixClient's lifetime. */
+export function markTreeDeleted(client, roomId) {
+    markersFor(client).trees.add(roomId);
+}
+/** Records a confirmed file deletion for this MatrixClient's lifetime. */
+export function markFileDeleted(client, roomId, fileId) {
+    const markers = markersFor(client);
+    let files = markers.files.get(roomId);
+    if (!files) {
+        files = new Set();
+        markers.files.set(roomId, files);
+    }
+    files.add(fileId);
+}
+export function isTreeDeleted(client, roomId) {
+    return markersFor(client).trees.has(roomId);
+}
+export function getDeletedTreeIds(client) {
+    return markersFor(client).trees;
+}
+export function isFileDeleted(client, roomId, fileId) {
+    return markersFor(client).files.get(roomId)?.has(fileId) ?? false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telecrypt-io/storage",
-  "version": "0.5.23",
+  "version": "0.5.26",
   "license": "BUSL-1.1",
   "type": "module",
   "packageManager": "npm@11.19.0",