@lexho111/plainblog 0.0.10 → 0.0.12

package/Blog.js

@@ -1,26 +1,69 @@
 import http from "http";
-import fetch from "node-fetch";
+import fs from "fs";
 import { URLSearchParams } from "url";
+import { fromEvent, firstValueFrom } from "rxjs";
+import { map, scan, takeUntil, last, defaultIfEmpty } from "rxjs/operators";
 import Article from "./Article.js";
 import DatabaseModel from "./model/DatabaseModel.js";
 import { fetchData, postData } from "./model/APIModel.js";
 import { save as saveToFile, load as loadFromFile } from "./model/fileModel.js";
+import { formatHTML, formatMarkdown, validate } from "./Formatter.js";
+import pkg from "./package.json" with { type: "json" };;
+import path from "path";
+import { fileURLToPath } from "url";
 
 export default class Blog {
   constructor() {
     this.title = "";
     this.articles = [];
-    this.style = "body { font-family: Arial; }";
+    this.styles = "";
     this.filename = null;
     this.#server = null;
 
     this.database = {
       type: "sqlite",
-      username: "user",
-      password: "password",
+      username: "user1",
+      password: "password1",
       host: "localhost",
       dbname: "blog",
     };
+
+    const version = pkg.version;
+    console.log(`version: ${version}`);
+
+    this.loadScripts();
+    
+    if(this.styles.length == 0) { // no style override specified via index.js
+      this.styles = "body { font-family: Arial; }"; // apply default style
+      this.loadStyles();
+    }
+    //console.log(styles)
+  }
+
+  loadScripts() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    this.scripts = "";
+    try {
+      console.log("load scripts")
+      this.scripts = fs.readFileSync(
+      path.join(__dirname, "scripts.min.js"),
+      "utf-8"
+    );
+    } catch(err) {
+      console.error("no scripts.min.js file found")
+    }
+  }
+
+  loadStyles() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    try {
+      this.styles = fs.readFileSync(
+      path.join(__dirname, "styles.min.css"), "utf-8");
+    } catch(err) {
+      console.error("no styles.min.css file found") 
+    } 
   }
 
   // Private fields
