@lexho111/plainblog 0.5.28 → 0.6.1

package/index.js

@@ -3,6 +3,30 @@ import Article from "./Article.js";
 import FileAdapter from "./model/FileAdapter.js";
 import SqliteAdapter from "./model/SqliteAdapter.js";
 import PostgresAdapter from "./model/PostgresAdapter.js";
+import DataModel from "./model/DataModel.js";
+import ArrayList from "./model/datastructures/ArrayList.js";
+import FileList from "./model/datastructures/FileList.js";
+import { BinarySearchTree } from "./model/datastructures/BinarySearchTree.js";
+import {
+  generateTitle,
+  generateContent,
+  generateDateList,
+} from "./utilities.js";
+import { appendArticle } from "./model/FileModel.js";
 
-export { Blog, Article, FileAdapter, SqliteAdapter, PostgresAdapter };
+export {
+  Blog,
+  Article,
+  FileAdapter,
+  SqliteAdapter,
+  PostgresAdapter,
+  DataModel,
+  ArrayList,
+  FileList,
+  BinarySearchTree,
+  generateTitle,
+  generateContent,
+  generateDateList,
+  appendArticle,
+};
 export default Blog;

package/model/DataModel.js

@@ -0,0 +1,80 @@
+//import createDebug from "debug";
+import { debuglog as createDebug } from "node:util";
+import Article from "../Article.js";
+
+const debug = createDebug("plainblog:DataModel");
+
+export default class DataModel {
+  constructor(storage) {
+    this.storage = storage;
+    this.db = null;
+  }
+
+  setDataModel(storage) {
+    this.storage = storage;
+  }
+
+  setDatabase(db) {
+    this.db = db;
+  }
+
+  getStorageName() {
+    // Check if storage exists and has a constructor with a name
+    return this.storage?.constructor?.name || "UnknownStorage";
+  }
+
+  insert(article) {
+    //console.log("DataModel: insert article");
+    this.storage.insert(article);
+  }
+
+  update(id, title, content) {
+    debug("update");
+    if (this.storage.update) {
+      return this.storage.update(id, title, content);
+    }
+  }
+
+  search(query) {
+    debug("search");
+    if (this.storage.search) {
+      return this.storage.search(query);
+    }
+  }
+
+  remove(article) {
+    debug("remove");
+    this.storage.remove(article);
+  }
+
+  getAllArticles() {
+    debug("get all articles");
+    const order = "newest";
+    return this.storage.getAllArticles(order);
+  }
+
+  async findAll(start, end, limit) {
+    debug("find all %d %d %d", start, end, limit);
+    if (start == null && end == null && limit == null)
+      return this.getAllArticles();
+
+    let articles = this.storage.getRange(start, end, limit);
+
+    if (articles.length < limit && this.db) {
+      const dbArticles = await this.db.findAll(limit, 0, start, end);
+      for (const data of dbArticles) {
+        if (!this.storage.contains(data.id)) {
+          this.storage.insert(
+            new Article(data.id, data.title, data.content, data.createdAt),
+          );
+        }
+      }
+      articles = this.storage.getRange(start, end, limit);
+    }
+    return articles;
+  }
+
+  size() {
+    return this.storage.size();
+  }
+}

package/model/DatabaseModel.js

