@lexho111/plainblog 0.0.9 → 0.0.10

package/Blog.js

@@ -1,9 +1,10 @@
 import http from "http";
 import fetch from "node-fetch";
-import { promises as fs } from "fs";
 import { URLSearchParams } from "url";
 import Article from "./Article.js";
-import ApiServer from "./model.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";
 
 export default class Blog {
   constructor() {
@@ -24,9 +25,9 @@ export default class Blog {
 
   // Private fields
   #server = null;
-  #apiServer;
+  #databaseModel;
   #isExternalAPI = false;
-  #apiDataLoaded = false;
+  #apiUrl = "";
 
   setTitle(title) {
     this.title = title;
@@ -43,56 +44,20 @@ export default class Blog {
   /** initializes database */
   async init() {
     if (this.#isExternalAPI) {
-      await this.loadFromAPI(this.#APIUrl);
+      await this.loadFromAPI();
     } else {
       console.log(`initialize ${this.database.type} database`);
-      this.#apiServer = new ApiServer(this.database);
-      const dbTitle = await this.#apiServer.getBlogTitle();
-      const dbArticles = await this.#apiServer.findAll();
+      this.#databaseModel = new DatabaseModel(this.database);
+      await this.#databaseModel.initialize();
+      const dbTitle = await this.#databaseModel.getBlogTitle();
+      const dbArticles = await this.#databaseModel.findAll();
       const responseData = { title: dbTitle, articles: dbArticles };
-      this.#loadFromData(responseData);
+      this.#applyBlogData(responseData);
     }
   }
 
-  // EXTERNAL DATA API
-  #APIUrl = "";
-
-  setAPI(APIUrl) {
-    this.#APIUrl = APIUrl;
-    this.#isExternalAPI = true;
-  }
-
-  /** fetch data from an URL */
-  async #fetchDataFromApi(apiUrl) {
-    try {
-      const response = await fetch(apiUrl);
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      console.error("Failed to fetch data:", error);
-      return null;
-    }
-  }
-
-  /** post data to an URL */
-  async #postDataToApi(apiUrl, postData) {
-    const response = await fetch(apiUrl, {
-      method: "POST",
-      body: JSON.stringify(postData),
-      headers: { "Content-Type": "application/json" },
-    });
-
-    const data = await response.json();
-    return data;
-  }
-
   /** post a blog article */
-  async #postArticle(req, res) {
+  async postArticle(req, res) {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
@@ -107,7 +72,9 @@ export default class Blog {
         const newArticleData = { title, content };
         try {
           // Save the new article to the database via the ApiServer
-          await this.#apiServer.save(newArticleData);
+          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) {
@@ -120,42 +87,10 @@ export default class Blog {
     });
   }
 
-  /** everything that happens in /api  */
-  async #jsonAPI(req, res) {
-    // GET all blog data
-    if (req.method === "GET" && req.url === "/api") {
-      // controller
-      res.writeHead(200, { "Content-Type": "application/json" });
-      const dbArticles = await this.#apiServer.findAll();
-      const responseData = {
-        title: this.title, // Keep the title from the original constant
-        articles: dbArticles,
-      };
-      console.log(`responseData: ${responseData}`);
-      res.end(JSON.stringify(responseData));
-    }
-
-    // POST a new article
-    else if (req.method === "POST" && req.url === "/api/articles") {
-      let body = "";
-      req.on("data", (chunk) => (body += chunk.toString()));
-      req.on("end", async () => {
-        const newArticle = JSON.parse(body);
-
-        // local
-        await this.#apiServer.save(newArticle); // --> to api server
-        // extern
-
-        res.writeHead(201, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(newArticle));
-      });
-    }
-  }
-
   /** start a http server with default port 8080 */
   async startServer(port = 8080) {
-    if (this.#apiServer === undefined) this.init(); // init blog if it didn't already happen
-    await this.#apiServer.initialize();
+    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
@@ -167,8 +102,8 @@ export default class Blog {
       // Web Page Routes
       // POST new article
       if (req.method === "POST" && req.url === "/") {
-        await this.#apiServer.updateBlogTitle(this.title);
-        await this.#postArticle(req, res);
+        await this.#databaseModel.updateBlogTitle(this.title);
+        await this.postArticle(req, res);
         // GET artciles
       } else if (req.method === "GET" && req.url === "/") {
         // load articles
@@ -207,42 +142,8 @@ export default class Blog {
     });
   }
 
-  /** save blog content to file */
-  async save(filename = this.filename) {
-    if (this.#apiServer === undefined) this.init(); // init blog if it didn't already happen
-    //await this.#apiServer.initialize();
-    if (this.#isExternalAPI) await this.loadFromAPI(this.#APIUrl);
-    if (!filename) {
-      console.error("Error: Filename not provided and not set previously.");
-      return;
-    }
-    this.filename = filename;
-    const data = {
-      title: this.title,
-      articles: this.articles,
-    };
-
-    try {
-      await fs.writeFile(filename, JSON.stringify(data, null, 2));
-      console.log(`Blog data saved to ${filename}`);
-    } catch (err) {
-      console.error("Error saving blog data:", err);
-    }
-  }
-
-  /** load blog content from file */
-  async load(filename) {
-    this.filename = filename;
-    const data = await fs.readFile(filename, "utf8");
-    const jsonData = JSON.parse(data);
-    this.title = jsonData.title;
-    this.articles = jsonData.articles.map(
-      (article) => new Article(article.title, article.content)
-    );
-  }
-
   /** Populates the blog's title and articles from a data object. */
-  #loadFromData(data) {
+  #applyBlogData(data) {
     this.articles = []; // Clear existing articles before loading new ones
     this.setTitle(data.title);
     // Assuming the API returns an array of objects with title and content
@@ -250,17 +151,72 @@ export default class Blog {
       for (const articleData of data.articles) {
         this.addArticle(new Article(articleData.title, articleData.content));
       }
-      this.#apiDataLoaded = true; // Mark that we have successfully loaded data
     }
   }
 
-  async loadFromAPI(apiUrl) {
-    const data = await this.#fetchDataFromApi(apiUrl);
+  async save(filename = this.filename) {
+    if (this.#databaseModel === undefined) this.init(); // init blog if it didn't already happen
+    //await this.#apiServer.initialize();
+    if (this.#isExternalAPI) await this.loadFromAPI();
+    const blogData = { title: this.title, articles: this.articles };
+    saveToFile(filename, blogData);
+  }
+
+  async load(filename) {
+    loadFromFile(filename, (title, articles) => {
+      this.title = title;
+      this.articles = articles.map(
+        (article) => new Article(article.title, article.content)
+      );
+    });
+  }
+
+  async loadFromAPI() {
+    const data = await fetchData(this.#apiUrl);
     if (data) {
-      this.#loadFromData(data);
+      this.#applyBlogData(data);
+    }
+  }
+
+  // controller
+  /** everything that happens in /api  */
+  async #jsonAPI(req, res) {
+    // GET all blog data
+    if (req.method === "GET" && req.url === "/api") {
+      // controller
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const dbArticles = await this.#databaseModel.findAll();
+      const responseData = {
+        title: this.title, // Keep the title from the original constant
+        articles: dbArticles,
+      };
+      console.log(`responseData: ${responseData}`);
+      res.end(JSON.stringify(responseData));
+    }
+
+    // POST a new article
+    else if (req.method === "POST" && req.url === "/api/articles") {
+      let body = "";
+      req.on("data", (chunk) => (body += chunk.toString()));
+      req.on("end", async () => {
+        const newArticle = JSON.parse(body);
+
+        // local
+        await this.#databaseModel.save(newArticle); // --> to api server
+        // extern
+
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(newArticle));
+      });
     }
   }
 
+  /** set external API */
+  setAPI(APIUrl) {
+    this.#apiUrl = APIUrl;
+    this.#isExternalAPI = true;
+  }
+
   /** print markdown to the console */
   async print() {
     console.log(`# ${this.title}`);
@@ -270,22 +226,17 @@ export default class Blog {
     }
   }
 
-  /** render this blog content to html */
-  async toHTML() {
-    // If we have an API URL and haven't loaded data yet, load it now.
-    if (this.#APIUrl && !this.#apiDataLoaded) {
-      await this.loadFromAPI(this.#APIUrl);
-    }
-
+  /** format this blog content to html */
+  formatter(data) {
     return `<!DOCTYPE html>
 <html lang="de">
   <head>
     <meta charset="UTF-8">
-    <title>${this.title}</title>
-    <style>${this.style}</style>
+    <title>${data.title}</title>
+    <style>${data.style}</style>
   </head>
   <body>
-    <h1>${this.title}</h1>
+    <h1>${data.title}</h1>
     <div style="width: 500px;">
       <form action="/" method="POST">
         <h3>Add a New Article</h3>
@@ -294,7 +245,7 @@ export default class Blog {
         <button type="submit">Add Article</button>
       </form>
       <hr>
-      ${this.articles
+      ${data.articles
         .map(
           (article) => `
       <article>
@@ -307,4 +258,37 @@ export default class Blog {
   </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!");
+  }
+
+  /** 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);
+  }
 }

package/blog.json

@@ -0,0 +1,9 @@
+{
+  "title": "",
+  "articles": [
+    {
+      "title": "hello",
+      "content": "hello world!"
+    }
+  ]
+}

package/model/APIModel.js

@@ -0,0 +1,30 @@
+// 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 data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch data:", error);
+    return null;
+  }
+}
+
+/** post data to an URL */
+export async function postData(apiUrl, postData) {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    body: JSON.stringify(postData),
+    headers: { "Content-Type": "application/json" },
+  });
+
+  const data = await response.json();
+  return data;
+}

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

@@ -1,6 +1,6 @@
 import { Sequelize, DataTypes } from "sequelize";
 
-export default class ApiServer {
+export default class DatabaseModel {
   #username;
   #password;
   #host;
@@ -16,7 +16,7 @@ export default class ApiServer {
     if (databasetype === "sqlite") {
       this.#sequelize = new Sequelize({
         dialect: "sqlite",
-        storage: "./blog.db",
+        storage: `./${this.#dbname}.db`,
         logging: false,
       });
     } else if (databasetype === "postgres") {

package/model/fileModel.js

@@ -0,0 +1,25 @@
+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;
+  }
+
+  try {
+    await fs.writeFile(filename, JSON.stringify(data, null, 2));
+    console.log(`Blog data saved to ${filename}`);
+  } catch (err) {
+    console.error("Error saving blog data:", err);
+  }
+}
+
+/** load blog content from file */
+export async function load(filename, f) {
+  const data = await fs.readFile(filename, "utf8");
+  const jsonData = JSON.parse(data);
+  const title = jsonData.title;
+  const articles = jsonData.articles;
+  f(title, articles);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",

package/test/model.test.js

@@ -0,0 +1,141 @@
+import Blog from "../Blog.js";
+import Article from "../Article.js";
+import { fetchData, postData } from "../model/APIModel.js";
+import { server } from "./simpleServer.js";
+
+function generateRandomContent(length) {
+  const char = "a";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    const rnd = Math.random() * 10;
+    const char1 = String.fromCharCode(char.charCodeAt(0) + rnd);
+    str += char1;
+  }
+  return str;
+}
+
+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; }"
+    );
+
+    const content = generateRandomContent(200);
+
+    const article = new Article("hello", content);
+    blog.addArticle(article);
+
+    await blog.load("blog.json");
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+});
+
+describe("API Model test", () => {
+  beforeAll(() => {
+    const port = 8081;
+    server.listen(port, () => {
+      console.log(`Simple server running at http://localhost:${port}/`);
+    });
+  });
+  afterAll(() => {
+    return new Promise((done) => {
+      server.close(done);
+    });
+  });
+
+  it("should load blog data from API", async () => {
+    const blog = new Blog();
+    blog.setAPI("http://localhost:8081/blog");
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+    await blog.init();
+
+    const content = generateRandomContent(200);
+
+    await new Promise((resolve) => {
+      const req = {
+        on: (event, cb) => {
+          if (event === "data") cb(`title=hello&content=${content}`);
+          if (event === "end") cb();
+        },
+      };
+      const res = {
+        writeHead: () => {},
+        end: resolve,
+      };
+      blog.postArticle(req, res);
+    });
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+
+  it("should fetch data from API", async () => {
+    const API = "http://localhost:8081/blog";
+    const data = await fetchData(API);
+    expect(data).toBeDefined();
+    expect(data.title).toBe("Mock Blog Title");
+    expect(data.articles).toHaveLength(2);
+  });
+
+  it("should post blog data to API", async () => {
+    const API = "http://localhost:8081/blog";
+    const newArticle = { title: "New Post", content: "New Content" };
+    const data = await postData(API, newArticle);
+    expect(data).toEqual(newArticle);
+  });
+});
+
+describe("Database Model test", () => {
+  it("should be empty", async () => {
+    const blog = new Blog();
+    blog.database.type = "sqlite";
+    blog.database.dbname = "test";
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+
+    //const article = new Article("hello", "hello world1!");
+    //blog.postArticle(article);
+
+    //await blog.load("blog.json");
+
+    expect(await blog.toHTML()).not.toContain("<article>");
+    expect(blog).toBeDefined();
+  });
+
+  it("should load blog data from sqlite database", async () => {
+    const blog = new Blog();
+    blog.database.type = "sqlite";
+    blog.database.dbname = "test";
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+    await blog.init();
+
+    const content = generateRandomContent(200);
+
+    await new Promise((resolve) => {
+      const req = {
+        on: (event, cb) => {
+          if (event === "data") cb(`title=hello&content=${content}`);
+          if (event === "end") cb();
+        },
+      };
+      const res = {
+        writeHead: () => {},
+        end: resolve,
+      };
+      blog.postArticle(req, res);
+    });
+
+    //await blog.load("blog.json");
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+});

package/test/simpleServer.js

@@ -0,0 +1,43 @@
+import http from "http";
+
+const port = 8081;
+
+export const server = http.createServer((req, res) => {
+  // Set CORS headers to allow requests from different origins if needed
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  if (req.url === "/blog") {
+    if (req.method === "GET") {
+      const data = {
+        title: "Mock Blog Title",
+        articles: [
+          { title: "Mock Article 1", content: "Content of mock article 1" },
+          { title: "Mock Article 2", content: "Content of mock article 2" },
+        ],
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data));
+    } else if (req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => (body += chunk.toString()));
+      req.on("end", () => {
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(body); // Echo the received data back
+      });
+    } else {
+      res.writeHead(405); // Method Not Allowed
+      res.end();
+    }
+  } else {
+    res.writeHead(404); // Not Found
+    res.end();
+  }
+});