@lexho111/plainblog 0.8.4 → 0.8.6

package/README.md

@@ -28,14 +28,13 @@ or with the BlogBuilder
 
 ```
 import { BlogBuilder } from "@lexho111/plainblog";
+
 const blog = new BlogBuilder()
   .withTitle("Mein Blog")
   .withStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }")
   .withPassword("mypassword")
   .build();
-
 await blog.init();
-
 await blog.startServer({ httpPort: 38080, httpsPort: 38443 });
 ```
 
@@ -50,8 +49,10 @@ To add a headerphoto to your blog simply name it "headerphoto.jpg" and put it in
 You can put your own angular theme in the public folder.
 
 ```
+const blog = new BlogBuilder()
 ...
-blog.angular = true;
+.withFrontend("angular")
+.build();
 ```
 
 ### set a Database Adapter
@@ -89,7 +90,7 @@ await blog.init();
 await blog.startServer();
 ```
 
-### use differen ports
+### use different ports
 
 ```
 import Blog from "@lexho111/plainblog";

package/dist/model/PostgresAdapter.js

@@ -0,0 +1,262 @@
+import { createDebug } from "../../debug-loader.js";
+
+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),
+    }));
+  }
+}

package/model/PostgresAdapter.js

@@ -1,97 +1,262 @@
-import SequelizeAdapter from "./SequelizeAdapter.js";
-import { createDebug } from "../debug-loader.js";
-
-const debug = createDebug("plainblog:SqliteAdapter");
-
-export default class PostgresAdapter extends SequelizeAdapter {
-  dbtype = "postgres";
-
-  constructor(options = {}) {
-    super();
-    debug(JSON.stringify(options));
-    this.username = options.username;
-    this.password = options.password;
-    this.host = options.host;
-    if (options.dbname) this.dbname = options.dbname;
-    if (options.dbport) this.dbport = options.dbport;
-    else this.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;
-  }
-
-  async initialize() {
-    console.log("initialize database");
-    let pgPkg;
-    try {
-      await import("sequelize");
-      pgPkg = await import("pg");
-      await import("pg-hstore");
-    } catch (error) {
-      if (
-        error.code === "ERR_MODULE_NOT_FOUND" ||
-        error.code === "MODULE_NOT_FOUND"
-      ) {
-        console.error(
-          "The 'sequelize', 'pg', and 'pg-hstore' packages are not installed. Please install them by running: npm install sequelize pg pg-hstore",
-        );
-        throw new Error(
-          "Missing optional dependencies: 'sequelize', 'pg', 'pg-hstore'",
-        );
-      }
-    }
-    await this.loadSequelize();
-    const maxRetries = 10;
-    const retryDelay = 3000;
-
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        console.log(
-          `postgres://${this.username}:${this.password}@${this.host}:${this.dbport}/${this.dbname}`,
-        );
-
-        this.sequelize = new this.Sequelize(
-          `postgres://${this.username}:${this.password}@${this.host}:${this.dbport}/${this.dbname}`,
-          {
-            logging: false,
-            dialectModule: pgPkg.default || pgPkg,
-          },
-        );
-        await this.sequelize.authenticate();
-        await this.initializeModels();
-        this.ready = true;
-        return;
-      } catch (err) {
-        if (err.message.includes("Please install")) {
-          throw new Error(
-            "PostgreSQL driver is not installed. Please install it to use PostgresAdapter: npm install pg pg-hstore",
-          );
-        }
-        console.error(
-          `Database connection attempt ${attempt} failed: ${err.message}`,
-        );
-        if (attempt === maxRetries) {
-          console.error("Max retries reached. Exiting.");
-          throw err;
-        }
-        console.log(`retrying in ${retryDelay / 1000} seconds...`);
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-      }
-    }
-  }
-
-  getType() {
-    return this.dbtype;
-  }
-
-  getDBName() {
-    return this.dbname;
-  }
-
-  isReady() {
-    return this.ready;
-  }
-}
+import { createDebug } from "../debug-loader.js";
+
+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),
+    }));
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",
@@ -8,8 +8,8 @@
     "dev": "node index.js",
     "cluster": "node cluster-server.js",
     "postinstall": "node postinstall.js",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "test2": "node --experimental-vm-modules node_modules/jest/bin/jest.js --runInBand",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --runInBand",