@@ -1,13 +1,11 @@
-import FileAdapter from "./FileAdapter.js";
+//import createDebug from "debug";
+import { debuglog as createDebug } from "node:util";
+
+const debug = createDebug("plainblog:DatabaseModel");
 
 export default class DatabaseModel {
-  dbtype;
-  constructor(options = {}) {
-    console.log(JSON.stringify(options));
-    this.dbtype = options.type;
-    if (options.type === "file") {
-      this.adapter = new FileAdapter(options);
-    }
+  constructor(adapter) {
+    this.adapter = adapter;
   }
 
   async setDatabaseAdapter(adapter) {
@@ -24,14 +22,29 @@ export default class DatabaseModel {
   }
 
   async save(newArticle) {
+    console.log("save article to database");
     return this.adapter.save(newArticle);
   }
 
+  async update(id, data) {
+    if (this.adapter.update) {
+      return this.adapter.update(id, data);
+    }
+  }
+
+  async remove(id) {
+    debug("remove by id");
+    if (this.adapter.remove) {
+      return this.adapter.remove(id);
+    }
+  }
+
   async updateBlogTitle(newTitle) {
     return this.adapter.updateBlogTitle(newTitle);
   }
 
   async findAll(limit, offset, startId, endId, order) {
+    debug("get all articles from database");
     return this.adapter.findAll(limit, offset, startId, endId, order);
   }
 }

package/model/FileAdapter.js

@@ -4,7 +4,12 @@ import {
   appendArticle,
   loadArticles,
   initFiles,
+  saveArticles,
 } from "./FileModel.js";
+//import createDebug from "debug";
+import { debuglog as createDebug } from "node:util";
+
+const debug = createDebug("plainblog:FileAdapter");
 
 export default class FileAdapter {
   dbtype = "file";
@@ -14,7 +19,7 @@ export default class FileAdapter {
   }
 
   async initialize() {
-    console.log("file adapter init");
+    debug("init");
     await initFiles(this.infoFile, this.articlesFile);
   }
 
@@ -31,6 +36,9 @@ export default class FileAdapter {
     if (!newArticle.createdAt) {
       newArticle.createdAt = new Date().toISOString();
     }
+    if (!newArticle.id) {
+      newArticle.id = Date.now();
+    }
     await appendArticle(this.articlesFile, newArticle);
   }
 
@@ -38,23 +46,55 @@ export default class FileAdapter {
     await saveInfo(this.infoFile, { title: newTitle });
   }
 
+  async update(id, data) {
+    const articles = await loadArticles(this.articlesFile);
+    const article = articles.find((a) => a.id == id);
+    if (article) {
+      if (data.title) article.title = data.title;
+      if (data.content) article.content = data.content;
+      await saveArticles(this.articlesFile, articles);
+    }
+  }
+
+  async remove(id) {
+    debug("remove from '%s'", this.articlesFile);
+    const articles = await loadArticles(this.articlesFile);
+    const newArticles = articles.filter((a) => a.id != id);
+    // Only write if something was actually removed
+    if (newArticles.length < articles.length) {
+      await saveArticles(this.articlesFile, newArticles);
+    }
+  }
+
+  // findAll()
+  // findAll(limit, offset, order)
   async findAll(
-    limit = 4,
+    limit = -1,
     offset = 0,
     //startId = null,
     //endId = null,
-    order = "DESC"
+    order = "DESC",
   ) {
     let dbArticles = [];
     try {
       const articles = await loadArticles(this.articlesFile);
       if (Array.isArray(articles)) {
+        // Ensure every article has an ID (backward compatibility)
+        articles.forEach((article, index) => {
+          if (!article.id) {
+            const ts = article.createdAt
+              ? new Date(article.createdAt).getTime()
+              : Date.now();
+            article.id = (isNaN(ts) ? Date.now() : ts) + index; // Add index to ensure uniqueness
+          }
+        });
         articles.sort((a, b) => {
           const dateA = new Date(a.createdAt || 0);
           const dateB = new Date(b.createdAt || 0);
           return order === "DESC" ? dateB - dateA : dateA - dateB;
         });
-        dbArticles = articles.slice(offset, offset + limit);
+        if (limit == -1) dbArticles = articles;
+        else dbArticles = articles.slice(offset, offset + limit);
       }
     } catch (err) {
       console.error(err);

package/model/FileModel.js

@@ -1,14 +1,20 @@
-import { promises as fs } from "fs";
+import { promises as promise } from "fs";
+import { appendFile, appendFileSync, readFile, readFileSync } from "node:fs";
+//import createDebug from "debug";
+import { debuglog as createDebug } from "node:util";
+import Article from "../Article.js";
+
+const debug = createDebug("plainblog:FileModel");
 
 /** save blog info (title, etc) to a standard JSON file */
 export async function saveInfo(filename, data) {
-  await fs.writeFile(filename, JSON.stringify(data, null, 2));
+  await promise.writeFile(filename, JSON.stringify(data, null, 2));
 }
 
 /** load blog info */
 export async function loadInfo(filename) {
   try {
-    const data = await fs.readFile(filename, "utf8");
+    const data = await promise.readFile(filename, "utf8");
     return JSON.parse(data);
   } catch (err) {
     console.error(err);
@@ -18,17 +24,50 @@ export async function loadInfo(filename) {
 
 /** append an article as a new line to the file */
 export async function appendArticle(filename, article) {
-  await fs.appendFile(filename, JSON.stringify(article) + "\n");
+  await promise.appendFile(filename, JSON.stringify(article) + "\n");
+}
+
+/** overwrite all articles in the file */
+export async function saveArticles(filename, articles) {
+  const data = articles.map((article) => JSON.stringify(article)).join("\n");
+  await promise.writeFile(filename, data + "\n");
+}
+
+/** append an article as a new line to the file */
+export function appendArticleSync(filename, article) {
+  appendFileSync(filename, JSON.stringify(article) + "\n");
 }
 
 /** load all articles by reading line by line */
 export async function loadArticles(filename) {
+  debug("loadArticles from file");
+  try {
+    const data = await promise.readFile(filename, "utf8");
+    return data
+      .split("\n")
+      .filter((line) => line.trim() !== "")
+      .map((line) => {
+        const json = JSON.parse(line);
+        return new Article(json.id, json.title, json.content, json.createdAt);
+      });
+  } catch (err) {
+    console.error(err);
+    return [];
+  }
+}
+
+/** load all articles by reading line by line */
+export function loadArticlesSync(filename) {
+  console.log("FileModel: loadArticles from '%s'", filename);
   try {
-    const data = await fs.readFile(filename, "utf8");
+    const data = readFileSync(filename, "utf8");
     return data
       .split("\n")
       .filter((line) => line.trim() !== "")
-      .map((line) => JSON.parse(line));
+      .map((line) => {
+        const json = JSON.parse(line);
+        return new Article(json.id, json.title, json.content, json.createdAt);
+      });
   } catch (err) {
     console.error(err);
     return [];
@@ -38,16 +77,16 @@ export async function loadArticles(filename) {
 /** ensure files exist */
 export async function initFiles(infoFilename, articlesFilename) {
   try {
-    await fs.access(infoFilename);
+    await promise.access(infoFilename);
   } catch (err) {
     console.error(err);
     await saveInfo(infoFilename, { title: "Blog" });
   }
 
   try {
-    await fs.access(articlesFilename);
+    await promise.access(articlesFilename);
   } catch (err) {
     console.error(err);
-    await fs.writeFile(articlesFilename, "");
+    await promise.writeFile(articlesFilename, "");
   }
 }

package/model/SequelizeAdapter.js

@@ -68,7 +68,7 @@ export default class SequelizeAdapter {
       },
       {
         timestamps: true,
-      }
+      },
     );
 
     this.BlogInfo = this.sequelize.define(
@@ -78,7 +78,7 @@ export default class SequelizeAdapter {
       },
       {
         timestamps: false,
-      }
+      },
     );
 
     // This creates the tables if they don't exist.
@@ -99,7 +99,7 @@ export default class SequelizeAdapter {
     offset = 0,
     startId = null,
     endId = null,
-    order = "DESC"
+    order = "DESC",
   ) {
     await this.loadSequelize();
     const where = {};
@@ -128,6 +128,14 @@ export default class SequelizeAdapter {
     console.log("Added new article:", newArticle);
   }
 
+  async update(id, data) {
+    await this.Article.update(data, { where: { id } });
+  }
+
+  async remove(id) {
+    await this.Article.destroy({ where: { id } });
+  }
+
   async getBlogTitle() {
     // Find the first (and only) entry in the BlogInfo table.
     const blogInfo = await this.BlogInfo.findOne();

package/model/datastructures/ArrayList.js

@@ -0,0 +1,118 @@
+export default class ArrayList {
+  articles = [];
+  constructor() {
+    ////this.ids = new Map();
+  }
+
+  clear() {
+    this.articles = [];
+    //this.ids.clear();
+  }
+
+  insert(article) {
+    this.articles.push(article);
+    //this.ids.set(article.id, article);
+  }
+
+  update(id, title, content) {
+    const article = this.find(id);
+    article.title = title;
+    article.content = content;
+  }
+
+  search(query) {
+    const lower = query.toLowerCase();
+    return this.getAllArticles().filter(
+      (a) =>
+        a.title.toLowerCase().includes(lower) ||
+        a.content.toLowerCase().includes(lower),
+    );
+  }
+
+  remove(article) {
+    const id = article && article.id ? article.id : article;
+    this.articles = this.articles.filter((article) => article.id != id);
+    //this.ids.delete(id);
+  }
+
+  /*contains(id) {
+    return this.articles.includes(id);
+  }*/
+
+  contains(article) {
+    const id = article.id;
+    return this.articles.some((a) => a.id === id);
+  }
+
+  find(id) {
+    return this.articles.find((u) => u.id === id);
+  }
+
+  formatter(tstamp) {
+    const date = new Date(tstamp);
+    /*const formatted = date.toLocaleString("de-DE", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false, // Ensures 24-hour format
+    });*/
+    const formatted = date;
+    return formatted;
+  }
+
+  async getRange(start, end, limit) {
+    let result = [];
+
+    const startTime = start
+      ? new Date(
+          start instanceof Date
+            ? start
+            : isNaN(start)
+              ? start
+              : parseInt(start),
+        ).getTime()
+      : 0;
+    const endTime = end
+      ? new Date(
+          end instanceof Date ? end : isNaN(end) ? end : parseInt(end),
+        ).getTime()
+      : Infinity;
+
+    for (const article of this.articles) {
+      // Optimization: article.createdAt is already a timestamp. No need for new Date().
+      const articleTime = article.createdAt;
+      if (articleTime >= startTime && articleTime <= endTime) {
+        result.push(article);
+      }
+    }
+
+    // Sort: Newest first (Descending)
+    result.sort((a, b) => b.createdAt - a.createdAt);
+    // Sort: Newest first (Descending), then by ID Descending for stability
+    /*result.sort((a, b) => {
+      const timeDiff = b.createdAt - a.createdAt;
+      if (timeDiff !== 0) return timeDiff;
+      return b.id - a.id;
+    });*/
+
+    if (limit && result.length > limit) {
+      result = result.slice(0, limit);
+    }
+
+    return result;
+  }
+
+  getAllArticles() {
+    return this.articles;
+  }
+
+  size() {
+    return this.articles.length;
+  }
+
+  get length() {
+    return this.size();
+  }
+}

package/model/datastructures/ArrayListHashMap.js

@@ -0,0 +1,37 @@
+import ArrayList from "./ArrayList.js";
+
+export default class ArrayListHashMap extends ArrayList {
+  constructor() {
+    super();
+    this.ids = new Map();
+  }
+
+  clear() {
+    super.clear();
+    this.ids.clear();
+  }
+
+  insert(article) {
+    super.insert(article);
+    this.ids.set(article.id, article);
+  }
+
+  remove(article) {
+    const id = article && article.id ? article.id : article;
+    super.remove(article);
+    this.ids.delete(id);
+  }
+
+  /*contains(id) {
+    return this.articles.includes(id);
+  }*/
+
+  contains(article) {
+    const id = article.id;
+    return this.ids.has(id);
+  }
+
+  find(id) {
+    return this.ids.get(id);
+  }
+}

package/model/datastructures/ArrayListHashMap.js.bk

@@ -0,0 +1,90 @@
+export default class ArrayListHashMap {
+  articles = [];
+  constructor() {
+    this.ids = new Map();
+  }
+
+  clear() {
+    this.articles = [];
+    this.ids.clear();
+  }
+
+  insert(article) {
+    this.articles.push(article);
+    this.ids.set(article.id, article);
+  }
+
+  remove(article) {
+    const id = article && article.id ? article.id : article;
+    this.articles = this.articles.filter((article) => article.id != id);
+    this.ids.delete(id);
+  }
+
+  /*contains(id) {
+    return this.articles.includes(id);
+  }*/
+
+  contains(article) {
+    const id = article.id;
+    return this.ids.has(id);
+  }
+
+  find(id) {
+    return this.ids.get(id);
+  }
+
+  formatter(tstamp) {
+    const date = new Date(tstamp);
+    /*const formatted = date.toLocaleString("de-DE", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false, // Ensures 24-hour format
+    });*/
+    const formatted = date;
+    return formatted;
+  }
+
+  async getRange(start, end, limit) {
+    let result = [];
+
+    const startTime = start ? new Date(start).getTime() : 0;
+    const endTime = end ? new Date(end).getTime() : Infinity;
+
+    for (const article of this.articles) {
+      const articleTime = new Date(article.createdAt).getTime();
+      if (articleTime >= startTime && articleTime <= endTime) {
+        result.push(article);
+      }
+    }
+
+    // Sort: Newest first (Descending)
+    result.sort((a, b) => b.createdAt - a.createdAt);
+    // Sort: Newest first (Descending), then by ID Descending for stability
+    /*result.sort((a, b) => {
+      const timeDiff = b.createdAt - a.createdAt;
+      if (timeDiff !== 0) return timeDiff;
+      return b.id - a.id;
+    });*/
+
+    if (limit && result.length > limit) {
+      result = result.slice(0, limit);
+    }
+
+    return result;
+  }
+
+  getAllArticles() {
+    return this.articles;
+  }
+
+  size() {
+    return this.articles.length;
+  }
+
+  get length() {
+    return this.size();
+  }
+}