@lexho111/plainblog 0.5.7 → 0.5.9

package/Blog.js

@@ -3,7 +3,7 @@ import crypto from "node:crypto";
 import fs from "fs";
 import { URLSearchParams } from "url";
 import Article from "./Article.js";
-import DatabaseModel from "./model/DatabaseModel3.js";
+import DatabaseModel from "./model/DatabaseModel.js";
 import { fetchData, postData } from "./model/APIModel.js";
 import { formatHTML, header, formatMarkdown, validate } from "./Formatter.js";
 import pkg from "./package.json" with { type: "json" };

package/README.md

@@ -1,6 +1,6 @@
 # Plainblog
 
-Plainblog is a simple blog generator to help you to set up and to maintain a minimalistic **single-page blog**. You can add new articles directly in the browser.
+Plainblog is a simple blog generator to help you to set up and to maintain a minimalistic **single-page blog**. You can add new articles directly in the browser. Your data will be stored by default in two file called _bloginfo.json_ and _articles.txt_.
 
 ## Installation
 
@@ -26,6 +26,41 @@ Now you can open your blog in your webbrowser on `http://localhost:8080`. Login
 
 ## More Features
 
+### set a Database Adapter
+
+#### connect to a sqlite database
+
+```
+import { SqliteAdapter } from "@lexho111/plainblog";
+const blog = new Blog();
+
+const sqliteAdapter = new SqliteAdapter({
+  dbname: "blog",
+});
+blog.setDatabaseAdapter(sqliteAdapter);
+
+await blog.init();
+blog.startServer(8080);
+```
+
+#### connect to a postgres database
+
+```
+import { PostgresAdapter } from "@lexho111/plainblog";
+const blog = new Blog();
+
+const postgresAdapter = new PostgresAdapter({
+  dbname: "blog",
+  username: "user",
+  password: "password",
+  host: "localhost",
+});
+blog.setDatabaseAdapter(postgresAdapter);
+
+await blog.init();
+blog.startServer(8080);
+```
+
 ### set an API to fetch data from an external database
 
 ```

package/articles.txt

@@ -0,0 +1,3 @@
+{"title":"Test Title from Jest","content":"This is the content of the test article.","createdAt":"2026-01-08T13:19:39.939Z"}
+{"title":"Test Title from Jest","content":"This is the content of the test article.","createdAt":"2026-01-08T13:34:38.866Z"}
+{"title":"Test Title from Jest","content":"This is the content of the test article.","createdAt":"2026-01-08T13:43:32.343Z"}

package/bloginfo.json

@@ -0,0 +1,3 @@
+{
+  "title": "Blog"
+}

package/index.js

@@ -1,5 +1,8 @@
 import Blog from "./Blog.js";
 import Article from "./Article.js";
+import FileAdapter from "./model/FileAdapter.js";
+import SqliteAdapter from "./model/SqliteAdapter.js";
+import PostgresAdapter from "./model/PostgresAdapter.js";
 
-export { Blog, Article };
+export { Blog, Article, FileAdapter, SqliteAdapter, PostgresAdapter };
 export default Blog;

package/model/{DatabaseModel3.js → DatabaseModel.js}

@@ -1,8 +1,10 @@
 import FileAdapter from "./FileAdapter.js";
 
 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);
     }

package/model/FileAdapter.js

@@ -1,12 +1,21 @@
-import { save as saveToFile, load as loadFromFile } from "./FileModel.js";
+import {
+  saveInfo,
+  loadInfo,
+  appendArticle,
+  loadArticles,
+  initFiles,
+} from "./FileModel.js";
 
 export default class FileAdapter {
+  dbtype = "file";
   constructor(options) {
-    this.filename = "blog.json";
+    this.infoFile = "bloginfo.json";
+    this.articlesFile = "articles.txt";
   }
 
   async initialize() {
     console.log("file adapter init");
+    await initFiles(this.infoFile, this.articlesFile);
   }
 
   test() {
@@ -14,42 +23,19 @@ export default class FileAdapter {
   }
 
   async getBlogTitle() {
-    const blogTitle = "TestBlog";
-    return new Promise((res, rej) => {
-      res(blogTitle);
-    });
+    const info = await loadInfo(this.infoFile);
+    return info.title || "Blog";
   }
 
   async save(newArticle) {
     if (!newArticle.createdAt) {
       newArticle.createdAt = new Date().toISOString();
     }
-
-    let blogTitle = "";
-    let articles = [];
-    try {
-      await loadFromFile(this.filename, (t, a) => {
-        blogTitle = t;
-        articles = a || [];
-      });
-    } catch (err) {
-      console.error(err);
-    }
-
-    articles.push(newArticle);
-    saveToFile(this.filename, { title: blogTitle, articles });
+    await appendArticle(this.articlesFile, newArticle);
   }
 
   async updateBlogTitle(newTitle) {
-    let articles = [];
-    try {
-      await loadFromFile(this.filename, (t, a) => {
-        articles = a || [];
-      });
-    } catch (err) {
-      console.error(err);
-    }
-    saveToFile(this.filename, { title: newTitle, articles });
+    await saveInfo(this.infoFile, { title: newTitle });
   }
 
   async findAll(
@@ -61,16 +47,15 @@ export default class FileAdapter {
   ) {
     let dbArticles = [];
     try {
-      await loadFromFile(this.filename, (title, articles) => {
-        if (Array.isArray(articles)) {
-          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);
-        }
-      });
+      const articles = await loadArticles(this.articlesFile);
+      if (Array.isArray(articles)) {
+        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);
+      }
     } catch (err) {
       console.error(err);
     }

package/model/FileModel.js

@@ -1,35 +1,49 @@
 import { promises as fs } from "fs";
 
-/** save blog content to file */
-export async function save(filename, data) {
-  if (!filename) {
-    console.error("Error: Filename not provided and not set previously.");
-    return;
-  }
+/** 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));
+}
 
+/** load blog info */
+export async function loadInfo(filename) {
   try {
-    await fs.writeFile(filename, JSON.stringify(data, null, 2));
-    console.log(`Blog data saved to ${filename}`);
+    const data = await fs.readFile(filename, "utf8");
+    return JSON.parse(data);
   } catch (err) {
-    console.error("Error saving blog data:", err);
+    return { title: "Blog" };
   }
 }
 
-/** load blog content from file */
-export async function load(filename, f) {
+/** append an article as a new line to the file */
+export async function appendArticle(filename, article) {
+  await fs.appendFile(filename, JSON.stringify(article) + "\n");
+}
+
+/** load all articles by reading line by line */
+export async function loadArticles(filename) {
   try {
     const data = await fs.readFile(filename, "utf8");
-    const jsonData = JSON.parse(data);
-    const title = jsonData.title;
-    const articles = jsonData.articles;
-    f(title, articles);
+    return data
+      .split("\n")
+      .filter((line) => line.trim() !== "")
+      .map((line) => JSON.parse(line));
+  } catch (err) {
+    return [];
+  }
+}
+
+/** ensure files exist */
+export async function initFiles(infoFilename, articlesFilename) {
+  try {
+    await fs.access(infoFilename);
+  } catch (err) {
+    await saveInfo(infoFilename, { title: "Blog" });
+  }
+
+  try {
+    await fs.access(articlesFilename);
   } catch (err) {
-    if (err.code === "ENOENT") {
-      const defaultData = { title: "Blog", articles: [] };
-      await save(filename, defaultData);
-      f(defaultData.title, defaultData.articles);
-    } else {
-      throw err;
-    }
+    await fs.writeFile(articlesFilename, "");
   }
 }

package/model/PostgresAdapter.js

@@ -0,0 +1,44 @@
+import { Sequelize, DataTypes, Op } from "sequelize";
+import SequelizeAdapter from "./SequelizeAdapter.js";
+
+export default class PostgresAdapter extends SequelizeAdapter {
+  dbtype = "postgres";
+
+  constructor(options = {}) {
+    super();
+    console.log(JSON.stringify(options));
+    this.username = options.username;
+    this.password = options.password;
+    this.host = options.host;
+    if (options.dbname) this.dbname = options.dbname;
+    if (options.dbport) this.dbport = options.dbport;
+    if (!this.username || !this.password || !this.host) {
+      throw new Error(
+        "PostgreSQL credentials not set. Please provide 'username', 'password', and 'host' in the options."
+      );
+    }
+  }
+
+  async initialize() {
+    console.log("initialize database");
+
+    try {
+      console.log(
+        `postgres://${this.username}:${this.password}@${this.host}:${this.dbport}/${this.dbname}`
+      );
+
+      this.sequelize = new Sequelize(
+        `postgres://${this.username}:${this.password}@${this.host}:${this.dbport}/${this.dbname}`,
+        { logging: false }
+      );
+    } catch (err) {
+      if (err.message.includes("Please install")) {
+        throw new Error(
+          "PostgreSQL driver is not installed. Please install it to use PostgresAdapter: npm install pg pg-hstore"
+        );
+      }
+      throw err;
+    }
+    await this.initializeModels();
+  }
+}

