fix(index): Update index incrementally instead of recreating it every time

Signed-off-by: Marcel Klehr <mklehr@gmx.net>

Author: marcelklehr

src/lib/CachingTreeWrapper.ts

@@ -26,9 +26,10 @@ export default class CachingTreeWrapper implements OrderFolderResource<typeof It
     const id = await this.innerTree.createBookmark(bookmark)
     const cacheId = await this.cacheTree.createBookmark(bookmark.copy(false))
     const cacheBookmark = this.cacheTree.bookmarksCache.findBookmark(cacheId)
+    this.cacheTree.bookmarksCache.removeFromIndex(cacheBookmark)
     cacheBookmark.id = id
     cacheBookmark.parentId = bookmark.parentId
-    this.cacheTree.bookmarksCache.createIndex()
+    this.cacheTree.bookmarksCache.updateIndex(cacheBookmark)
     return id
   }
 
@@ -46,9 +47,10 @@ export default class CachingTreeWrapper implements OrderFolderResource<typeof It
     const id = await this.innerTree.createFolder(folder)
     const cacheId = await this.cacheTree.createFolder(folder.copy(false))
     const cacheFolder = this.cacheTree.bookmarksCache.findFolder(cacheId)
+    this.cacheTree.bookmarksCache.removeFromIndex(cacheFolder)
     cacheFolder.id = id
     cacheFolder.parentId = folder.parentId
-    this.cacheTree.bookmarksCache.createIndex()
+    this.cacheTree.bookmarksCache.updateIndex(cacheFolder)
     return id
   }
 

src/lib/Tree.ts

@@ -39,6 +39,7 @@ export class Bookmark<L extends TItemLocation> {
   public location: L
   public isRoot = false
   private hashValue: Record<string, string>
+  public index: IItemIndex<L>
 
   constructor({
     id,
@@ -194,8 +195,9 @@ export class Bookmark<L extends TItemLocation> {
     return result
   }
 
-  createIndex(): any {
-    return { [this.id]: this }
+  createIndex(): IItemIndex<L> {
+    this.index = { bookmark: {[this.id]: this}, folder: {} }
+    return this.index
   }
 
   // TODO: Make this return the correct type based on the type param
@@ -258,7 +260,7 @@ export class Folder<L extends TItemLocation> {
   public isRoot = false
   public loaded = true
   public location: L
-  private index: IItemIndex<L>
+  public index: IItemIndex<L>
 
   constructor({
     id,
@@ -363,7 +365,7 @@ export class Folder<L extends TItemLocation> {
   ): Promise<void> {
     await Parallel.each(
       this.children,
-      async (item) => {
+      async(item) => {
         await fn(item, this)
         if (item.type === 'folder') {
           // give the browser time to breathe
@@ -560,24 +562,43 @@ export class Folder<L extends TItemLocation> {
   createIndex(): IItemIndex<L> {
     this.index = {
       folder: { [this.id]: this },
-      bookmark: this.children
-        .filter((child) => child instanceof Bookmark)
-        .reduce((obj, child) => {
-          obj[child.id] = child
-          return obj
-        }, {}),
+      bookmark: {}
     }
 
-    this.children
-      .filter((child) => child instanceof Folder)
-      .map((child) => child.createIndex())
-      .forEach((subIndex) => {
+    for (const child of this.children) {
+      if (child instanceof Bookmark) {
+        this.index.bookmark[child.id] = child
+      } else if (child instanceof Folder) {
+        const subIndex = child.createIndex()
         Object.assign(this.index.folder, subIndex.folder)
         Object.assign(this.index.bookmark, subIndex.bookmark)
-      })
+      }
+    }
+
     return this.index
   }
 
+  updateIndex(item: TItem<L>) {
+    const itemIndex = item.index || item.createIndex()
+    let currentItem = item
+    while (currentItem) {
+      Object.assign(currentItem.index.folder, itemIndex.folder)
+      Object.assign(currentItem.index.bookmark, itemIndex.bookmark)
+      currentItem = this.index.folder[currentItem.parentId]
+    }
+  }
+
+  removeFromIndex(item: TItem<L>) {
+    if (!item) return
+    if (item.parentId) {
+      let parentFolder = this.index.folder[item.parentId]
+      while (parentFolder) {
+        delete parentFolder.index[item.type][item.id]
+        parentFolder = this.index.folder[parentFolder.parentId]
+      }
+    }
+  }
+
   inspect(depth = 0): string {
     return (
       Array(depth < 0 ? 0 : depth)
@@ -618,13 +639,13 @@ export class Folder<L extends TItemLocation> {
       ...obj,
       children: obj.children
         ? obj.children.map((child) => {
-            // Firefox seems to set 'url' even for folders
-            if ('url' in child && typeof child.url === 'string') {
-              return Bookmark.hydrate(child)
-            } else {
-              return Folder.hydrate(child)
-            }
-          })
+          // Firefox seems to set 'url' even for folders
+          if ('url' in child && typeof child.url === 'string') {
+            return Bookmark.hydrate(child)
+          } else {
+            return Folder.hydrate(child)
+          }
+        })
         : null,
     })
   }

src/lib/adapters/Caching.ts

@@ -80,7 +80,7 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
       throw new UnknownCreateTargetError()
     }
     foundFolder.children.push(bm)
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.updateIndex(bm)
     return bm.id
   }
 
@@ -111,7 +111,8 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
     )
     foundNewFolder.children.push(foundBookmark)
     foundBookmark.parentId = newBm.parentId
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.removeFromIndex(foundBookmark)
+    this.bookmarksCache.updateIndex(newBm)
   }
 
   async removeBookmark(bookmark:Bookmark<TItemLocation>): Promise<void> {
@@ -131,7 +132,7 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
       foundOldFolder.children.indexOf(foundBookmark),
       1
     )
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.removeFromIndex(bookmark)
   }
 
   async createFolder(folder:Folder<TItemLocation>): Promise<string|number> {
@@ -142,7 +143,7 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
       throw new UnknownCreateTargetError()
     }
     foundParentFolder.children.push(newFolder)
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.updateIndex(newFolder)
     return newFolder.id
   }
 
@@ -167,9 +168,10 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
     }
     foundOldParentFolder.children.splice(foundOldParentFolder.children.indexOf(oldFolder), 1)
     foundNewParentFolder.children.push(oldFolder)
+    this.bookmarksCache.removeFromIndex(oldFolder)
     oldFolder.title = folder.title
     oldFolder.parentId = folder.parentId
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.updateIndex(oldFolder)
   }
 
   async orderFolder(id:string|number, order:Ordering<TItemLocation>):Promise<void> {
@@ -218,7 +220,7 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
       return
     }
     foundOldFolder.children.splice(foundOldFolder.children.indexOf(oldFolder), 1)
-    this.bookmarksCache.createIndex()
+    this.bookmarksCache.removeFromIndex(oldFolder)
   }
 
   async bulkImportFolder(id:string|number, folder:Folder<TItemLocation>):Promise<Folder<TItemLocation>> {
@@ -237,7 +239,8 @@ export default class CachingAdapter implements Adapter, BulkImportResource<TItem
     // insert into tree
     foundFolder.children = imported.children
     // good as new
-    this.bookmarksCache.createIndex()
+    foundFolder.createIndex()
+    this.bookmarksCache.updateIndex(foundFolder)
     return imported
   }
 

src/lib/adapters/NextcloudBookmarks.ts

@@ -408,7 +408,8 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
     }
     folder.children = children
     folder.loaded = true
-    this.tree.createIndex()
+    folder.createIndex()
+    this.tree.updateIndex(folder)
     return folder.copy(true).children
   }
 
