@telecrypt-io/storage 0.2.9 → 0.2.11

package/dist/TeleCryptIOStorage.d.ts

@@ -213,6 +213,21 @@ export declare class TeleCryptIOStorage {
      */
     createTree(name: string): Promise<TreeSpace>;
     listTrees(): Promise<TreeSpace[]>;
+    /**
+     * Creates a subdirectory (nested tree space) under `parent` and links it
+     * with the parent's space.child / the child's space.parent state events.
+     *
+     * Mirrors `createTree`'s workaround for the same matrix-js-sdk race:
+     * `MSC3089TreeSpace.createDirectory()` calls `unstableCreateFileTree()`,
+     * which creates the room via a plain `createRoom()` HTTP call and then
+     * immediately wraps the result by looking the room up in the *local*
+     * client store — throwing `Error("Unknown room")` when the background
+     * sync loop hasn't surfaced the new room yet. Without the workaround the
+     * subfolder room is created server-side but never linked (no space.child
+     * event), leaving an orphaned room and a spurious failure for a folder
+     * that in fact exists.
+     */
+    createSubtree(parent: TreeSpace, name: string): Promise<TreeSpace>;
     getTree(roomId: string): TreeSpace | null;
     /**
      * Lists the participants of a shared folder (tree space) and their role,

package/dist/TeleCryptIOStorage.js

@@ -1,4 +1,4 @@
-import { ClientEvent, createClient, MatrixEvent, SyncState } from "matrix-js-sdk";
+import { ClientEvent, createClient, EventType, MatrixEvent, SyncState } from "matrix-js-sdk";
 import { Method } from "matrix-js-sdk/lib/http-api/method.js";
 import { ClientPrefix } from "matrix-js-sdk/lib/http-api/prefix.js";
 import { encryptAttachment, decryptAttachment } from "matrix-encrypt-attachment";
@@ -306,6 +306,59 @@ export class TeleCryptIOStorage {
         }
         return trees;
     }
+    /**
+     * Creates a subdirectory (nested tree space) under `parent` and links it
+     * with the parent's space.child / the child's space.parent state events.
+     *
+     * Mirrors `createTree`'s workaround for the same matrix-js-sdk race:
+     * `MSC3089TreeSpace.createDirectory()` calls `unstableCreateFileTree()`,
+     * which creates the room via a plain `createRoom()` HTTP call and then
+     * immediately wraps the result by looking the room up in the *local*
+     * client store — throwing `Error("Unknown room")` when the background
+     * sync loop hasn't surfaced the new room yet. Without the workaround the
+     * subfolder room is created server-side but never linked (no space.child
+     * event), leaving an orphaned room and a spurious failure for a folder
+     * that in fact exists.
+     */
+    async createSubtree(parent, name) {
+        const knownRoomIdsBefore = new Set(this.client.getRooms().map((r) => r.roomId));
+        try {
+            // The `await` here is load-bearing: without it, the promise's
+            // eventual rejection would happen after this try/catch has already
+            // returned, bypassing the recovery logic below entirely.
+            return (await parent.createDirectory(name));
+        }
+        catch (err) {
+            if (!(err instanceof Error) || err.message !== "Unknown room")
+                throw err;
+            const newRoomId = await new Promise((resolve, reject) => {
+                const deadline = Date.now() + 15000;
+                const poll = () => {
+                    const found = this.client.getRooms().find((r) => !knownRoomIdsBefore.has(r.roomId));
+                    if (found) {
+                        resolve(found.roomId);
+                        return;
+                    }
+                    if (Date.now() >= deadline) {
+                        reject(new Error("createSubtree: room was created server-side but never appeared in this client's local sync state"));
+                        return;
+                    }
+                    setTimeout(poll, 200);
+                };
+                poll();
+            });
+            const tree = this.client.unstableGetFileTreeSpace(newRoomId);
+            if (!tree) {
+                throw new Error(`createSubtree: room ${newRoomId} appeared but is not a valid file tree space`);
+            }
+            // The room appeared in sync, but `createDirectory` threw before it
+            // could send the space.child / space.parent link events. Send them
+            // now so the subfolder is actually reachable from its parent.
+            await this.client.sendStateEvent(parent.id, EventType.SpaceChild, { via: [this.client.getDomain()] }, newRoomId);
+            await this.client.sendStateEvent(newRoomId, EventType.SpaceParent, { via: [this.client.getDomain()] }, parent.id);
+            return tree;
+        }
+    }
     getTree(roomId) {
         return this.client.unstableGetFileTreeSpace(roomId);
     }

package/dist/core/operations.js

@@ -92,7 +92,7 @@ export function getMyFolderRole(storage, folderId) {
 }
 export async function joinFolder(storage, folderId) {
     try {
-        await storage.getClient().joinRoom(folderId);
+        await withRateLimitRetry("joinFolder", () => storage.getClient().joinRoom(folderId));
     }
     catch (err) {
         throw new CliError(`join failed: ${err.message}`);
@@ -173,20 +173,20 @@ export async function shareFolder(storage, folderId, userId, role) {
     }
     const tree = await resolveTree(storage, folderId);
     try {
-        await tree.invite(userId);
+        await withRateLimitRetry("shareFolder.invite", () => tree.invite(userId));
     }
     catch (err) {
         if (!/already in the room/i.test(err.message)) {
             throw err;
         }
     }
-    await tree.setPermissions(userId, role);
+    await withRateLimitRetry("shareFolder.setPermissions", () => tree.setPermissions(userId, role));
     return { folderId, userId, role };
 }
 export async function unshareFolder(storage, folderId, userId) {
     await resolveTree(storage, folderId);
     try {
-        await storage.getClient().kick(folderId, userId, "unshared");
+        await withRateLimitRetry("unshareFolder", () => storage.getClient().kick(folderId, userId, "unshared"));
     }
     catch (err) {
         throw new CliError(`unshare failed: ${err.message}`);
@@ -208,7 +208,7 @@ export async function listSubfolders(storage, folderId) {
 }
 export async function createSubfolder(storage, folderId, name) {
     const tree = await resolveTree(storage, folderId);
-    const sub = await withRateLimitRetry("createSubfolder", () => tree.createDirectory(name));
+    const sub = await withRateLimitRetry("createSubfolder", () => storage.createSubtree(tree, name));
     return { id: sub.id, name };
 }
 export async function renameFolder(storage, folderId, name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telecrypt-io/storage",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "license": "BUSL-1.1",
   "type": "module",
   "main": "dist/index.js",