package/model/SequelizeAdapter.js

@@ -0,0 +1,121 @@
+import { Sequelize, DataTypes, Op } from "sequelize";
+
+export default class SequelizeAdapter {
+  username;
+  password;
+  host;
+  dbport = 5432;
+  dbname = "blog";
+
+  sequelize;
+  Article;
+  BlogInfo;
+
+  constructor(options = {}) {
+    console.log(JSON.stringify(options));
+
+    //let Sequelize, DataTypes, Op;
+    /*try {
+      const sequelizePkg = await import("sequelize");
+      Sequelize = sequelizePkg.Sequelize;
+      DataTypes = sequelizePkg.DataTypes;
+      //Op = sequelizePkg.Op;
+      //this.#Op = Op;
+    } catch (err) {
+      throw new Error(
+        "Sequelize is not installed. Please install it to use PostgresAdapter: npm install sequelize"
+      );
+    }*/
+
+    // throw new Error(`Error! ${databasetype} is an unknown database type.`);
+  }
+
+  async initializeModels() {
+    this.Article = this.sequelize.define(
+      "Article",
+      {
+        title: DataTypes.STRING,
+        content: DataTypes.TEXT,
+        createdAt: {
+          type: DataTypes.DATE,
+          defaultValue: DataTypes.NOW,
+        },
+        updatedAt: {
+          type: DataTypes.DATE,
+          defaultValue: DataTypes.NOW,
+        },
+      },
+      {
+        timestamps: true,
+      }
+    );
+
+    this.BlogInfo = this.sequelize.define(
+      "BlogInfo",
+      {
+        title: DataTypes.STRING,
+      },
+      {
+        timestamps: false,
+      }
+    );
+
+    // This creates the tables if they don't exist.
+    await this.sequelize.sync({ alter: true });
+    console.log("database tables synced and ready.");
+
+    // Check for and create the initial blog title right after syncing.
+    const blogInfoCount = await this.BlogInfo.count();
+    if (blogInfoCount === 0) {
+      await this.BlogInfo.create({ title: "My Default Blog Title" });
+      console.log("initialized blog title in database.");
+    }
+  }
+
+  // model
+  async findAll(
+    limit = 4,
+    offset = 0,
+    startId = null,
+    endId = null,
+    order = "DESC"
+  ) {
+    const where = {};
+    if (startId !== null && endId !== null) {
+      where.id = {
+        [Op.between]: [Math.min(startId, endId), Math.max(startId, endId)],
+      };
+    } else if (startId !== null) {
+      where.id = { [order === "DESC" ? Op.lte : Op.gte]: startId };
+    }
+    const options = {
+      where,
+      order: [
+        ["createdAt", order],
+        ["id", order],
+      ],
+      limit,
+      offset,
+    };
+    const articles = await this.Article.findAll(options);
+    return articles.map((article) => article.get({ plain: true }));
+  }
+
+  async save(newArticle) {
+    await this.Article.create(newArticle);
+    console.log("Added new article:", newArticle);
+  }
+
+  async getBlogTitle() {
+    // Find the first (and only) entry in the BlogInfo table.
+    const blogInfo = await this.BlogInfo.findOne();
+
+    return blogInfo.title;
+  }
+
+  async updateBlogTitle(newTitle) {
+    // Find the first (and only) entry and update its title.
+    // Using where: {} will always find the first row.
+    await this.BlogInfo.update({ title: newTitle }, { where: {} });
+  }
+}