+    "test2": "node --experimental-vm-modules node_modules/jest/bin/jest.js --silent --runInBand",
     "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage & start coverage/lcov-report/index.html",
     "view-coverage": "start coverage/lcov-report/index.html",
     "lint": "eslint .",
@@ -28,12 +28,12 @@
     "@types/node": "^25.0.3",
     "debug": "^4.4.3",
     "eslint": "^9.39.2",
-    "eslint-plugin-jest": "^28.6.0",
+    "eslint-plugin-jest": "^28.14.0",
     "eslint-plugin-promise": "^7.2.1",
     "globals": "^17.0.0",
     "jest": "^29.7.0",
     "multer": "^2.0.2",
-    "pg": "^8.16.3",
+    "pg": "^8.18.0",
     "pg-hstore": "^2.3.4",
     "sequelize": "^6.37.7",
     "typescript": "^5.9.3",

package/profile-bst.js

@@ -11,7 +11,7 @@ import fs from "node:fs";
 
 async function runSearch(name, BlogClass, cb = () => {}) {
   const storage = new BlogClass();
-  let allDates = generateDateList("2000-01-01T00:00", "2025-12-25T00:00");
+  let allDates = [...generateDateList("2000-01-01T00:00", "2025-12-25T00:00")];
 
   // The callback (which shuffles for BinaryTreeSearch) must be called BEFORE insertion
   cb(allDates);

package/src1/model/PostgresAdapter.ts

@@ -0,0 +1,311 @@
+import { DatabaseAdapter } from "./DatabaseAdapter.js";
+import { Article } from "./Article.interface.js";
+//import { createDebug } from "../../debug-loader.js";
+const createDebug = (namespace: any) => {
+  return (...args: any) => {};
+};
+
+const debug = createDebug("plainblog:PostgresAdapter");
+
+interface PostgresAdapterOptions {
+  username?: string;
+  password?: string;
+  host?: string;
+  dbname?: string;
+  dbport?: number;
+}
+
+export default class PostgresAdapter implements DatabaseAdapter {
+  dbtype = "postgres";
+  username?: string;
+  password?: string;
+  host?: string;
+  dbname: string;
+  dbport: number;
+  pool: any;
+  ready: boolean;
+
+  constructor(options: PostgresAdapterOptions = {}) {
+    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(): Promise<void> {
+    let pg: any;
+    try {
+      // @ts-ignore
+      pg = await import("pg");
+    } catch (error: any) {
+      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: any) {
+      console.error("Failed to initialize PostgresAdapter", err);
+      throw err;
+    }
+  }
+
+  async terminate(): Promise<void> {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      this.ready = false;
+    }
+  }
+
+  getType(): string {
+    return this.dbtype;
+  }
+
+  getDBName(): string {
+    return this.dbname;
+  }
+
+  isReady(): boolean {
+    return this.ready;
+  }
+
+  async getBlogTitle(): Promise<string> {
+    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: string): Promise<void> {
+    if (!this.pool) await this.initialize();
+    await this.pool.query('UPDATE "BlogInfos" SET title = $1', [newTitle]);
+  }
+
+  async save(newArticle: Article): Promise<Article> {
+    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: any[] = [
+      newArticle.title,
+      newArticle.content,
+      (newArticle as any).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: number, data: Partial<Article>): Promise<void> {
+    if (!this.pool) await this.initialize();
+    const sets: string[] = [];
+    const values: any[] = [];
+    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 as any).image !== undefined) {
+      sets.push(`image = $${paramIndex++}`);
+      values.push((data as any).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: number): Promise<void> {
+    if (!this.pool) await this.initialize();
+    await this.pool.query('DELETE FROM "Articles" WHERE id = $1', [id]);
+  }
+
+  async findAll(
+    limit: number = 4,
+    offset: number = 0,
+    startId: number | string | null = null,
+    endId: number | string | null = null,
+    order: "DESC" | "ASC" = "DESC",
+  ): Promise<Article[]> {
+    if (!this.pool) await this.initialize();
+
+    let query = 'SELECT * FROM "Articles"';
+    const conditions: string[] = [];
+    const values: any[] = [];
+    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: any) => ({
+      id: Number(row.id),
+      title: row.title,
+      content: row.content,
+      image: row.image,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
+    }));
+  }
+}