@@ -38,59 +81,82 @@ export default class Blog {
   }
 
   setStyle(style) {
-    this.style = style;
+    this.styles = style;
   }
 
   /** initializes database */
   async init() {
+    try {
+      this.styles = fs.readFileSync(
+        new URL("./styles.min.css", import.meta.url),
+        "utf-8"
+      );
+    } catch (err) {
+      console.error("Failed to load styles.min.css:", err);
+    }
     if (this.#isExternalAPI) {
+      console.log("external API");
       await this.loadFromAPI();
     } else {
-      console.log(`initialize ${this.database.type} database`);
+      console.log(`database: ${this.database.type}`);
       this.#databaseModel = new DatabaseModel(this.database);
+      console.log(`connected to database`);
       await this.#databaseModel.initialize();
       const dbTitle = await this.#databaseModel.getBlogTitle();
       const dbArticles = await this.#databaseModel.findAll();
-      const responseData = { title: dbTitle, articles: dbArticles };
+      let title = "";
+      if (this.title.length > 0) title = this.title; // use blog title if set
+      else title = dbTitle;
+      const responseData = { title: title, articles: dbArticles };
       this.#applyBlogData(responseData);
     }
   }
 
   /** post a blog article */
   async postArticle(req, res) {
-    let body = "";
+    // OLD CODE
+    /*let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
-    });
-
-    req.on("end", async () => {
-      const params = new URLSearchParams(body);
-      const title = params.get("title");
-      const content = params.get("content");
-
-      if (title && content) {
-        const newArticleData = { title, content };
-        try {
-          // Save the new article to the database via the ApiServer
-          if (this.#databaseModel)
-            await this.#databaseModel.save(newArticleData);
-          if (this.#isExternalAPI) postData(this.#apiUrl, newArticleData);
-          // Add the article to the local list for immediate display
-          this.addArticle(new Article(title, content));
-        } catch (error) {
-          console.error("Failed to post new article to API:", error);
-        }
+    });*/
+    // NEW CODE
+    // Create a stream of the body string
+    const body$ = fromEvent(req, "data").pipe(
+      map((chunk) => chunk.toString()),
+      scan((acc, chunk) => acc + chunk, ""), // Accumulate chunks
+      takeUntil(fromEvent(req, "end")), // Stop when 'end' emits
+      last(), // Emit only the final full string
+      defaultIfEmpty("") // Handle empty bodies
+    );
+
+    const body = await firstValueFrom(body$);
+
+    //req.on("end", async () => {
+    const params = new URLSearchParams(body);
+    const title = params.get("title");
+    const content = params.get("content");
+
+    if (title && content) {
+      const newArticleData = { title, content };
+      try {
+        // Save the new article to the database via the ApiServer
+        if (this.#databaseModel) await this.#databaseModel.save(newArticleData);
+        if (this.#isExternalAPI) await postData(this.#apiUrl, newArticleData);
+        // Add the article to the local list for immediate display
+        this.addArticle(new Article(title, content));
+      } catch (error) {
+        console.error("Failed to post new article to API:", error);
       }
+    }
 
-      res.writeHead(303, { Location: "/" });
-      res.end();
-    });
+    res.writeHead(303, { Location: "/" });
+    res.end();
+    //});
   }
 
   /** start a http server with default port 8080 */
   async startServer(port = 8080) {
     if (this.#databaseModel === undefined) await this.init(); // init blog if it didn't already happen
-    await this.#databaseModel.initialize();
 
     const server = http.createServer(async (req, res) => {
       // API routes
@@ -108,6 +174,8 @@ export default class Blog {
       } else if (req.method === "GET" && req.url === "/") {
         // load articles
 
+        this.loadScripts(); this.loadStyles();
+
         const html = await this.toHTML(); // render this blog to HTML
         res.writeHead(200, { "Content-Type": "text/html; charset=UTF-8" });
         res.end(html);
@@ -122,7 +190,7 @@ export default class Blog {
 
     return new Promise((resolve) => {
       this.#server.listen(port, () => {
-        console.log(`Server running at http://localhost:${port}/`);
+        console.log(`server running at http://localhost:${port}/`);
         resolve(); // Resolve the promise when the server is listening
       });
     });
@@ -181,8 +249,16 @@ export default class Blog {
   // controller
   /** everything that happens in /api  */
   async #jsonAPI(req, res) {
+    if(req.method === "GET") {
+    if(req.url === "/api" || req.url === "/api/") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const data = {
+        title: this.title
+      }
+      res.end(JSON.stringify(data));
+    }
     // GET all blog data
-    if (req.method === "GET" && req.url === "/api") {
+    if (req.url === "/api/articles") {
       // controller
       res.writeHead(200, { "Content-Type": "application/json" });
       const dbArticles = await this.#databaseModel.findAll();
@@ -195,7 +271,7 @@ export default class Blog {
     }
 
     // POST a new article
-    else if (req.method === "POST" && req.url === "/api/articles") {
+  } else if (req.method === "POST" && req.url === "/api/articles") {
       let body = "";
       req.on("data", (chunk) => (body += chunk.toString()));
       req.on("end", async () => {
@@ -219,76 +295,23 @@ export default class Blog {
 
   /** print markdown to the console */
   async print() {
-    console.log(`# ${this.title}`);
-    for (const article of this.articles) {
-      console.log(`## ${article.title}`);
-      console.log(article.content);
-    }
-  }
-
-  /** format this blog content to html */
-  formatter(data) {
-    return `<!DOCTYPE html>
-<html lang="de">
-  <head>
-    <meta charset="UTF-8">
-    <title>${data.title}</title>
-    <style>${data.style}</style>
-  </head>
-  <body>
-    <h1>${data.title}</h1>
-    <div style="width: 500px;">
-      <form action="/" method="POST">
-        <h3>Add a New Article</h3>
-        <input type="text" name="title" placeholder="Article Title" required style="display: block; width: 300px; margin-bottom: 10px;">
-        <textarea name="content" placeholder="Article Content" required style="display: block; width: 300px; height: 100px; margin-bottom: 10px;"></textarea>
-        <button type="submit">Add Article</button>
-      </form>
-      <hr>
-      ${data.articles
-        .map(
-          (article) => `
-      <article>
-        <h2>${article.title}</h2>
-        <p>${article.getContentShort()}</p>
-      </article>`
-        )
-        .join("")}
-    </div>
-  </body>
-</html>`;
-  }
-
-  validate(html) {
-    let test = true; // all tests passed
-    if (!(html.includes("<html") && html.includes("</html"))) {
-      console.error("html not ok");
-      test = false;
-    }
-    if (!(html.includes("<head") && html.includes("</head"))) {
-      console.error("head not ok");
-      test = false;
-    }
-    if (!(html.includes("<body") && html.includes("</body"))) {
-      console.error("body not ok");
-      test = false;
-    }
-    return test;
-  }
-
-  toHTMLFunc(data, formatter, validate) {
-    const html = formatter(data);
-    if (validate(html)) return html;
-    else throw new Error("Error. Invalid HTML!");
+    const data = {
+      title: this.title,
+      articles: this.articles,
+    };
+    const markdown = formatMarkdown(data);
+    console.log(markdown);
   }
 
   /** render this blog content to valid html */
   toHTML() {
     const data = {
       title: this.title,
-      style: this.style,
       articles: this.articles,
     };
-    return this.toHTMLFunc(data, this.formatter, this.validate);
+    
+    const html = formatHTML(data, this.scripts, this.styles);
+    if (validate(html)) return html;
+    else throw new Error("Error. Invalid HTML!");
   }
 }

package/Formatter.js

@@ -0,0 +1,65 @@
+/** format content to html */
+export function formatHTML(data, script, style) {
+  //export function formatHTML(data) {
+  const button = `<button type="button" onClick="fillWithContent();" style="margin: 4px;">generate random text</button>`;
+  return `<!DOCTYPE html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8">
+    <title>${data.title}</title>
+    <style>${style}</style>
+  </head>
+  <body>
+    <h1>${data.title}</h1>
+    <div style="width: 500px;">
+      <form action="/" method="POST">
+        <h3>Add a New Article</h3>
+        <input type="text" id="title" name="title" placeholder="Article Title" required style="display: block; width: 300px; margin-bottom: 10px;">
+        <textarea id="content" name="content" placeholder="Article Content" required style="display: block; width: 300px; height: 100px; margin-bottom: 10px;"></textarea>
+        <button type="submit">Add Article</button>${button}
+        <script>
+        ${script}
+        </script>
+      </form>
+      <hr>
+      ${data.articles
+        .map(
+          (article) => `
+      <article style="overflow-wrap: break-word;">
+        <h2>${article.title}</h2>
+        <p>${article.getContentShort()}</p>
+      </article>`
+        )
+        .join("")}
+    </div>
+  </body>
+</html>`;
+}
+
+export function formatMarkdown(data) {
+  let markdown = "";
+  markdown += `# ${data.title}\n`;
+  for (const article of data.articles) {
+    markdown += `## ${article.title}\n`;
+    markdown += article.content;
+    markdown += "\n";
+  }
+  return markdown;
+}
+
+export function validate(html) {
+  let test = true; // all tests passed
+  if (!(html.includes("<html") && html.includes("</html"))) {
+    console.error("html not ok");
+    test = false;
+  }
+  if (!(html.includes("<head") && html.includes("</head"))) {
+    console.error("head not ok");
+    test = false;
+  }
+  if (!(html.includes("<body") && html.includes("</body"))) {
+    console.error("body not ok");
+    test = false;
+  }
+  return test;
+}

package/README.md

@@ -42,10 +42,17 @@ await blog.init(); // load data from database
 blog.startServer(8080);
 ```
 
-### set an external API to fetch data from an external database
+### set an API to fetch data from an external database
 
 ```
+import Blog from "@lexho111/plainblog";
+
+const blog = new Blog();
 blog.setAPI("http://example.com:5432/blog")
+blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
+await blog.init(); // load data from database
+
+blog.startServer(8080);
 ```
 
 save data to file

package/model/APIModel.js

@@ -1,20 +1,31 @@
+import fetch from "node-fetch";
+import { defer, firstValueFrom, timer, of } from "rxjs";
+import { retry, mergeMap, catchError } from "rxjs/operators";
+
 // EXTERNAL DATA API
 
 /** fetch data from an URL */
 export async function fetchData(apiUrl) {
-  try {
-    const response = await fetch(apiUrl);
-
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
+  const request$ = defer(() => fetch(apiUrl)).pipe(
+    // 1. Check response status inside the stream
+    mergeMap(async (response) => {
+      if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+      return response.json();
+    }),
+    // 2. Retry 3 times, waiting 1s, 2s, 3s respectively
+    retry({
+      count: 3,
+      delay: (error, retryCount) => timer(retryCount * 1000),
+    }),
+    // 3. Handle final failure
+    catchError((error) => {
+      console.error("Failed to fetch data after retries:", error);
+      return of(null);
+    })
+  );
 
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    console.error("Failed to fetch data:", error);
-    return null;
-  }
+  return firstValueFrom(request$);
 }
 
 /** post data to an URL */

package/model/DatabaseModel.js

@@ -14,9 +14,11 @@ export default class DatabaseModel {
   constructor(options) {
     const databasetype = options.type; // the database type defines
     if (databasetype === "sqlite") {
+      // Use the full path for the database file from the options.
+      if (options.dbname) this.#dbname = options.dbname;
       this.#sequelize = new Sequelize({
         dialect: "sqlite",
-        storage: `./${this.#dbname}.db`,
+        storage: this.#dbname + ".db",
         logging: false,
       });
     } else if (databasetype === "postgres") {
@@ -49,7 +51,7 @@ export default class DatabaseModel {
       "Article",
       {
         title: DataTypes.STRING,
-        content: DataTypes.STRING,
+        content: DataTypes.TEXT,
       },
       {
         timestamps: false, // Assuming you don't need createdAt/updatedAt for this simple model
@@ -70,12 +72,13 @@ export default class DatabaseModel {
   async initialize() {
     // 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.");
+      console.log("initialized blog title in database.");
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",
@@ -19,6 +19,7 @@
     "node-fetch": "^3.3.2",
     "pg": "^8.16.3",
     "pg-hstore": "^2.3.4",
+    "rxjs": "^7.8.2",
     "sequelize": "^6.37.7",
     "sqlite3": "^5.1.7"
   },

package/scripts.min.js

@@ -0,0 +1,2 @@
+/*! gruntproject 2025-12-21 */
+function generateRandomContent(t){let n="";for(let e=0;e<t;e++){var o=Math.random()*("z".charCodeAt(0)-"A".charCodeAt(0)),o=String.fromCharCode("A".charCodeAt(0)+o);n+=o}return n}function fillWithContent(){var e=document.getElementById("title");document.getElementById("content").value=generateRandomContent(200),e.value=generateRandomContent(50)}

package/styles.min.css

@@ -0,0 +1 @@
+body{font-family:Courier;background-color:#d3d3d3}div{color:#000;width:500px}h1,h2,h3{font-weight:700}

package/test/blog.test.js

@@ -61,7 +61,7 @@ describe("test blog", () => {
       expect(html).toContain(style);
     }
   });
-  test("print method logs title and articles to console", () => {
+  test("print method logs title and articles to console", async () => {
     // Arrange: Set up the blog with a title and articles
     const myblog = new Blog();
     myblog.setTitle("My Test Blog");
@@ -71,12 +71,14 @@ describe("test blog", () => {
     const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
 
     // Act: Call the method we want to test
-    myblog.print();
+    await myblog.print();
 
     // Assert: Check if console.log was called with the correct strings
-    expect(consoleSpy).toHaveBeenCalledWith("# My Test Blog");
-    expect(consoleSpy).toHaveBeenCalledWith("## Article 1");
-    expect(consoleSpy).toHaveBeenCalledWith("Content 1");
+    expect(consoleSpy).toHaveBeenCalled();
+    const output = consoleSpy.mock.calls[0][0];
+    expect(output).toContain("# My Test Blog");
+    expect(output).toContain("## Article 1");
+    expect(output).toContain("Content 1");
 
     // Clean up the spy to restore the original console.log
     consoleSpy.mockRestore();

package/test/model.test.js

@@ -4,10 +4,10 @@ import { fetchData, postData } from "../model/APIModel.js";
 import { server } from "./simpleServer.js";
 
 function generateRandomContent(length) {
-  const char = "a";
   let str = "";
+  const char = "A";
   for (let i = 0; i < length; i++) {
-    const rnd = Math.random() * 10;
+    const rnd = Math.random() * ("z".charCodeAt(0) - "A".charCodeAt(0)); // A z.charCodeAt(0)"
     const char1 = String.fromCharCode(char.charCodeAt(0) + rnd);
     str += char1;
   }
@@ -59,9 +59,14 @@ describe("API Model test", () => {
     await new Promise((resolve) => {
       const req = {
         on: (event, cb) => {
-          if (event === "data") cb(`title=hello&content=${content}`);
-          if (event === "end") cb();
+          if (event === "data") {
+            setTimeout(() => cb(`title=hello&content=${content}`), 0);
+          }
+          if (event === "end") {
+            setTimeout(() => cb(), 10);
+          }
         },
+        off: () => {},
       };
       const res = {
         writeHead: () => {},
@@ -111,7 +116,7 @@ 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";
+    blog.database.dbname = "test_" + Date.now();
     blog.setStyle(
       "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
     );
@@ -122,9 +127,14 @@ describe("Database Model test", () => {
     await new Promise((resolve) => {
       const req = {
         on: (event, cb) => {
-          if (event === "data") cb(`title=hello&content=${content}`);
-          if (event === "end") cb();
+          if (event === "data") {
+            setTimeout(() => cb(`title=hello&content=${content}`), 0);
+          }
+          if (event === "end") {
+            setTimeout(() => cb(), 20);
+          }
         },
+        off: () => {},
       };
       const res = {
         writeHead: () => {},

package/test/server.test.js

@@ -11,8 +11,9 @@ import Blog from "../Blog.js";
  * blog.startServer(8080);
  */
 
-const PORT = 8080;
+const PORT = 8090;
 const apiBaseUrl = `http://localhost:${PORT}`;
+
 describe("server test", () => {
   const blog = new Blog(); // Create one blog instance for all tests
   blog.setTitle("My Blog");
@@ -23,6 +24,7 @@ describe("server test", () => {
     blog.setStyle(
       "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
     );
+    await blog.init();
     // Await it to ensure the server is running before tests start.
     await blog.startServer(PORT);
   });
@@ -33,12 +35,35 @@ describe("server test", () => {
     await blog.closeServer();
   });
 
-  test("should post a new article via /api/articles endpoint", async () => {
+  test("check if server responds to /", async () => {
+    // get articles from blog api
+    const response = await fetch(`${apiBaseUrl}/`, {
+      method: "GET",
+    });
+
+    expect(response.status).toBe(200);
+    const html = await response.text();
+    expect(html).toContain("My Blog");
+  });
+
+  test("check if server responds to /api", async () => {
+    // get articles from blog api
+    const response = await fetch(`${apiBaseUrl}/api`, {
+      method: "GET",
+    });
+
+    expect(response.status).toBe(200);
+    const responseData = await response.json();
+    expect(responseData.title).toBe("My Blog");
+  });
+
+  test("should post a new article via /api/articles", async () => {
     const newArticle = {
       title: "Test Title from Jest",
       content: "This is the content of the test article.",
     };
 
+    // post new article to the blog
     const response = await fetch(`${apiBaseUrl}/api/articles`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -48,5 +73,7 @@ describe("server test", () => {
     expect(response.status).toBe(201);
     const responseData = await response.json();
     expect(responseData).toEqual(newArticle);
+
+    expect(blog.toHTML()).toContain(newArticle.content); // does blog contain my new article?
   });
 });