@lexho111/plainblog 0.0.5 → 0.0.8

package/Article.js

@@ -9,6 +9,7 @@ export default class Article {
   }
 
   getContentShort() {
+    if (this.content.length < 400) return this.getContent();
     let contentShort = this.content.substring(0, 400);
     contentShort += "...";
     return contentShort;

package/Blog.js

@@ -1,4 +1,5 @@
 import http from "http";
+import fetch from "node-fetch";
 import { promises as fs } from "fs";
 import { URLSearchParams } from "url";
 import Article from "./Article.js";
@@ -11,6 +12,33 @@ export default class Blog {
     this.filename = null;
   }
 
+  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;
+    }
+  }
+
+  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;
+  }
+
   setTitle(title) {
     this.title = title;
   }
@@ -23,8 +51,15 @@ export default class Blog {
     this.style = style;
   }
 
-  startServer(port = 8080) {
-    const server = http.createServer((req, res) => {
+  APIUrl = "";
+
+  setAPI(APIUrl) {
+    this.APIUrl = APIUrl;
+  }
+
+  async startServer(port = 8080) {
+    if (this.APIUrl.length > 0) await this.loadFromAPI(this.APIUrl);
+    const server = http.createServer(async (req, res) => {
       if (req.method === "POST") {
         let body = "";
         req.on("data", (chunk) => {
@@ -36,10 +71,16 @@ export default class Blog {
           const content = params.get("content");
 
           if (title && content) {
-            this.addArticle(new Article(title, content));
-            // Auto-save if a file has been loaded or saved before
-            if (this.filename) {
-              await this.save();
+            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);
             }
           }
 
@@ -48,8 +89,9 @@ export default class Blog {
           res.end();
         });
       } else {
+        const html = await this.toHTML();
         res.writeHead(200, { "Content-Type": "text/html; charset=UTF-8" });
-        res.end(this.toHTML());
+        res.end(html);
       }
     });
 
@@ -59,6 +101,7 @@ export default class Blog {
   }
 
   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;
@@ -80,12 +123,30 @@ export default class Blog {
   async load(filename) {
     this.filename = filename;
     const data = await fs.readFile(filename, "utf8");
-    const { title, articles } = JSON.parse(data);
-    this.title = title;
-    this.articles = articles;
+    const jsonData = JSON.parse(data);
+    this.title = jsonData.title;
+    this.articles = jsonData.articles.map(
+      (article) => new Article(article.title, article.content)
+    );
   }
 
-  print() {
+  async loadFromAPI(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
+      }
+    }
+  }
+
+  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}`);
@@ -93,37 +154,40 @@ export default class Blog {
     }
   }
 
-  toHTML() {
-    let html = `
-    <!DOCTYPE html>
-    <html lang="de">
-    <head>
-      <meta charset="UTF-8">
-      <title>${this.title}</title>
-      <style>${this.style}</style>
-    </head>
-    <body>`;
-    html += `<h1>${this.title}</h1><div style="width: 500px;">`;
-
-    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);
+    }
+
+    return `<!DOCTYPE html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8">
+    <title>${this.title}</title>
+    <style>${this.style}</style>
+  </head>
+  <body>
+    <h1>${this.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>`;
-
-    for (const article of this.articles) {
-      html += `
+      <hr>
+      ${this.articles
+        .map(
+          (article) => `
       <article>
         <h2>${article.title}</h2>
         <p>${article.getContentShort()}</p>
-      </article>`;
-    }
-
-    html += `</div></body></html>`;
-
-    return html;
+      </article>`
+        )
+        .join("")}
+    </div>
+  </body>
+</html>`;
   }
 }

package/README.md

@@ -1,21 +1,69 @@
+# Plainblog
+
+Plainblog is a simple blog generator to help you to set up and to maintain a minimalistic **single-page blog**. You can add new articles directly in the browser. Articles are stored in a file or a database specified via an API.
+
+## Install
+
 ```
-import { Blog, Article } from "@lexho111/plainblog";
+npm install @lexho111/plainblog
+```
+
+## Quick Start
 
-const bl  og = new Blog();
+```
+import { Blog } from "@lexho111/plainblog";
+
+const blog = new Blog();
 blog.setTitle("My Blog");
 blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
 
-const article1 = new Article("My First Post", "Hello world!");
-blog.addArticle(article1);
+blog.startServer(8080);
+```
+
+Now you can start to add articles to your blog via your webbrowser on `http://localhost:8080`.
+
+## More Features
+
+set an API to fetch data from an external database
+
+```
+blog.setAPI("http://localhost:8081/blog")
+```
+
+### run api server with sqlite database
+
+```
+import { Blog, storageserver} from "@lexho111/plainblog";
+await storageserver("sqlite", 8081); // you can use a postgres db too
+const blog = new Blog();
+blog.setAPI(storageserver.getAPIURL());
+blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
 
-const article2 = new Article(
-  "Good Evening!",
-  "Good Evening, Ladies and Gentleman!"
-);
-blog.addArticle(article2);
 blog.startServer(8080);
 ```
 
+### run api server with postgres 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
+```
+
+```
+import { Blog, storageserver} 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
+
 ```
 # save your blog to 'myblog.json'
 await blog.save("myblog.json");
@@ -23,3 +71,9 @@ await blog.save("myblog.json");
 # load data from 'myblog.json'
 await blog.load("myblog.json");
 ```
+
+print your blog articles in markdown
+
+```
+blog.print()
+```

package/api-server.js

@@ -0,0 +1,175 @@
+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;

package/eslint.config.js

@@ -0,0 +1,45 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import pluginJest from "eslint-plugin-jest";
+
+export default [
+  {
+    // Configuration for all JavaScript files
+    files: ["**/*.js"],
+    languageOptions: {
+      ecmaVersion: 2022, // Supports modern JavaScript features
+      sourceType: "module",
+      globals: {
+        ...globals.node, // Defines Node.js global variables (e.g., `process`, `require`)
+      },
+    },
+    // ESLint's recommended rules for general JavaScript
+    rules: {
+      ...pluginJs.configs.recommended.rules,
+      // Add or override general JavaScript rules here.
+      // Example: Enforce semicolons at the end of statements
+      semi: ["error", "always"],
+      // Example: Prefer `const` over `let` where variables are not reassigned
+      "prefer-const": "error",
+      // Example: Prevent unused variables (can be configured further)
+      "no-unused-vars": ["warn", { args: "none" }],
+    },
+  },
+  {
+    // Configuration specifically for Jest test files
+    files: ["**/*.test.js", "**/*.spec.js"],
+    languageOptions: {
+      globals: {
+        ...globals.jest, // Defines Jest global variables (e.g., `describe`, `it`, `expect`)
+      },
+    },
+    plugins: {
+      jest: pluginJest,
+    },
+    // Recommended Jest rules from `eslint-plugin-jest`
+    rules: {
+      ...pluginJest.configs.recommended.rules,
+      // Add or override Jest-specific rules here.
+    },
+  },
+];

package/index.js

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

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",
-  "files": [
-    "index.js",
-    "Blog.js",
-    "Article.js"
-  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "lint": "eslint ."
   },
   "keywords": [
     "blog",
@@ -18,5 +14,17 @@
     "server"
   ],
   "author": "lexho111",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "node-fetch": "^3.3.2",
+    "pg": "^8.16.3",
+    "pg-hstore": "^2.3.4",
+    "sequelize": "^6.37.7",
+    "sqlite3": "^5.1.7"
+  },
+  "devDependencies": {
+    "eslint": "^9.8.0",
+    "eslint-plugin-jest": "^28.6.0",
+    "jest": "^29.7.0"
+  }
 }

package/test/article.test.js

@@ -0,0 +1,31 @@
+import Article from "../Article.js";
+
+test("get content", () => {
+  const article = new Article("title", "text text text");
+  const content = article.getContent();
+  expect(article.title).toContain("title");
+  expect(content).toContain("text text text");
+});
+
+test("get shortened content", () => {
+  const article = new Article("title", "text text text");
+  const content = article.getContentShort();
+  expect(article.title).toContain("title");
+  const text_short = "text text text";
+  expect(content).toContain(text_short);
+  expect(content).not.toContain("...");
+});
+
+test("get shortened content", () => {
+  let text = "text";
+  for (let i = 0; i < 500; i++) {
+    text += " ";
+    text += "text";
+  }
+  const text_long = text;
+  const article = new Article("title", text_long);
+  const content = article.getContentShort();
+  expect(article.title).toContain("title");
+  expect(content).toContain("text text text");
+  expect(content).toContain("...");
+});

package/test/blog.test.js

@@ -0,0 +1,97 @@
+import Blog from "../Blog.js";
+import Article from "../Article.js";
+import { jest } from "@jest/globals";
+
+describe("test blog", () => {
+  test("is valid html", async () => {
+    const myblog = new Blog();
+    const html = await myblog.toHTML();
+    expect(html).toContain("html>");
+    expect(html).toContain("</html>");
+    expect(html).toContain("<body");
+    expect(html).toContain("</body>");
+    expect(html).toContain("<div"); // container
+    expect(html).toContain("</div>");
+  });
+  test("creates Blog with specified title", async () => {
+    const titles = ["TestBlog", "Blog1234", "abcdfg", "kiwi"];
+    for (const title of titles) {
+      const myblog = new Blog();
+      myblog.setTitle(title);
+      const html = await myblog.toHTML();
+      expect(html).toContain(title);
+    }
+  });
+  test("empty blog without any article", async () => {
+    const myblog = new Blog();
+    const html = await myblog.toHTML();
+    expect(html).not.toContain("<article");
+  });
+  test("add article", async () => {
+    const myblog = new Blog();
+    const article = new Article("", "");
+    myblog.addArticle(article);
+    const html = await myblog.toHTML();
+    expect(html).toContain("<article");
+    expect(myblog.articles.length).toBe(1);
+  });
+  test("add articles", async () => {
+    const myblog = new Blog();
+    expect(myblog.articles.length).toBe(0);
+    const size = 10;
+    for (let i = 1; i <= size; i++) {
+      const article = new Article("", "");
+      myblog.addArticle(article);
+      expect(myblog.articles.length).toBe(i);
+    }
+    const html = await myblog.toHTML();
+    expect(html).toContain("<article");
+    expect(myblog.articles.length).toBe(size);
+  });
+  test("set style", async () => {
+    const myblog = new Blog();
+    const styles = [
+      "body { font-family: Courier; }",
+      "body { background-color: black; color: white; }",
+      "body { font-size: 1.2em; }",
+    ];
+    for (const style of styles) {
+      myblog.setStyle(style);
+      const html = await myblog.toHTML();
+      expect(html).toContain(style);
+    }
+  });
+  test("print method logs title and articles to console", () => {
+    // Arrange: Set up the blog with a title and articles
+    const myblog = new Blog();
+    myblog.setTitle("My Test Blog");
+    myblog.addArticle(new Article("Article 1", "Content 1"));
+
+    // Spy on console.log to capture its output without printing to the test runner
+    const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    // Act: Call the method we want to test
+    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");
+
+    // Clean up the spy to restore the original console.log
+    consoleSpy.mockRestore();
+  });
+});
+
+/*
+test Blog.js
+ok - new Blog()
+ok - set title
+ok - set style
+ok - add article
+- set api
+- fetch/post
+- save/load
+ok - print
+ok - toHTML
+*/

package/test/server.test.js

@@ -0,0 +1,29 @@
+import { start as startAPIServer } from "../api-server.js";
+import fetch from "node-fetch";
+
+describe("API Server Health Check", () => {
+  let server;
+  const PORT = 8085;
+  const apiBaseUrl = `http://localhost:${PORT}`;
+
+  beforeAll(async () => {
+    // how about to use in-memory database?
+    server = await startAPIServer("sqlite", PORT);
+  });
+
+  afterAll((done) => {
+    server.close(() => {
+      done();
+    });
+  });
+
+  test("should respond with 200 OK on the /health endpoint", async () => {
+    const response = await fetch(`${apiBaseUrl}/health`);
+
+    // Check for a successful status code
+    expect(response.status).toBe(200);
+
+    const body = await response.json();
+    expect(body).toEqual({ status: "ok" });
+  });
+});