@@ -435,10 +436,14 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
       throw new UnexpectedServerResponseError()
     }
 
-    parentFolder.children.push(
-      new Folder({ id: json.item.id, title, parentId, location: ItemLocation.SERVER })
-    )
-    this.tree.createIndex()
+    const newFolder = new Folder({
+      id: json.item.id,
+      title,
+      parentId,
+      location: ItemLocation.SERVER,
+    })
+    parentFolder.children.push(newFolder)
+    this.tree.updateIndex(newFolder)
     return json.item.id
   }
 
@@ -500,7 +505,8 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
     }
     const imported = recurseChildren(json.data, parentId, folder.title, folder.parentId)
     parentFolder.children = imported.copy(true).children
-    this.tree.createIndex()
+    parentFolder.createIndex()
+    this.tree.updateIndex(parentFolder)
     return imported
   }
 
@@ -536,9 +542,10 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
       throw new UnknownMoveTargetError()
     }
     newParentFolder.children.push(oldFolder)
+    this.tree.removeFromIndex(oldFolder)
     oldFolder.title = folder.title
     oldFolder.parentId = folder.parentId
-    this.tree.createIndex()
+    this.tree.updateIndex(oldFolder)
   }
 
   async orderFolder(id:string|number, order:Ordering<typeof ItemLocation.SERVER>):Promise<void> {
@@ -573,7 +580,7 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
       parent.children = parent.children.filter(
         (child) => String(child.id) !== String(id)
       )
-      this.tree.createIndex()
+      this.tree.removeFromIndex(oldFolder)
     }
   }
 
@@ -691,7 +698,7 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
       this.list && this.list.push(upstreamMark)
       if (this.tree) {
         newParentFolder.children.push(upstreamMark)
-        this.tree.createIndex()
+        this.tree.updateIndex(upstreamMark)
       }
 
       return bm.id
@@ -742,11 +749,21 @@ export default class NextcloudBookmarksAdapter implements Adapter, BulkImportRes
         throw e
       }
 
+      if (oldParentId) {
+        const oldParentFolder = this.tree.findFolder(oldParentId)
+        const oldBm = oldParentFolder.findBookmark(newBm.id)
+        oldParentFolder.children = oldParentFolder.children.filter(
+          (item) => !(item.type === 'bookmark' && item.id === newBm.id)
+        )
+        if (oldBm && this.tree) {
+          this.tree.removeFromIndex(oldBm)
+        }
+      }
       if (!newFolder.children.find(item => String(item.id) === String(newBm.id) && item.type === 'bookmark')) {
         newFolder.children.push(newBm)
       }
       newBm.id = upstreamId + ';' + newBm.parentId
-      this.tree.createIndex()
+      this.tree.updateIndex(newBm)
 
       return newBm.id
     })