@lexho111/plainblog 0.6.14 → 0.7.0

package/Article.js

@@ -89,6 +89,7 @@ export default class Article {
         <h2>${this.title}</h2>
         <span class="datetime">${this.getFormattedDate()}</span>
         <p>${this.getContentShort()}</p>
+        <div class="full-content" style="display: none;">${this.content}</div>
         ${moreButton}
       </article>`;
   }

package/AssetManager.js

@@ -0,0 +1,215 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { Worker } from "node:worker_threads";
+import { createDebug } from "./debug-loader.js";
+
+const debug = createDebug("plainblog:AssetManager");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default class AssetManager {
+  constructor() {
+    this.publicDir = path.join(process.cwd(), "public");
+    this.reloadStylesOnGET = false;
+    this.stylesheetPath = null;
+    this.compilestyle = false;
+    this.styles = "body { font-family: Arial; }";
+    this.compiledStyles = "";
+    this.stylesHash = "";
+    this.scriptsHash = "";
+  }
+
+  setStyle(style) {
+    this.styles += style;
+    this.compilestyle = true;
+  }
+
+  async init() {
+    // if there is a stylesheet path provided, process it
+    if (this.stylesheetPath != null && this.compilestyle) {
+      await this.processStylesheets(this.stylesheetPath);
+    }
+    if (!this.stylesheetPath) {
+      // compile and merge hardcoded styles in "this.styles" with "src/styles.css"
+      const srcStylePath = path.join(__dirname, "src", "styles.css");
+      const publicStylePath = path.join(this.publicDir, "styles.min.css");
+
+      let publicHash = null;
+      let srcStyles = "";
+
+      await Promise.all([
+        fs.promises
+          .readFile(publicStylePath, "utf8")
+          .then((publicCSS) => {
+            const match = publicCSS.match(
+              /\/\* source-hash: ([a-f0-9]{64}) \*\//,
+            );
+            if (match) publicHash = match[1];
+          })
+          .catch((err) => {
+            if (err.code !== "ENOENT") console.error(err);
+          }),
+        fs.promises
+          .readFile(srcStylePath, "utf8")
+          .then((content) => {
+            srcStyles = content;
+          })
+          .catch((err) => {
+            if (err.code !== "ENOENT") console.error(err);
+          }),
+      ]);
+
+      const combinedStyles = this.styles + srcStyles;
+      const srcHash = crypto
+        .createHash("sha256")
+        .update(combinedStyles)
+        .digest("hex");
+
+      if (srcHash !== publicHash && this.compilestyle) {
+        debug("Styles have changed. Recompiling in worker...");
+        const finalStyles = await this.runWorker("mergeStyles", [
+          this.styles,
+          srcStyles,
+        ]);
+
+        try {
+          await fs.promises.mkdir(path.dirname(publicStylePath), {
+            recursive: true,
+          });
+          await fs.promises.writeFile(
+            publicStylePath,
+            finalStyles + `\n/* source-hash: ${srcHash} */`,
+          );
+        } catch (err) {
+          console.error("Failed to write styles to public folder:", err);
+        }
+      }
+    }
+
+    // Process Scripts
+    const srcScriptPath = path.join(__dirname, "src", "fetchData.js");
+    await this.processScripts(srcScriptPath);
+  }
+
+  async reload() {
+    if (this.stylesheetPath != null && this.compilestyle) {
+      await this.processStylesheets(this.stylesheetPath);
+    }
+    const srcScriptPath = path.join(__dirname, "src", "fetchData.js");
+    await this.processScripts(srcScriptPath);
+  }
+
+  async processStylesheets(files) {
+    debug("process stylesheets");
+    const fileList = Array.isArray(files) ? files : [files];
+    const styleFiles = fileList.filter(
+      (f) =>
+        typeof f === "string" &&
+        (f.endsWith(".scss") || f.endsWith(".css")) &&
+        !f.endsWith(".min.css"),
+    );
+
+    if (styleFiles.length > 0) {
+      const fileData = await Promise.all(
+        styleFiles.sort().map(async (f) => {
+          const content = await fs.promises.readFile(f, "utf-8");
+          if (content == "") throw new Error("Invalid Filepath or empty file!");
+          return { path: f, content };
+        }),
+      );
+
+      const hash = crypto.createHash("sha256");
+      for (const file of fileData) hash.update(file.content);
+      const currentHash = hash.digest("hex");
+
+      if (currentHash !== this.stylesHash && this.compilestyle) {
+        console.log("style assets have changed. recompiling in worker...");
+        this.stylesHash = currentHash;
+        this.compiledStyles = await this.runWorker("styles", fileData);
+
+        await fs.promises.mkdir(this.publicDir, { recursive: true });
+        await fs.promises.writeFile(
+          path.join(this.publicDir, "styles.min.css"),
+          this.compiledStyles + `\n/* source-hash: ${currentHash} */`,
+        );
+      } else {
+        console.log("styles are up-to-date");
+      }
+    }
+  }
+
+  async processScripts(files) {
+    const fileList = Array.isArray(files) ? files : [files];
+    const scriptFiles = fileList.filter(
+      (f) =>
+        typeof f === "string" && f.endsWith(".js") && !f.endsWith(".min.js"),
+    );
+
+    if (scriptFiles.length > 0) {
+      const fileData = await Promise.all(
+        scriptFiles.map(async (f) => {
+          const content = await fs.promises.readFile(f, "utf-8");
+          if (content == "") throw new Error("Invalid Filepath or empty file!");
+          return { path: f, content };
+        }),
+      );
+
+      const hash = crypto.createHash("sha256");
+      for (const file of fileData) hash.update(file.content);
+      const currentHash = hash.digest("hex");
+
+      if (!this.scriptsHash) {
+        try {
+          const existing = await fs.promises.readFile(
+            path.join(this.publicDir, "scripts.min.js"),
+            "utf-8",
+          );
+          const match = existing.match(/\/\* source-hash: ([a-f0-9]{64}) \*\//);
+          if (match) this.scriptsHash = match[1];
+        } catch {
+          // ignore
+        }
+      }
+
+      if (currentHash !== this.scriptsHash) {
+        console.log("script assets have changed. recompiling in worker...");
+        this.scriptsHash = currentHash;
+        const compiledScripts = await this.runWorker("scripts", fileData);
+
+        await fs.promises.mkdir(this.publicDir, { recursive: true });
+        await fs.promises.writeFile(
+          path.join(this.publicDir, "scripts.min.js"),
+          compiledScripts + `\n/* source-hash: ${currentHash} */`,
+        );
+      }
+    }
+  }
+
+  runWorker(type, data) {
+    return new Promise((resolve, reject) => {
+      const workerData =
+        type === "mergeStyles"
+          ? { type: "mergeStyles", cssContents: data }
+          : { type, fileData: data };
+
+      const worker = new Worker(
+        path.resolve(__dirname, "workers", "compiler-worker.js"),
+        { workerData },
+      );
+      worker.on("message", (msg) => {
+        if (msg.status === "success") {
+          resolve(msg.result);
+        } else {
+          reject(new Error(msg.error));
+        }
+      });
+      worker.on("error", reject);
+      worker.on("exit", (code) => {
+        if (code !== 0)
+          reject(new Error(`Worker stopped with exit code ${code}`));
+      });
+    });
+  }
+}

package/Auth.js

@@ -0,0 +1,97 @@
+import { URLSearchParams } from "url";
+import crypto from "node:crypto";
+import { createDebug } from "./debug-loader.js";
+import { debug_perf } from "./debug-loader.js";
+
+const debug = createDebug("plainblog:Auth");
+
+export default class Auth {
+  constructor(sessions, password) {
+    this.sessions = sessions;
+    this.password = password;
+  }
+
+  isAuthenticated(req) {
+    const time_start = performance.now();
+    if (!req.headers.cookie) {
+      const time_end = performance.now();
+      const duration = time_end - time_start;
+      debug_perf("isAuthenticated took " + duration + "ms", duration);
+      return false;
+    }
+    const match = req.headers.cookie.match(/(?:^|;\s*)session=([^;]*)/);
+    const result = match ? this.sessions.has(match[1]) : false;
+    const time_end = performance.now();
+    const duration = time_end - time_start;
+    debug_perf("isAuthenticated took " + duration + "ms", duration);
+    return result;
+  }
+
+  async handleLogin(req, res, readBody, timeout, maxSize) {
+    debug("handle login request");
+    try {
+      const body = await readBody(req, timeout, maxSize);
+      const params = new URLSearchParams(body);
+      const receivedPassword = params.get("password");
+
+      if (receivedPassword === this.password) {
+        const id = crypto.randomUUID();
+        this.sessions.add(id);
+        // Limit session count to prevent memory exhaustion
+        if (this.sessions.size > 10000) {
+          debug("Warning: too many sessions, clearing oldest");
+          const sessionsArray = Array.from(this.sessions);
+          for (let i = 0; i < 1000; i++) {
+            this.sessions.delete(sessionsArray[i]);
+          }
+        }
+        if (!res.headersSent) {
+          res.writeHead(303, {
+            "Set-Cookie": `session=${id}; Path=/; SameSite=Lax`,
+            "X-Session-ID": id,
+            Location: "/",
+          });
+          res.end();
+        }
+      } else {
+        if (!res.headersSent) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              error: "unauthorized",
+              message: "Please enter the correct password.",
+            }),
+          );
+        }
+      }
+    } catch (loginErr) {
+      debug("Login error: %s", loginErr.message);
+      if (!res.headersSent) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "Bad Request",
+            message: "Invalid request body",
+          }),
+        );
+      }
+    }
+  }
+
+  handleLogout(req, res) {
+    if (req.headers.cookie) {
+      const params = new URLSearchParams(
+        req.headers.cookie.replace(/; /g, "&"),
+      );
+      const sessionId = params.get("session");
+      if (this.sessions.has(sessionId)) {
+        this.sessions.delete(sessionId);
+      }
+    }
+    res.writeHead(303, {
+      "Set-Cookie": "session=; HttpOnly; Path=/; Max-Age=0",
+      Location: "/",
+    });
+    res.end();
+  }
+}