@lexho111/plainblog 0.0.8 → 0.0.10

package/Blog.js

@@ -1,8 +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 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() {
@@ -10,34 +12,22 @@ export default class Blog {
     this.articles = [];
     this.style = "body { font-family: Arial; }";
     this.filename = null;
-  }
-
-  async fetchDataFromApi(apiUrl) {
-    try {
-      const response = await fetch(apiUrl);
+    this.#server = null;
 
-      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;
-    }
+    this.database = {
+      type: "sqlite",
+      username: "user",
+      password: "password",
+      host: "localhost",
+      dbname: "blog",
+    };
   }
 
-  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;
-  }
+  // Private fields
+  #server = null;
+  #databaseModel;
+  #isExternalAPI = false;
+  #apiUrl = "";
 
   setTitle(title) {
     this.title = title;
@@ -51,102 +41,184 @@ export default class Blog {
     this.style = style;
   }
 
-  APIUrl = "";
+  /** initializes database */
+  async init() {
+    if (this.#isExternalAPI) {
+      await this.loadFromAPI();
+    } else {
+      console.log(`initialize ${this.database.type} database`);
+      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.#applyBlogData(responseData);
+    }
+  }
 
-  setAPI(APIUrl) {
-    this.APIUrl = APIUrl;
+  /** post a blog article */
+  async postArticle(req, res) {
+    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);
+        }
+      }
+
+      res.writeHead(303, { Location: "/" });
+      res.end();
+    });
   }
 
+  /** start a http server with default port 8080 */
   async startServer(port = 8080) {
-    if (this.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
+    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) => {
-      if (req.method === "POST") {
-        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 newArticle = new Article(title, content);
-            this.addArticle(newArticle);
-
-            // Post the new article to the backend API
-            try {
-              const postUrl = new URL(this.APIUrl);
-              postUrl.pathname = "/blog/articles";
-              await this.postDataToApi(postUrl.toString(), newArticle);
-            } catch (error) {
-              console.error("Failed to post new article to API:", error);
-            }
-          }
-
-          // Redirect to the homepage to show the new article
-          res.writeHead(303, { Location: "/" });
-          res.end();
-        });
-      } else {
-        const html = await this.toHTML();
+      // API routes
+      if (req.url.startsWith("/api")) {
+        await this.#jsonAPI(req, res);
+        return;
+      }
+
+      // Web Page Routes
+      // POST new article
+      if (req.method === "POST" && req.url === "/") {
+        await this.#databaseModel.updateBlogTitle(this.title);
+        await this.postArticle(req, res);
+        // GET artciles
+      } else if (req.method === "GET" && req.url === "/") {
+        // load articles
+
+        const html = await this.toHTML(); // render this blog to HTML
         res.writeHead(200, { "Content-Type": "text/html; charset=UTF-8" });
         res.end(html);
+      } else {
+        // Error 404
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ message: "Not Found" }));
       }
     });
 
-    server.listen(port, () => {
-      console.log(`Server running at http://localhost:${port}/`);
+    this.#server = server;
+
+    return new Promise((resolve) => {
+      this.#server.listen(port, () => {
+        console.log(`Server running at http://localhost:${port}/`);
+        resolve(); // Resolve the promise when the server is listening
+      });
+    });
+  } // http server
+
+  async closeServer() {
+    return new Promise((resolve, reject) => {
+      if (this.#server) {
+        this.#server.close((err) => {
+          if (err) return reject(err);
+          console.log("Server closed.");
+          resolve();
+        });
+      } else {
+        resolve(); // Nothing to close
+      }
     });
   }
 
-  async save(filename = this.filename) {
-    if (this.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
-    if (!filename) {
-      console.error("Error: Filename not provided and not set previously.");
-      return;
+  /** Populates the blog's title and articles from a data object. */
+  #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
+    if (data.articles && Array.isArray(data.articles)) {
+      for (const articleData of data.articles) {
+        this.addArticle(new Article(articleData.title, articleData.content));
+      }
     }
-    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);
-    }
+  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) {
-    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)
-    );
+    loadFromFile(filename, (title, articles) => {
+      this.title = title;
+      this.articles = articles.map(
+        (article) => new Article(article.title, article.content)
+      );
+    });
   }
 
