@lexho111/plainblog 0.8.6 → 0.9.0

package/dist/model/datastructures/BinarySearchTreeWithInvertedIndex.js

@@ -26,9 +26,11 @@ export var TraversalOrder;
 })(TraversalOrder || (TraversalOrder = {}));
 export class BinarySearchTree {
     root;
+    dateRoot;
     searchIndex;
     constructor() {
         this.root = null;
+        this.dateRoot = null;
         this.searchIndex = new InvertedIndexSearch();
     }
     // O(n) - Linear search (Base class has no HashMap)
@@ -37,34 +39,63 @@ export class BinarySearchTree {
     }
     // Insert a new article
     insert(article) {
+        const time_start = performance.now();
         this.searchIndex.add(article);
-        // Note: The tree is now sorted by date. ID-based methods will not work correctly.
-        // if (!article.id) article.id = this.getNextID();
-        // Add to the Set
-        const newNode = new BlogNode(article);
+        // 1. Insert into ID Tree
+        const idNode = new BlogNode(article);
         if (!this.root) {
-            this.root = newNode;
-            return;
+            this.root = idNode;
         }
-        let current = this.root;
-        const newTime = newNode.article.createdAt;
-        while (true) {
-            // Using getTime() for numeric comparison. Duplicates go to the right.
-            if (newTime < current.article.createdAt) {
-                if (!current.left) {
-                    current.left = newNode;
+        else {
+            let current = this.root;
+            while (true) {
+                if (article.id < current.article.id) {
+                    if (!current.left) {
+                        current.left = idNode;
+                        break;
+                    }
+                    current = current.left;
+                }
+                else if (article.id > current.article.id) {
+                    if (!current.right) {
+                        current.right = idNode;
+                        break;
+                    }
+                    current = current.right;
+                }
+                else {
+                    current.article = article; // Update existing
                     break;
                 }
-                current = current.left;
             }
-            else {
-                if (!current.right) {
-                    current.right = newNode;
-                    break;
+        }
+        // 2. Insert into Date Tree
+        const dateNode = new BlogNode(article);
+        if (!this.dateRoot) {
+            this.dateRoot = dateNode;
+        }
+        else {
+            let current = this.dateRoot;
+            const newTime = new Date(article.createdAt).getTime();
+            while (true) {
+                // Duplicates go to the right
+                if (newTime < new Date(current.article.createdAt).getTime()) {
+                    if (!current.left) {
+                        current.left = dateNode;
+                        break;
+                    }
+                    current = current.left;
+                }
+                else {
+                    if (!current.right) {
+                        current.right = dateNode;
+                        break;
+                    }
+                    current = current.right;
                 }
-                current = current.right;
             }
         }
+        debug_perf("BST.insert", performance.now() - time_start);
     }
     update(id, title, content) {
         const article = this.find(id);
@@ -90,29 +121,27 @@ export class BinarySearchTree {
     }
     // Search for a specific article by ID
     find(id) {
-        // Tree is sorted by Date, so we must traverse all nodes to find by ID (O(n))
-        return this._findNodeDFS(this.root, id);
-    }
-    _findNodeDFS(node, id) {
-        const stack = [];
-        if (node)
-            stack.push(node);
-        while (stack.length > 0) {
-            const current = stack.pop();
-            if (current.article.id === id)
+        const time_start = performance.now();
+        // Use ID Tree for O(log n) lookup
+        let current = this.root;
+        while (current) {
+            if (id === current.article.id) {
+                debug_perf("BST.find", performance.now() - time_start);
                 return current.article;
-            if (current.right)
-                stack.push(current.right);
-            if (current.left)
-                stack.push(current.left);
+            }
+            if (id < current.article.id)
+                current = current.left;
+            else
+                current = current.right;
         }
+        debug_perf("BST.find", performance.now() - time_start);
         return null;
     }
     // Get all articles in order (Sorted by ID)
     getAllArticles(order = TraversalOrder.NewestFirst) {
         const articles = [];
-        if (this.root) {
-            this._inOrder(this.root, articles, order);
+        if (this.dateRoot) {
+            this._inOrder(this.dateRoot, articles, order);
         }
         return articles;
     }
@@ -144,7 +173,7 @@ export class BinarySearchTree {
     }
     *traverse(order = TraversalOrder.NewestFirst) {
         const stack = [];
-        let current = this.root;
+        let current = this.dateRoot;
         let visitedCount = 0;
         if (order === TraversalOrder.NewestFirst) {
             while (current || stack.length > 0) {
@@ -173,6 +202,7 @@ export class BinarySearchTree {
         debug("Traversed %d nodes of %d", visitedCount, this.size());
     }
     getRange(startdate, enddate, limit = null) {
+        const time_start = performance.now();
         debug("Using BST.getRange for start: '%s', end: '%s', limit: %s", startdate, enddate, limit);
         if (typeof startdate === "number") {
             debug("startdate is number");
@@ -193,7 +223,8 @@ export class BinarySearchTree {
         const end = toTimestamp(enddate, Infinity);
         debug("startdate: %d", start);
         debug("enddate: %d", end);
-        this._rangeSearch(this.root, start, end, limit, results);
+        this._rangeSearch(this.dateRoot, start, end, limit, results);
+        debug_perf("BST.getRange", performance.now() - time_start);
         return results;
     }
     _rangeSearch(node, start, end, limit, results) {
@@ -206,7 +237,7 @@ export class BinarySearchTree {
             // Go right as much as possible, but prune if > end
             while (current) {
                 visitedCount++;
-                if (current.article.createdAt > end) {
+                if (new Date(current.article.createdAt).getTime() > end) {
                     current = current.left;
                 }
                 else {
@@ -218,7 +249,7 @@ export class BinarySearchTree {
                 current = stack.pop();
                 if (limit !== null && results.length >= limit)
                     break;
-                if (current.article.createdAt >= start) {
+                if (new Date(current.article.createdAt).getTime() >= start) {
                     results.push(current.article);
                     current = current.left;
                 }
@@ -246,103 +277,87 @@ export class BinarySearchTree {
         return count;
     }
     remove(data) {
-        const id = data instanceof Article ? data.id : data;
-        const date = data instanceof Article ? data.createdAt : null;
-        const { root, removed } = this._removeIterative(this.root, id, date);
-        this.root = root;
-        if (removed) {
-            this.searchIndex.remove(removed.id);
+        const time_start = performance.now();
+        let articleToRemove = null;
+        if (data instanceof Article) {
+            articleToRemove = data;
+        }
+        else {
+            articleToRemove = this.find(data);
         }
-        return removed;
+        if (articleToRemove) {
+            // Remove from ID tree
+            this.root = this._removeNodeID(this.root, articleToRemove.id);
+            // Remove from Date tree
+            this.dateRoot = this._removeNodeDate(this.dateRoot, articleToRemove);
+            this.searchIndex.remove(articleToRemove.id);
+        }
+        debug_perf("BST.remove", performance.now() - time_start);
+        return articleToRemove;
     }
-    _removeIterative(root, id, date) {
-        let parent = null;
-        let current = root;
-        let isLeftChild = false;
-        // 1. Find the node
-        if (date !== null) {
-            // Optimized search using BST property (Date)
-            while (current) {
-                if (current.article.id == id)
-                    break;
-                parent = current;
-                if (date < current.article.createdAt) {
-                    current = current.left;
-                    isLeftChild = true;
-                }
-                else {
-                    current = current.right;
-                    isLeftChild = false;
-                }
-            }
+    _removeNodeID(root, id) {
+        if (!root)
+            return null;
+        if (id < root.article.id) {
+            root.left = this._removeNodeID(root.left, id);
+            return root;
         }
-        else {
-            const stack = root ? [{ node: root, parent: null, isLeft: false }] : [];
-            current = null;
-            while (stack.length > 0) {
-                const item = stack.pop();
-                if (item.node.article.id === id) {
-                    current = item.node;
-                    parent = item.parent;
-                    isLeftChild = item.isLeft;
-                    break;
-                }
-                if (item.node.right)
-                    stack.push({
-                        node: item.node.right,
-                        parent: item.node,
-                        isLeft: false,
-                    });
-                if (item.node.left)
-                    stack.push({ node: item.node.left, parent: item.node, isLeft: true });
-            }
+        else if (id > root.article.id) {
+            root.right = this._removeNodeID(root.right, id);
+            return root;
         }
-        if (!current)
-            return { root, removed: null }; // Not found
-        const removed = current.article;
-        // 2. Delete node
-        if (!current.left && !current.right) {
-            if (!parent)
-                return { root: null, removed }; // Root was deleted
-            if (isLeftChild)
-                parent.left = null;
-            else
-                parent.right = null;
+        else {
+            // Found
+            if (!root.left)
+                return root.right;
+            if (!root.right)
+                return root.left;
+            let minRight = root.right;
+            while (minRight.left)
+                minRight = minRight.left;
+            root.article = minRight.article;
+            root.right = this._removeNodeID(root.right, minRight.article.id);
+            return root;
         }
-        else if (!current.right) {
-            if (!parent)
-                return { root: current.left, removed };
-            if (isLeftChild)
-                parent.left = current.left;
-            else
-                parent.right = current.left;
+    }
+    _removeNodeDate(root, article) {
+        if (!root)
+            return null;
+        const time = new Date(article.createdAt).getTime();
+        const rootTime = new Date(root.article.createdAt).getTime();
+        if (time < rootTime) {
+            root.left = this._removeNodeDate(root.left, article);
+            return root;
         }
-        else if (!current.left) {
-            if (!parent)
-                return { root: current.right, removed };
-            if (isLeftChild)
-                parent.left = current.right;
-            else
-                parent.right = current.right;
+        else if (time > rootTime) {
+            root.right = this._removeNodeDate(root.right, article);
+            return root;
         }
         else {
-            // Two children: Find successor (min in right subtree)
-            let successorParent = current;
-            let successor = current.right;
-            while (successor.left) {
-                successorParent = successor;
-                successor = successor.left;
+            // Dates equal. Check ID.
+            if (article.id === root.article.id) {
+                // Found exact match
+                if (!root.left)
+                    return root.right;
+                if (!root.right)
+                    return root.left;
+                let minRight = root.right;
+                while (minRight.left)
+                    minRight = minRight.left;
+                root.article = minRight.article;
+                root.right = this._removeNodeDate(root.right, minRight.article);
+                return root;
+            }
+            else {
+                // Dates equal but ID different. Duplicates are on right.
+                root.right = this._removeNodeDate(root.right, article);
+                return root;
             }
-            current.article = successor.article;
-            if (successorParent === current)
-                successorParent.right = successor.right;
-            else
-                successorParent.left = successor.right;
         }
-        return { root, removed };
     }
     clear() {
         this.root = null;
+        this.dateRoot = null;
         this.searchIndex = new InvertedIndexSearch();
     }
     size() {

package/index.js

@@ -2,7 +2,6 @@ import { Blog, BlogBuilder } from "./Blog.js";
 import Article from "./Article.js";
 import FileAdapter from "./model/FileAdapter.js";
 import PostgresAdapter from "./model/PostgresAdapter.js";
-import SequelizeAdapter from "./model/SequelizeAdapter.js";
 import SqliteAdapter from "./model/SqliteAdapter.js";
 import { startCluster } from "./cluster-server.js";
 import { articleFactory, articleGenerator } from "./utilities.js";
@@ -12,7 +11,6 @@ export {
   BlogBuilder,
   Article,
   PostgresAdapter,
-  SequelizeAdapter,
   FileAdapter,
   SqliteAdapter,
   startCluster,