@telecrypt-io/storage 0.5.22 → 0.5.25

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
@@ -31,6 +32,7 @@ const RATE_LIMIT_DEFAULT_DELAY_MS = 15_000;
 const RATE_LIMIT_MAX_DELAY_MS = 30_000;
 const RATE_LIMIT_MAX_TOTAL_DELAY_MS = 90_000;
 const MAX_DELETION_ROOMS = 4096;
+const DELETION_REFRESH_CONCURRENCY = 8;
 const MAX_DELETION_DEPTH = 128;
 const MAX_FILE_VERSION_CHAIN = 128;
 const MAX_LIST_ITEMS = 10000;
@@ -174,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)
@@ -224,12 +241,14 @@ 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));
     }
     catch {
         throw new StorageError("could not enumerate storage files safely");
@@ -249,6 +268,7 @@ async function refreshDeletionRooms(storage, signal) {
     if (roomIds.length > MAX_DELETION_ROOMS)
         throw new StorageError("delete graph is too large");
     const joined = new Set(roomIds);
+    const roomIdsToRefresh = [];
     // Matrix has no bounded endpoint that enumerates every invited/non-joined
     // room carrying a space relation. Refresh every locally visible room and
     // fail closed for an invite/knock/unknown membership; a joined external
@@ -258,14 +278,34 @@ async function refreshDeletionRooms(storage, signal) {
             const membership = room.getMyMembership?.();
             if (membership !== "join")
                 throw new StorageError("delete graph inventory is incomplete");
-            await storage.refreshRoomState(room.roomId, { signal });
+            roomIdsToRefresh.push(room.roomId);
         }
     }
-    for (const roomId of roomIds) {
-        if (signal?.aborted)
-            throw new StorageError("operation cancelled");
-        await storage.refreshRoomState(roomId, { signal });
-    }
+    roomIdsToRefresh.push(...roomIds);
+    let nextRoom = 0;
+    let failed = false;
+    let firstError;
+    const refreshWorker = async () => {
+        while (!failed && !signal?.aborted) {
+            const roomId = roomIdsToRefresh[nextRoom++];
+            if (roomId === undefined)
+                return;
+            try {
+                await storage.refreshRoomState(roomId, { signal });
+            }
+            catch (error) {
+                failed = true;
+                firstError = error;
+                return;
+            }
+        }
+    };
+    const workerCount = Math.min(DELETION_REFRESH_CONCURRENCY, roomIdsToRefresh.length);
+    await Promise.all(Array.from({ length: workerCount }, () => refreshWorker()));
+    if (signal?.aborted)
+        throw new StorageError("operation cancelled");
+    if (failed)
+        throw firstError;
 }
 async function refreshTreeSpaces(storage, spaces, signal) {
     for (const space of spaces) {
@@ -458,8 +498,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"));
@@ -518,12 +556,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
@@ -671,6 +704,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))
@@ -969,7 +1004,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() }));
@@ -989,7 +1026,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 }));
@@ -1062,21 +1101,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
@@ -1088,12 +1122,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) {
@@ -1143,7 +1176,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");
@@ -1164,7 +1196,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);
@@ -1269,7 +1301,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);
@@ -1306,6 +1338,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");
@@ -1348,7 +1383,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);
@@ -1382,7 +1417,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.22",
+  "version": "0.5.25",
   "license": "BUSL-1.1",
   "type": "module",
   "packageManager": "npm@11.19.0",