@lexho111/plainblog 0.8.5 → 0.9.0

package/Blog.js

@@ -273,7 +273,7 @@ export default class Blog {
             this.#articles.setDatabase(this.#databaseModel);
             const [dbTitle, dbArticles] = await Promise.all([
               this.#databaseModel.getBlogTitle(),
-              this.#databaseModel.findAll(-1),
+              this.#databaseModel.findAll(-1), // dbArticles should be ordered by date (BST)
             ]);
             debug("dbArticles.size(): %d", dbArticles.length);
             //log(filename, "dbArticles.size(): " + dbArticles.length);
@@ -405,6 +405,7 @@ export default class Blog {
     }
     this.#title = data.title;
     // Assuming data contains a title and an array of articles with title and content
+    // data.articles should be ordered by date (BST)
     if (this.#articles && data.articles && Array.isArray(data.articles)) {
       if (this.#articles.getStorageName().includes("BinarySearchTree")) {
         debug("using special insert method for BST");
@@ -466,8 +467,30 @@ export default class Blog {
   /** render this blog content to valid html */
   async toHTML(loggedin, params = {}) {
     let articles = [];
+    let singleArticle = false;
     if (params.q) {
       articles = this.#articles.search(params.q);
+    } else if (params.id) {
+      const id = parseInt(params.id);
+      let article = this.#articles.get(id);
+      if (!article && this.#databaseModel) {
+        const dbResults = await this.#databaseModel.findAll(1, 0, id, id);
+        if (dbResults.length > 0) {
+          const data = dbResults[0];
+          article = new Article(
+            data.id,
+            data.title,
+            data.content,
+            data.createdAt,
+            data.image,
+          );
+          this.#articles.insert(article);
+        }
+      }
+      if (article) {
+        articles = [article];
+        singleArticle = true;
+      }
     } else if (params.date) {
       const d = new Date(params.date);
       if (!isNaN(d.getTime())) {
@@ -491,6 +514,7 @@ export default class Blog {
       articles: articles,
       latestArticleDate: latestArticle ? latestArticle.createdAt : null,
       loggedin,
+      singleArticle,
       login: "",
     };
 

package/Formatter.js

@@ -16,6 +16,7 @@ const articleTemplate = loadTemplate("article.html");
 const articleButtonsTemplate = loadTemplate("articleButtons.html");
 const moreButtonTemplate = loadTemplate("moreButton.html");
 const timelineTemplate = loadTemplate("timelineSelector.html");
+const loginTemplate = loadTemplate("login.html");
 
 /**
  * generates the header of the generated html file
@@ -30,7 +31,7 @@ function createNew() {
   return formTemplate;
 }
 
-function formatArticle(article, loggedin) {
+function formatArticle(article, loggedin, showFull = false) {
   if (article.content == null) return "";
 
   let buttons = "";
@@ -38,22 +39,33 @@ function formatArticle(article, loggedin) {
     buttons = articleButtonsTemplate.replaceAll("${id}", article.id);
   }
 
-  const moreButton = article.content.length > 400 ? moreButtonTemplate : "";
+  const moreButton =
+    !showFull && article.content.length > 400
+      ? moreButtonTemplate.replaceAll("${id}", article.id)
+      : "";
 
   /*const imageHtml = article.image
     ? `<img src="${article.image}" alt="${article.title}" style="max-width: 100%;">`
     : "";*/
 
   let html = articleTemplate;
-  html = html.replace("${id}", article.id);
+  html = html.replaceAll("${id}", article.id);
   html = html.replace("${createdAt}", article.createdAt);
   html = html.replace("${buttons}", buttons);
   html = html.replace("${title}", article.title);
   html = html.replace("${formattedDate}", article.getFormattedDate());
   html = html.replace("${image}", article.image);
-  html = html.replace("${contentShort}", article.getContentShort());
+  html = html.replace(
+    "${contentShort}",
+    showFull ? "" : article.getContentShort(),
+  );
   html = html.replace("${content}", article.content);
   html = html.replace("${moreButton}", moreButton);
+
+  if (showFull) {
+    html = html.replace('style="display: none;"', "");
+  }
+
   return html;
 }
 
@@ -97,18 +109,32 @@ function formatTimeline(latestArticleDate) {
 export function formatHTML(data) {
   const form = data.loggedin ? createNew() : "";
   const articles = data.articles
-    .map((article) => formatArticle(article, data.loggedin))
+    .map((article) => formatArticle(article, data.loggedin, data.singleArticle))
     .join("");
-  const timeline = formatTimeline(data.latestArticleDate);
+  const timeline = data.singleArticle
+    ? '<a href="/" class="btn backtohome">Back to Home</a>'
+    : formatTimeline(data.latestArticleDate);
   let html = layoutTemplate;
   html = html.replace("${login}", data.login);
-  html = html.replace("${title}", data.title);
+  html = html.replace(
+    "${title}",
+    `<a href="/" style="text-decoration: none; color: inherit;">${data.title}</a>`,
+  );
   html = html.replace("${form}", form);
   html = html.replace("${timeline}", timeline);
   html = html.replace("${articles}", articles);
   return header(data.title) + "\n" + html;
 }
 
+export function formatLogin(title) {
+  let html = loginTemplate;
+  html = html.replace(
+    "${title}",
+    `<a href="/" style="text-decoration: none; color: inherit;">${title}</a>`,
+  );
+  return header(title) + "\n" + html;
+}
+
 /**
  * format content like articles to markdown
  * @param {*} data blog data like blogtitle and articles

package/dist/model/PostgresAdapter.js

@@ -0,0 +1,248 @@
+//import { createDebug } from "../../debug-loader.js";
+const createDebug = (namespace) => {
+    return (...args) => { };
+};
+const debug = createDebug("plainblog:PostgresAdapter");
+export default class PostgresAdapter {
+    dbtype = "postgres";
+    username;
+    password;
+    host;
+    dbname;
+    dbport;
+    pool;
+    ready;
+    constructor(options = {}) {
+        debug(JSON.stringify(options));
+        this.username = options.username;
+        this.password = options.password;
+        this.host = options.host;
+        this.dbname = options.dbname || "blog";
+        this.dbport = options.dbport || 5432;
+        if (!this.username || !this.password || !this.host) {
+            throw new Error("PostgreSQL credentials not set. Please provide 'username', 'password', and 'host' in the options.");
+        }
+        this.ready = false;
+        this.pool = null;
+    }
+    async initialize() {
+        let pg;
+        try {
+            // @ts-ignore
+            pg = await import("pg");
+        }
+        catch (error) {
+            if (error.code === "ERR_MODULE_NOT_FOUND" ||
+                error.code === "MODULE_NOT_FOUND") {
+                console.error("The 'pg' package is not installed. Please install it by running: npm install pg");
+                process.exit(1);
+            }
+            else {
+                throw error;
+            }
+        }
+        const { Pool, Client } = pg.default || pg;
+        try {
+            const client = new Client({
+                user: this.username,
+                host: this.host,
+                database: "postgres",
+                password: this.password,
+                port: this.dbport,
+            });
+            await client.connect();
+            const res = await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [this.dbname]);
+            if (res.rowCount === 0) {
+                await client.query(`CREATE DATABASE "${this.dbname}"`);
+            }
+            await client.end();
+        }
+        catch (e) {
+            console.error("Failed to check/create database:", e);
+        }
+        this.pool = new Pool({
+            user: this.username,
+            host: this.host,
+            database: this.dbname,
+            password: this.password,
+            port: this.dbport,
+        });
+        try {
+            const client = await this.pool.connect();
+            try {
+                await client.query(`
+          CREATE TABLE IF NOT EXISTS "Articles" (
+            id BIGSERIAL PRIMARY KEY,
+            title VARCHAR(255),
+            content TEXT,
+            image TEXT,
+            "createdAt" TIMESTAMP,
+            "updatedAt" TIMESTAMP
+          )
+        `);
+                await client.query(`
+          CREATE TABLE IF NOT EXISTS "BlogInfos" (
+            id SERIAL PRIMARY KEY,
+            title VARCHAR(255)
+          )
+        `);
+                const res = await client.query('SELECT count(*) as count FROM "BlogInfos"');
+                if (parseInt(res.rows[0].count) === 0) {
+                    await client.query('INSERT INTO "BlogInfos" (title) VALUES ($1)', ["My Default Blog Title"]);
+                }
+                this.ready = true;
+            }
+            finally {
+                client.release();
+            }
+        }
+        catch (err) {
+            console.error("Failed to initialize PostgresAdapter", err);
+            throw err;
+        }
+    }
+    async terminate() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.ready = false;
+        }
+    }
+    getType() {
+        return this.dbtype;
+    }
+    getDBName() {
+        return this.dbname;
+    }
+    isReady() {
+        return this.ready;
+    }
+    async getBlogTitle() {
+        if (!this.pool)
+            await this.initialize();
+        const res = await this.pool.query('SELECT title FROM "BlogInfos" LIMIT 1');
+        return res.rows.length > 0 ? res.rows[0].title : "Blog";
+    }
+    async updateBlogTitle(newTitle) {
+        if (!this.pool)
+            await this.initialize();
+        await this.pool.query('UPDATE "BlogInfos" SET title = $1', [newTitle]);
+    }
+    async save(newArticle) {
+        if (!this.pool)
+            await this.initialize();
+        const createdAt = newArticle.createdAt
+            ? new Date(newArticle.createdAt)
+            : new Date();
+        const updatedAt = new Date();
+        const cols = ['title', 'content', 'image', '"createdAt"', '"updatedAt"'];
+        const vals = [
+            newArticle.title,
+            newArticle.content,
+            newArticle.image,
+            createdAt,
+            updatedAt,
+        ];
+        if (newArticle.id) {
+            cols.unshift("id");
+            vals.unshift(newArticle.id);
+        }
+        const finalPlaceholders = vals.map((_, i) => `$${i + 1}`);
+        const query = `
+      INSERT INTO "Articles" (${cols.join(", ")})
+      VALUES (${finalPlaceholders.join(", ")})
+      RETURNING id
+    `;
+        const res = await this.pool.query(query, vals);
+        const id = Number(res.rows[0].id);
+        return {
+            ...newArticle,
+            id,
+            createdAt,
+            updatedAt,
+        };
+    }
+    async update(id, data) {
+        if (!this.pool)
+            await this.initialize();
+        const sets = [];
+        const values = [];
+        let paramIndex = 1;
+        if (data.title !== undefined) {
+            sets.push(`title = $${paramIndex++}`);
+            values.push(data.title);
+        }
+        if (data.content !== undefined) {
+            sets.push(`content = $${paramIndex++}`);
+            values.push(data.content);
+        }
+        if (data.image !== undefined) {
+            sets.push(`image = $${paramIndex++}`);
+            values.push(data.image);
+        }
+        sets.push(`"updatedAt" = $${paramIndex++}`);
+        values.push(new Date());
+        if (sets.length > 0) {
+            values.push(id);
+            const query = `UPDATE "Articles" SET ${sets.join(", ")} WHERE id = $${paramIndex}`;
+            await this.pool.query(query, values);
+        }
+    }
+    async remove(id) {
+        if (!this.pool)
+            await this.initialize();
+        await this.pool.query('DELETE FROM "Articles" WHERE id = $1', [id]);
+    }
+    async findAll(limit = 4, offset = 0, startId = null, endId = null, order = "DESC") {
+        if (!this.pool)
+            await this.initialize();
+        let query = 'SELECT * FROM "Articles"';
+        const conditions = [];
+        const values = [];
+        let paramIndex = 1;
+        const isDate = typeof startId === "string" || typeof endId === "string";
+        if (startId !== null && endId !== null) {
+            if (isDate) {
+                conditions.push(`"createdAt" BETWEEN $${paramIndex++} AND $${paramIndex++}`);
+                values.push(startId, endId);
+            }
+            else {
+                conditions.push(`id BETWEEN $${paramIndex++} AND $${paramIndex++}`);
+                values.push(Math.min(Number(startId), Number(endId)), Math.max(Number(startId), Number(endId)));
+            }
+        }
+        else if (startId !== null) {
+            if (isDate) {
+                conditions.push(order === "DESC"
+                    ? `"createdAt" <= $${paramIndex++}`
+                    : `"createdAt" >= $${paramIndex++}`);
+                values.push(startId);
+            }
+            else {
+                conditions.push(order === "DESC" ? `id <= $${paramIndex++}` : `id >= $${paramIndex++}`);
+                values.push(startId);
+            }
+        }
+        if (conditions.length > 0) {
+            query += " WHERE " + conditions.join(" AND ");
+        }
+        query += ` ORDER BY "createdAt" ${order}, id ${order}`;
+        if (limit !== -1) {
+            query += ` LIMIT $${paramIndex++}`;
+            values.push(limit);
+        }
+        if (offset > 0) {
+            query += ` OFFSET $${paramIndex++}`;
+            values.push(offset);
+        }
+        const res = await this.pool.query(query, values);
+        return res.rows.map((row) => ({
+            id: Number(row.id),
+            title: row.title,
+            content: row.content,
+            image: row.image,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        }));
+    }
+}