-  async loadFromAPI(apiUrl) {
-    const data = await this.fetchDataFromApi(apiUrl);
+  async loadFromAPI() {
+    const data = await fetchData(this.#apiUrl);
     if (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
-      if (data.articles && Array.isArray(data.articles)) {
-        for (const articleData of data.articles) {
-          this.addArticle(new Article(articleData.title, articleData.content));
-        }
-        this.apiDataLoaded = true; // Mark that we have successfully loaded 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() {
-    if (this.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
     console.log(`# ${this.title}`);
     for (const article of this.articles) {
       console.log(`## ${article.title}`);
@@ -154,21 +226,17 @@ export default class Blog {
     }
   }
 
-  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>
@@ -177,7 +245,7 @@ export default class Blog {
         <button type="submit">Add Article</button>
       </form>
       <hr>
-      ${this.articles
+      ${data.articles
         .map(
           (article) => `
       <article>
@@ -190,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/README.md

@@ -2,7 +2,7 @@
 
 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. Articles are stored in a file or a database specified via an API.
 
-## Install
+## Installation
 
 ```
 npm install @lexho111/plainblog
@@ -11,7 +11,7 @@ npm install @lexho111/plainblog
 ## Quick Start
 
 ```
-import { Blog } from "@lexho111/plainblog";
+import Blog from "@lexho111/plainblog";
 
 const blog = new Blog();
 blog.setTitle("My Blog");
@@ -24,49 +24,43 @@ Now you can start to add articles to your blog via your webbrowser on `http://lo
 
 ## More Features
 
-set an API to fetch data from an external database
+**SQLite** is the default database. But you can use **PostgreSQL** instead.
 
-```
-blog.setAPI("http://localhost:8081/blog")
-```
-
-### run api server with sqlite database
+### run api server with postgres database
 
 ```
-import { Blog, storageserver} from "@lexho111/plainblog";
-await storageserver("sqlite", 8081); // you can use a postgres db too
+import Blog from "@lexho111/plainblog";
+
 const blog = new Blog();
-blog.setAPI(storageserver.getAPIURL());
+blog.database.type = "postgres";
+blog.database.user = "user";
+blog.database.password = "password";
+blog.database.host = "localhost";
 blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
+await blog.init(); // load data from database
 
 blog.startServer(8080);
 ```
 
-### run api server with postgres database
+### set an external API to fetch data from an external database
 
 ```
-docker run -p 5432:5432 --name postgresdb --restart always -e POSTGRES_USER=user -e POSTGRES_PASSWORD=password -e POSTGRES_DB=blog  -v db_data:/var/lib/postgresql/data -d  postgres:13
+blog.setAPI("http://example.com:5432/blog")
 ```
 
+save data to file
+
 ```
-import { Blog, storageserver} from "@lexho111/plainblog";
+import Blog from "@lexho111/plainblog";
+import { Article } from "@lexho111/plainblog";
 
-storageserver.setUsername("username");
-storageserver.setPassword("password");
-storageserver.setHost("localhost");
-await storageserver.start("postgres", 8081);
 const blog = new Blog();
-blog.setAPI(storageserver.getAPIURL());
 blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
 
-blog.startServer(8080);
-```
-
-save data to file
+const article = new Article("hello", "hello world!");
+blog.addArticle(article);
 
-```
-# save your blog to 'myblog.json'
-await blog.save("myblog.json");
+blog.save("blog.json");
 
 # load data from 'myblog.json'
 await blog.load("myblog.json");

package/blog.json

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

package/index.js

@@ -1,5 +1,5 @@
 import Blog from "./Blog.js";
 import Article from "./Article.js";
-import storageserver from "./api-server.js";
 
-export { Blog, Article, storageserver };
+export { Blog, Article };
+export default Blog;

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/DatabaseModel.js

@@ -0,0 +1,104 @@
+import { Sequelize, DataTypes } from "sequelize";
+
+export default class DatabaseModel {
+  #username;
+  #password;
+  #host;
+  #dbport = 5432;
+  #dbname = "blog";
+
+  #sequelize;
+  #Article;
+  #BlogInfo;
+
+  constructor(options) {
+    const databasetype = options.type; // the database type defines
+    if (databasetype === "sqlite") {
+      this.#sequelize = new Sequelize({
+        dialect: "sqlite",
+        storage: `./${this.#dbname}.db`,
+        logging: false,
+      });
+    } else if (databasetype === "postgres") {
+      this.#username = options.username;
+      this.#password = options.password;
+      this.#host = options.host;
+      if (options.dbname) this.#dbname = options.dbname;
+      if (!this.#username || !this.#password || !this.#host) {
+        throw new Error(
+          "PostgreSQL credentials not set. Please provide 'username', 'password', and 'host' in the options."
+        );
+      }
+      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 }
+      );
+    } else {
+      throw new Error(`Error! ${databasetype} is an unknown database type.`);
+    }
+
+    this.#Article = this.#sequelize.define(
+      "Article",
+      {
+        title: DataTypes.STRING,
+        content: DataTypes.STRING,
+      },
+      {
+        timestamps: false, // Assuming you don't need createdAt/updatedAt for this simple model
+      }
+    );
+
+    this.#BlogInfo = this.#sequelize.define(
+      "BlogInfo",
+      {
+        title: DataTypes.STRING,
+      },
+      {
+        timestamps: false,
+      }
+    );
+  }
+
+  async initialize() {
+    // This creates the tables if they don't exist.
+    await this.#sequelize.sync({ alter: true });
+
+    // 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() {
+    return this.#Article.findAll();
+  }
+
+  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/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.8",
+  "version": "0.0.10",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",

package/test/article.test.js

@@ -7,7 +7,7 @@ test("get content", () => {
   expect(content).toContain("text text text");
 });
 
-test("get shortened content", () => {
+test("get shortened content 1", () => {
   const article = new Article("title", "text text text");
   const content = article.getContentShort();
   expect(article.title).toContain("title");
@@ -16,7 +16,7 @@ test("get shortened content", () => {
   expect(content).not.toContain("...");
 });
 
-test("get shortened content", () => {
+test("get shortened content 2", () => {
   let text = "text";
   for (let i = 0; i < 500; i++) {
     text += " ";

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/server.test.js

@@ -1,29 +1,52 @@
-import { start as startAPIServer } from "../api-server.js";
 import fetch from "node-fetch";
+import Blog from "../Blog.js";
 
-describe("API Server Health Check", () => {
-  let server;
-  const PORT = 8085;
-  const apiBaseUrl = `http://localhost:${PORT}`;
+/** this is a test for
+ * import Blog from "@lexho111/plainblog";
+ *
+ * const blog = new Blog();
+ * blog.setTitle("My Blog");
+ * blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
+ *
+ * blog.startServer(8080);
+ */
 
+const PORT = 8080;
+const apiBaseUrl = `http://localhost:${PORT}`;
+describe("server test", () => {
+  const blog = new Blog(); // Create one blog instance for all tests
+  blog.setTitle("My Blog");
+
+  // Use beforeAll to set up and start the server once before any tests run
   beforeAll(async () => {
-    // how about to use in-memory database?
-    server = await startAPIServer("sqlite", PORT);
+    //blog.database.type = "sqlite";
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+    // Await it to ensure the server is running before tests start.
+    await blog.startServer(PORT);
   });
 
-  afterAll((done) => {
-    server.close(() => {
-      done();
-    });
+  // Use afterAll to shut down the server once after all tests have finished
+  afterAll(async () => {
+    // Await the closing of the server to ensure a clean shutdown.
+    await blog.closeServer();
   });
 
-  test("should respond with 200 OK on the /health endpoint", async () => {
-    const response = await fetch(`${apiBaseUrl}/health`);
+  test("should post a new article via /api/articles endpoint", async () => {
+    const newArticle = {
+      title: "Test Title from Jest",
+      content: "This is the content of the test article.",
+    };
 
-    // Check for a successful status code
-    expect(response.status).toBe(200);
+    const response = await fetch(`${apiBaseUrl}/api/articles`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(newArticle),
+    });
 
-    const body = await response.json();
-    expect(body).toEqual({ status: "ok" });
+    expect(response.status).toBe(201);
+    const responseData = await response.json();
+    expect(responseData).toEqual(newArticle);
   });
 });

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();
+  }
+});

package/api-server.js

@@ -1,175 +0,0 @@
-import http from "http";
-import { Sequelize, DataTypes } from "sequelize";
-
-// This is a simple API server that provides blog data.
-// This is the data that our API will serve, similar to a myblog.json file.
-const blogData = {
-  title: "My Blog from the API",
-  articles: [
-    {
-      title: "First API Post",
-      content: "This article was loaded from our new external API server!",
-    },
-    {
-      title: "REST is Cool",
-      content:
-        "Using a REST API allows us to separate our frontend from our backend.",
-    },
-  ],
-};
-
-let username;
-let password;
-let host;
-const dbport = 5432;
-const dbname = process.env.POSTGRES_DB || "blog";
-
-export function setUsername(username1) {
-  username = username1;
-}
-export function setPassword(password1) {
-  password = password1;
-}
-export function setHost(host1) {
-  host = host1;
-}
-
-let serverPort = 8081; // Default port
-
-export async function start(databasetype, port = 8081) {
-  let sequelize;
-  serverPort = port; // Update the port for getAPIURL
-
-  if (databasetype === "sqlite") {
-    sequelize = new Sequelize({
-      dialect: "sqlite",
-      storage: "./blog.db",
-      logging: false,
-    });
-  } else if (databasetype === "postgres") {
-    if (!username || !password || !host) {
-      throw new Error(
-        "PostgreSQL credentials not set. Please use setUsername(), setPassword(), and setHost() before starting the server."
-      );
-    }
-
-    sequelize = new Sequelize(
-      `postgres://${username}:${password}@${host}:${dbport}/${dbname}`,
-      { logging: false }
-    );
-  }
-
-  const Article = sequelize.define(
-    "Article",
-    {
-      title: DataTypes.STRING,
-      content: DataTypes.STRING,
-    },
-    {
-      timestamps: false, // Assuming you don't need createdAt/updatedAt for this simple model
-    }
-  );
-
-  try {
-    // The connectWithRetry logic is now integrated here and properly awaited.
-    let retries = 5;
-    while (retries) {
-      try {
-        await sequelize.authenticate();
-        console.log("Connection has been established successfully.");
-
-        // Sync all models and populate data
-        await sequelize.sync({ alter: true });
-        console.log("All models were synchronized successfully.");
-
-        if ((await Article.count()) === 0) {
-          for (const articleData of blogData.articles) {
-            await Article.create(articleData);
-          }
-          console.log("Initial blog data populated.");
-        }
-        break; // Success, exit retry loop
-      } catch (err) {
-        // For sqlite, we don't need to retry, just throw the error.
-        if (databasetype === "sqlite") throw err;
-
-        console.error("Unable to connect to the database:", err.name);
-        retries -= 1;
-        console.log(`Retries left: ${retries}`);
-        if (retries === 0) throw err; // Throw error if max retries reached
-        await new Promise((res) => setTimeout(res, 5000));
-      }
-    }
-
-    const server = http.createServer(async (req, res) => {
-      // Set CORS headers for all responses
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-
-      // Handle preflight CORS requests
-      if (req.method === "OPTIONS") {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-
-      // Health check endpoint
-      if (req.method === "GET" && req.url === "/health") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok" }));
-        return;
-      }
-
-      // GET all blog data
-      if (req.method === "GET" && req.url === "/blog") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        const dbArticles = await Article.findAll();
-        const responseData = {
-          title: blogData.title, // Keep the title from the original constant
-          articles: dbArticles,
-        };
-        res.end(JSON.stringify(responseData));
-      }
-      // POST a new article
-      else if (req.method === "POST" && req.url === "/blog/articles") {
-        let body = "";
-        req.on("data", (chunk) => (body += chunk.toString()));
-        req.on("end", async () => {
-          const newArticle = JSON.parse(body);
-          await Article.create(newArticle);
-          console.log("Added new article:", newArticle);
-          res.writeHead(201, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(newArticle));
-        });
-      } else {
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ message: "Not Found" }));
-      }
-    });
-
-    return new Promise((resolve) => {
-      server.listen(port, () => {
-        console.log(`API server running at http://localhost:${port}/`);
-        resolve(server);
-      });
-    });
-  } catch (error) {
-    console.error("Failed to initialize database or start server:", error);
-    process.exit(1); // Exit the process if there's a critical error
-  }
-}
-
-function getAPIURL() {
-  return `http://localhost:${serverPort}/blog`;
-}
-
-const storageserver = {
-  start,
-  getAPIURL,
-  setUsername,
-  setPassword,
-  setHost,
-};
-
-export default storageserver;