@lexho111/plainblog 0.0.8 → 0.0.9

package/Blog.js

@@ -3,6 +3,7 @@ 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";
 
 export default class Blog {
   constructor() {
@@ -10,9 +11,59 @@ export default class Blog {
     this.articles = [];
     this.style = "body { font-family: Arial; }";
     this.filename = null;
+    this.#server = null;
+
+    this.database = {
+      type: "sqlite",
+      username: "user",
+      password: "password",
+      host: "localhost",
+      dbname: "blog",
+    };
+  }
+
+  // Private fields
+  #server = null;
+  #apiServer;
+  #isExternalAPI = false;
+  #apiDataLoaded = false;
+
+  setTitle(title) {
+    this.title = title;
+  }
+
+  addArticle(article) {
+    this.articles.push(article);
+  }
+
+  setStyle(style) {
+    this.style = style;
   }
 
-  async fetchDataFromApi(apiUrl) {
+  /** initializes database */
+  async init() {
+    if (this.#isExternalAPI) {
+      await this.loadFromAPI(this.#APIUrl);
+    } 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();
+      const responseData = { title: dbTitle, articles: dbArticles };
+      this.#loadFromData(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);
 
@@ -28,7 +79,8 @@ export default class Blog {
     }
   }
 
-  async postDataToApi(apiUrl, postData) {
+  /** post data to an URL */
+  async #postDataToApi(apiUrl, postData) {
     const response = await fetch(apiUrl, {
       method: "POST",
       body: JSON.stringify(postData),
@@ -39,69 +91,127 @@ export default class Blog {
     return data;
   }
 
-  setTitle(title) {
-    this.title = title;
-  }
+  /** post a blog article */
+  async #postArticle(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
 
-  addArticle(article) {
-    this.articles.push(article);
-  }
+    req.on("end", async () => {
+      const params = new URLSearchParams(body);
+      const title = params.get("title");
+      const content = params.get("content");
 
-  setStyle(style) {
-    this.style = style;
+      if (title && content) {
+        const newArticleData = { title, content };
+        try {
+          // Save the new article to the database via the ApiServer
+          await this.#apiServer.save(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();
+    });
   }
 
-  APIUrl = "";
+  /** 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);
 
-  setAPI(APIUrl) {
-    this.APIUrl = APIUrl;
+        // 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.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
+    if (this.#apiServer === undefined) this.init(); // init blog if it didn't already happen
+    await this.#apiServer.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.#apiServer.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
+      }
     });
   }
 
+  /** save blog content to file */
   async save(filename = this.filename) {
-    if (this.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
+    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;
@@ -120,6 +230,7 @@ export default class Blog {
     }
   }
 
+  /** load blog content from file */
   async load(filename) {
     this.filename = filename;
     const data = await fs.readFile(filename, "utf8");
@@ -130,23 +241,28 @@ export default class Blog {
     );
   }
 
+  /** Populates the blog's title and articles from a data object. */
+  #loadFromData(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
+    }
+  }
+
   async loadFromAPI(apiUrl) {
-    const data = await this.fetchDataFromApi(apiUrl);
+    const data = await this.#fetchDataFromApi(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.#loadFromData(data);
     }
   }
 
+  /** 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,10 +270,11 @@ 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);
+    if (this.#APIUrl && !this.#apiDataLoaded) {
+      await this.loadFromAPI(this.#APIUrl);
     }
 
     return `<!DOCTYPE html>

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

@@ -0,0 +1,104 @@
+import { Sequelize, DataTypes } from "sequelize";
+
+export default class ApiServer {
+  #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: "./blog.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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/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/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;