package/model/SqliteAdapter.js

@@ -0,0 +1,30 @@
+import { Sequelize } from "sequelize";
+import SequelizeAdapter from "./SequelizeAdapter.js";
+
+export default class SqliteAdapter extends SequelizeAdapter {
+  constructor(options = {}) {
+    super();
+    console.log(JSON.stringify(options));
+
+    // Use the full path for the database file from the options.
+    if (options.dbname) this.dbname = options.dbname;
+  }
+
+  async initialize() {
+    try {
+      this.sequelize = new Sequelize({
+        dialect: "sqlite",
+        storage: this.dbname + ".db",
+        logging: false,
+      });
+      await this.initializeModels();
+    } catch (err) {
+      if (err.message.includes("Please install")) {
+        throw new Error(
+          "SQLite driver is not installed. Please install it: npm install sqlite3 --save-dev"
+        );
+      }
+      throw err;
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",
@@ -17,13 +17,11 @@
   "author": "lexho111",
   "license": "ISC",
   "dependencies": {
-    "autoprefixer": "^10.4.23",
     "child_process": "^1.0.2",
     "fs": "^0.0.1-security",
     "http": "^0.0.1-security",
     "node-fetch": "^3.3.2",
     "path": "^0.12.7",
-    "postcss": "^8.4.35",
     "sass": "^1.97.1",
     "url": "^0.11.4",
     "util": "^0.12.5"
@@ -32,6 +30,12 @@
     "dom-parser": "^1.1.5",
     "eslint": "^9.8.0",
     "eslint-plugin-jest": "^28.6.0",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "sqlite3": "^5.1.7"
+  },
+  "optionalDependencies": {
+    "pg": "^8.16.3",
+    "pg-hstore": "^2.3.4",
+    "sequelize": "^6.37.7"
   }
 }

package/public/styles.min.css

@@ -1,4 +1,4 @@
-body { font-family: Arial; }body { font-family: Arial, sans-serif; } h1 { color: #333; } .grid {
+body { font-family: Arial; } .grid {
   border: 0 solid #000;
   display: grid;
   gap: 0.25rem;
@@ -65,4 +65,4 @@ nav a:visited {
   }
 }
 
-/* source-hash: a07f631befba4b6bc703f8709f5ef455faafeff4e5f00b62f835576eea7fb529 */
+/* source-hash: bcb6644ec5b5c6f9685c9ad6c14ee551a6f908b8a2c372d3294e2d2e80d17fb7 */

package/test/model.test.js

@@ -2,7 +2,17 @@ import Blog from "../Blog.js";
 import Article from "../Article.js";
 import { fetchData, postData } from "../model/APIModel.js";
 import { server } from "./simpleServer.js";
-import { load as loadFromFile } from "../model/FileModel.js";
+import fs from "fs";
+
+import {
+  saveInfo,
+  loadInfo,
+  appendArticle,
+  loadArticles,
+  initFiles,
+} from "../model/FileModel.js";
+
+import SqliteAdapter from "../model/SqliteAdapter.js";
 
 function generateRandomContent(length) {
   let str = "";
@@ -16,21 +26,40 @@ function generateRandomContent(length) {
 }
 
 describe("File Model test", () => {
-  it("should load blog data from blog.json", async () => {
-    const blog = new Blog();
-    blog.setStyle(
-      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
-    );
+  it("should init files and load info", async () => {
+    const infoFile = "test_bloginfo.json";
+    const articlesFile = "test_articles.txt";
+
+    // Ensure clean state
+    if (fs.existsSync(infoFile)) fs.unlinkSync(infoFile);
+    if (fs.existsSync(articlesFile)) fs.unlinkSync(articlesFile);
+
+    await initFiles(infoFile, articlesFile);
+
+    const info = await loadInfo(infoFile);
+    expect(info.title).toBe("Blog");
 
+    // Cleanup
+    fs.unlinkSync(infoFile);
+    fs.unlinkSync(articlesFile);
+  });
+
+  it("should write to articles.txt file", async () => {
     const content = generateRandomContent(200);
+    const article = new Article("hello", content, new Date().toISOString());
+    const filename = "test_articles.txt";
 
-    const article = new Article("hello", content);
-    blog.addArticle(article);
+    await appendArticle(filename, article);
+    const articles = await loadArticles(filename);
 
-    await loadFromFile("blog.json", async (title) => {
-      expect(await blog.toHTML()).toContain(content);
-      expect(blog).toBeDefined();
-    });
+    // Compare properties since 'articles' contains plain objects, not Article instances
+    expect(articles.length).toBeGreaterThan(0);
+    const lastArticle = articles[articles.length - 1];
+    expect(lastArticle.title).toBe(article.title);
+    expect(lastArticle.content).toBe(article.content);
+
+    // Cleanup
+    if (fs.existsSync(filename)) fs.unlinkSync(filename);
   });
 });
 
@@ -117,11 +146,10 @@ describe("Database Model test", () => {
 
   it("should load blog data from sqlite database", async () => {
     const blog = new Blog();
-    blog.database.type = "sqlite";
-    blog.database.dbname = "test_" + Date.now();
-    blog.setStyle(
-      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
-    );
+    const sqliteAdapter = new SqliteAdapter({
+      dbname: "blog",
+    });
+    blog.setDatabaseAdapter(sqliteAdapter);
     await blog.init();
 
     const content = generateRandomContent(200);