@bwog/bwog 0.0.0-stage → 0.1.0

package/databases/SqliteDatabase.js

@@ -0,0 +1,99 @@
+import { DatabaseSync } from 'node:sqlite';
+
+class SqliteDatabase {
+    constructor(file) {
+        this.file = file;
+    }
+
+    async connect() {
+        this.db = new DatabaseSync(this.file);
+    }
+
+    async makeFromJsonDatabase(JsonDatabase) {
+        this.db.exec(`
+            CREATE TABLE posts (
+                id TEXT PRIMARY KEY,
+                author TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                content JSONB NOT NULL
+            );
+        `);
+
+        const insertPost = this.db.prepare('INSERT INTO posts (id, author, created_at, content) VALUES (?, ?, ?, jsonb(?));');
+
+        JsonDatabase.getAll().forEach(post => {
+            const content = {...post};
+            delete content.id;
+            delete content.author;
+            delete content.createdAt;
+            insertPost.run(post.id, post.author, post.createdAt, JSON.stringify(content));
+        });
+    }
+
+    async getAll() {
+        const rawPosts = this.db.prepare(`
+            SELECT
+                id,
+                author,
+                created_at,
+                json(content) as content
+            FROM posts
+            ORDER BY created_at DESC;
+        `).all();
+
+        return rawPosts.map(post => ({
+            id: post.id,
+            author: post.author,
+            createdAt: post.created_at,
+            ...JSON.parse(post.content)
+        }));
+    }
+
+    async getLastTwoMonthsAtLeast20() {
+        const rawPosts = this.db.prepare(`
+            WITH latest_two_months AS (
+                SELECT DISTINCT strftime('%Y-%m', created_at) AS month
+                FROM posts
+                ORDER BY month DESC
+                LIMIT 2
+            ),
+            suitability AS (
+                SELECT *,
+                    CASE
+                        WHEN created_at IN latest_two_months THEN 1
+                        ELSE 0
+                    END AS in_latest_two_months,
+                    ROW_NUMBER() OVER (ORDER BY created_at DESC) AS recency
+                FROM posts
+            )
+            SELECT
+                id,
+                author,
+                created_at,
+                json(content) as content
+            FROM suitability
+            WHERE in_latest_two_months = 1
+               OR recency <= 20
+            ORDER BY created_at DESC;
+        `).all();
+
+        return rawPosts.map(post => ({
+            id: post.id,
+            author: post.author,
+            createdAt: post.created_at,
+            ...JSON.parse(post.content)
+        }));
+    }
+
+    async createPost(post) {
+        const insertPost = this.db.prepare('INSERT INTO posts (id, author, created_at, content) VALUES (?, ?, ?, jsonb(?));');
+
+        const content = {...post};
+        delete content.id;
+        delete content.author;
+        delete content.createdAt;
+        insertPost.run(post.id, post.author, post.createdAt, JSON.stringify(content));
+    }
+}
+
+export default SqliteDatabase;

package/generator.js

@@ -0,0 +1,460 @@
+import { Eta } from 'eta';
+import beautify from 'js-beautify';
+import { minify } from 'html-minifier-next';
+import {createTranslator} from 'short-uuid';
+
+import templates from './templates.js';
+
+class Generator {
+    constructor(store, database) {
+        this.store = store;
+        this.database = database;
+        this.eta = new Eta();
+    }
+
+    async generate(siteUrl, authorName, authorEmail, enableAP, apHandle, apUsername, apPublicKey) {
+        const posts = await this.database.getAll();
+        const sitemap = [];
+
+        const postsByMonth = posts.reduce((acc, post) => {
+            let currentMonth = null;
+            if (acc.length > 0) {
+                const lastDate = new Date(acc[acc.length - 1][0].createdAt);
+                const currentDate = new Date(post.createdAt);
+                if (lastDate.getFullYear() === currentDate.getFullYear() && lastDate.getMonth() === currentDate.getMonth()) {
+                    currentMonth = acc[acc.length - 1];
+                }
+            }
+
+            if (currentMonth === null) {
+                currentMonth = [];
+                acc.push(currentMonth);
+            }
+
+            currentMonth.push(post);
+
+            return acc;
+        }, []);
+
+        try {
+            await this.generateIndex(siteUrl, posts, sitemap);
+            await this.writeAtom(siteUrl, authorName, authorEmail, posts, 'feed.atom');
+        } catch (error) {
+            console.error(error);
+            return;
+        }
+
+        let previousMonth = postsByMonth[0][0].createdAt;
+        let currentMonth = null;
+        let nextMonth = null;
+        for (let i = 0; i < postsByMonth.length; ++i) {
+            nextMonth = currentMonth;
+            currentMonth = previousMonth;
+
+            if (postsByMonth.length > i + 1) {
+                previousMonth = postsByMonth[i + 1][0].createdAt;
+            } else {
+                previousMonth = null;
+            }
+
+            try {
+                await this.writePage(postsByMonth[i],
+                    this.displayMonthFromIsoTimestamp(currentMonth),
+                    `${siteUrl}/${this.filenameFromIsoTimestamp(currentMonth)}`,
+                    this.filenameFromIsoTimestamp(currentMonth),
+                    previousMonth === null ? null : this.filenameFromIsoTimestamp(previousMonth),
+                    nextMonth === null ? null : this.filenameFromIsoTimestamp(nextMonth));
+
+                sitemap.push({
+                    url: `${siteUrl}/${this.filenameFromIsoTimestamp(currentMonth)}`,
+                    updatedAt: currentMonth,
+                });
+
+                if (enableAP) {
+                    await this.writeAPOutboxPage(postsByMonth[i],
+                        siteUrl,
+                        this.filenameFromIsoTimestamp(currentMonth),
+                        nextMonth === null ? null : this.filenameFromIsoTimestamp(nextMonth),
+                        previousMonth === null ? null : this.filenameFromIsoTimestamp(previousMonth));
+                }
+            } catch (error) {
+                console.error(error);
+                return;
+            }
+        }
+
+        await this.writeSitemap(sitemap, 'sitemap.xml');
+
+        if (enableAP) {
+            await this.writeAPOutbox(posts, siteUrl, 'ap/outbox.json');
+            await this.writeAPWebfinger(siteUrl, apHandle, 'ap/webfinger.json');
+            await this.writeAPActor(siteUrl, apUsername, apPublicKey, authorName, 'ap/actor.json');
+        }
+    }
+
+    async generatePartial(siteUrl, authorName, authorEmail, enableAP, newPost) {
+        const posts = await this.database.getLastTwoMonthsAtLeast20();
+        const sitemap = [];
+
+        this.generateIndex(siteUrl, posts, sitemap);
+        await this.writeAtom(siteUrl, authorName, authorEmail, posts, 'feed.atom');
+
+        const newPostDate = new Date(newPost.createdAt);
+        const thisMonthPosts = posts.filter(post => {
+            const postDate = new Date(post.createdAt);
+
+            return postDate.getFullYear() === newPostDate.getFullYear()
+                && postDate.getMonth() === newPostDate.getMonth();
+        });
+        const isNewMonth = thisMonthPosts.length === 1;
+
+        try {
+            await this.writePage(thisMonthPosts,
+                this.displayMonthFromIsoTimestamp(newPost.createdAt),
+                `${siteUrl}/${this.filenameFromIsoTimestamp(newPost.createdAt)}`,
+                this.filenameFromIsoTimestamp(newPost.createdAt),
+                posts.length > thisMonthPosts.length ? this.filenameFromIsoTimestamp(posts[thisMonthPosts.length].createdAt) : null,
+                null);
+
+            if (enableAP) {
+                await this.writeAPOutboxPage(thisMonthPosts,
+                    siteUrl,
+                    this.filenameFromIsoTimestamp(newPost.createdAt),
+                    null,
+                    posts.length > thisMonthPosts.length ? this.filenameFromIsoTimestamp(posts[thisMonthPosts.length].createdAt) : null);
+            }
+        } catch (error) {
+            console.error(error);
+        }
+
+        if (isNewMonth) {
+            if (posts.length > 1) {
+                const prevPostDate = new Date(posts[1].createdAt);
+                const lastMonthPosts = posts.filter(post => {
+                    const postDate = new Date(post.createdAt);
+                    return postDate.getFullYear() === prevPostDate.getFullYear()
+                        && postDate.getMonth() === prevPostDate.getMonth()
+                });
+
+                try {
+                    await this.writePage(lastMonthPosts,
+                        this.displayMonthFromIsoTimestamp(posts[1].createdAt),
+                        `${siteUrl}/${this.filenameFromIsoTimestamp(posts[1].createdAt)}`,
+                        this.filenameFromIsoTimestamp(posts[1].createdAt),
+                        posts.length > lastMonthPosts.length + 1 ? this.filenameFromIsoTimestamp(posts[lastMonthPosts.length + 1].createdAt) : null,
+                        this.filenameFromIsoTimestamp(newPost.createdAt));
+
+                    if (enableAP) {
+                        await this.writeAPOutboxPage(lastMonthPosts,
+                            siteUrl,
+                            this.filenameFromIsoTimestamp(posts[1].createdAt),
+                            this.filenameFromIsoTimestamp(newPost.createdAt),
+                            posts.length > lastMonthPosts.length + 1 ? this.filenameFromIsoTimestamp(posts[lastMonthPosts.length + 1].createdAt) : null);
+                    }
+                } catch (error) {
+                    console.error(error);
+                }
+            }
+
+            const months = posts.reduce((acc, post) => {
+                if (acc.length === 0) {
+                    return [post.createdAt];
+                }
+
+                const postDate = new Date(post.createdAt);
+                const lastDate = new Date(acc[acc.length - 1]);
+
+                if (postDate.getFullYear() === lastDate.getFullYear() && postDate.getMonth() === lastDate.getMonth()) {
+                    return acc;
+                }
+
+                return [...acc, post.createdAt];
+            }, []);
+
+            months.forEach(month => sitemap.push({
+                url: `${siteUrl}/${this.filenameFromIsoTimestamp(month)}`,
+                updatedAt: month,
+            }));
+
+            await this.writeSitemap(sitemap, 'sitemap.xml');
+
+            if (enableAP) {
+                await this.writeAPOutbox(posts, 'ap/outbox.json');
+            }
+        }
+    }
+
+    async generateIndex(siteUrl, posts, sitemap) {
+        const mainPage = posts.slice(0, 10);
+
+        try {
+            await this.writePage(mainPage,
+                null,
+                `${siteUrl}/`,
+                'index',
+                this.filenameFromIsoTimestamp(posts[10].createdAt),
+                null);
+            sitemap.push({
+                url: `${siteUrl}/`,
+                updatedAt: mainPage[0].createdAt,
+            });
+        } catch (error) {
+            throw(error);
+        }
+    }
+
+    async writeSitemap(sitemap, file) {
+        const xml = beautify.html(
+            templates.sitemap.call(this.eta, {pages: sitemap}),
+            {end_with_newline: true},
+        );
+
+        try {
+            await this.store.write(file, xml, 'application/xml');
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writePage(posts, title, canonical, file, prevPage, nextPage) {
+        const html = beautify.html(
+            templates.default.call(this.eta, {posts, title, canonical, prevPage, nextPage}, {tab_size: 4, ignore: ['style', 'script']}),
+            {
+                end_with_newline: true,
+                space_after_anon_function: true,
+                operator_position: 'after-newline',
+                extra_liners: [],
+            },
+        );
+
+        try {
+            await this.store.write(file, html, 'text/html')
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writeAtom(siteUrl, authorName, authorEmail, posts, file) {
+        const translator = createTranslator();
+
+        const latestPosts = posts.slice(0, 20);
+
+        const postsWithDerivedData = await Promise.all(latestPosts.map(async post => ({
+            ...post,
+            title: post.text.replace(/(https:\/\/\S*)/g, '').replaceAll('\n', ' ').replace(/\s\s+/g, ' ').trimEnd() || 'link',
+            uuid: translator.toUUID(post.id),
+            archivePage: `${siteUrl}/${this.filenameFromIsoTimestamp(post.createdAt)}`,
+            html: await minify(templates.basic_html.call(this.eta, {post})),
+        })));
+
+        const xml = beautify.html(
+            templates.atom_feed.call(this.eta, {
+                siteUrl,
+                authorName,
+                authorEmail,
+                posts: postsWithDerivedData
+            }),
+            {end_with_newline: true},
+        );
+
+        try {
+            await this.store.write(file, xml, 'application/atom+xml')
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writeAPWebfinger(siteUrl, apHandle, file) {
+        const webfinger = {
+            "subject": `acct:${apHandle}`,
+            "aliases": [
+                siteUrl
+            ],
+            "links": [
+                {
+                    "rel": "self",
+                    "type": "application/activity+json",
+                    "href": `${siteUrl}/ap/actor`
+                },
+                {
+                    "rel": "http://webfinger.net/rel/profile-page",
+                    "type": "text/html",
+                    "href": siteUrl
+                }
+            ]
+        };
+
+        const json = beautify.js(
+            JSON.stringify(webfinger),
+            {end_with_newline: true},
+        );
+        try {
+            await this.store.write(file, json, 'application/jrd+json');
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writeAPActor(siteUrl, apUsername, apPublicKey, authorName, file) {
+        const actor = {
+            "@context": [
+                "https://www.w3.org/ns/activitystreams",
+                "https://w3id.org/security/v1"
+            ],
+            "id": `${siteUrl}/ap/actor`,
+            "type": "Person",
+            "preferredUsername": apUsername,
+            "name": authorName,
+            "inbox": `${siteUrl}/ap/inbox`,
+            "outbox": `${siteUrl}/ap/outbox`,
+            "icon": {
+                "type": "Image",
+                "mediaType": "image/png",
+                "url": `${siteUrl}/favicon.png`
+            },
+            "url": siteUrl,
+            "publicKey": {
+            "id": `${siteUrl}/ap/actor#main-key`,
+                "owner": `${siteUrl}/ap/actor`,
+                "publicKeyPem": apPublicKey
+            }
+        }
+
+        const json = beautify.js(
+            JSON.stringify(actor),
+            {end_with_newline: true},
+        );
+        try {
+            await this.store.write(file, json, 'application/activity+json');
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writeAPOutbox(posts, siteUrl, file) {
+        const url = `${siteUrl}/ap/outbox`;
+        const first = this.filenameFromIsoTimestamp(new Date(posts[0].createdAt));
+        const last = this.filenameFromIsoTimestamp(new Date(posts[posts.length - 1].createdAt));
+
+        const outbox = {
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollection",
+            "totalItems": posts.length,
+            "first": `${url}?page=${first}`,
+            "last": `${url}?page=${last}`
+        }
+
+        const json = beautify.js(
+            JSON.stringify(outbox),
+            {end_with_newline: true},
+        );
+        try {
+            await this.store.write(file, json, 'application/activity+json');
+        } catch (err) {
+            throw (`Failed to write file: ${file}`);
+        }
+    }
+
+    async writeAPOutboxPage(posts, siteUrl, currentMonth, prevPage, nextPage) {
+        const page = {
+            "@context": "https://www.w3.org/ns/activitystreams",
+            "type": "OrderedCollectionPage",
+            "id": `${siteUrl}/ap/outbox?page=${currentMonth}`,
+            "partOf": `${siteUrl}/ap/outbox`,
+            "prev": `${siteUrl}/ap/outbox?page=${prevPage}`,
+            "next": `${siteUrl}/ap/outbox?page=${nextPage}`,
+            "orderedItems": []
+        };
+
+        if (!prevPage) {
+            delete page.prev;
+        }
+
+        if (!nextPage) {
+            delete page.next;
+        }
+
+        for (const post of posts) {
+            const url = `${siteUrl}/ap/notes/${post.id}`;
+
+            const noteHtml = await minify(templates.basic_html.call(this.eta, {post}))
+
+            const note = {
+                "id": url,
+                "type": "Note",
+                "published": post.createdAt,
+                "url": `${siteUrl}/${currentMonth}`,
+                "attributedTo": `${siteUrl}/ap/actor`,
+                "to": [
+                    `${siteUrl}/ap/followers`
+                ],
+                "cc": [
+                    "https://www.w3.org/ns/activitystreams#Public"
+                ],
+                "sensitive": false,
+                "content": noteHtml
+            };
+
+            const create = {
+                "id": `${url}?activity=true`,
+                "type": "Create",
+                "actor": `${siteUrl}/ap/actor`,
+                "published": post.createdAt,
+                "to": [
+                    `${siteUrl}/ap/followers`
+                ],
+                "cc": [
+                    "https://www.w3.org/ns/activitystreams#Public"
+                ],
+                "object": note
+            };
+
+            page.orderedItems.push(create);
+
+            const notePath = `ap/notes/${post.id}.json`;
+            const noteJson = beautify.js(
+                JSON.stringify(note),
+                {end_with_newline: true},
+            );
+            try {
+                await this.store.write(notePath, noteJson, 'application/activity+json');
+            } catch (err) {
+                throw (`Failed to write file: ${notePath}`);
+            }
+
+            const createPath = `ap/creates/${post.id}.json`;
+            const createJson = beautify.js(
+                JSON.stringify(create),
+                {end_with_newline: true},
+            );
+            try {
+                await this.store.write(createPath, createJson, 'application/activity+json');
+            } catch (err) {
+                throw (`Failed to write file: ${createPath}`);
+            }
+        }
+
+        const pagePath = `ap/outbox_pages/${currentMonth}.json`;
+        const pageJson = beautify.js(
+            JSON.stringify(page),
+            {end_with_newline: true},
+        );
+        try {
+            await this.store.write(pagePath, pageJson, 'application/activity+json');
+        } catch (err) {
+            throw (`Failed to write file: ${pagePath}`);
+        }
+    }
+
+    filenameFromIsoTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        return `${date.getFullYear()}-${date.getMonth() + 1}`;
+    }
+
+    displayMonthFromIsoTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        return date.toLocaleDateString(undefined, {year: 'numeric', month: 'long'});
+    }
+}
+
+export default Generator;

package/nginx.config

@@ -0,0 +1,61 @@
+map $arg_resource $webfinger_resource {
+	"acct:username@example.com" /ap/webfinger.json;
+	"acct%3Ausername%40example.com" /ap/webfinger.json;
+}
+
+map $arg_page $outbox {
+	"" /ap/outbox.json;
+	"~^(?<i>[0-9]+-[0-9]+)?" /ap/outbox_pages/$i.json;
+}
+
+map $uri $note_id {
+	"~^/ap/notes/(?<id>.+)$" $id;
+}
+
+map $arg_activity $notes {
+	"true" /ap/creates/$note_id.json;
+	default /ap/notes/$note_id.json;
+}
+
+server {
+	listen 443 ssl;
+	ssl_certificate /etc/ssl/certs/example.com.crt;
+	ssl_certificate_key /etc/ssl/private/example.com.key;
+
+	server_name example.com;
+	root /var/www/example;
+	index index.html;
+
+	location / {
+		try_files $uri.html $uri $uri/ =404;
+	}
+
+	location ~ ^/(post|login|logout|oauth2/redirect/google) {
+		proxy_pass http://localhost:3000;
+		proxy_http_version 1.1;
+		proxy_set_header Upgrade $http_upgrade;
+		proxy_set_header Connection 'upgrade';
+		proxy_set_header Host $host;
+		proxy_cache_bypass $http_upgrade;
+	}
+
+	location /.well-known/webfinger {
+		default_type "application/jrd+json";
+		try_files $webfinger_resource =404;
+	}
+
+	location /ap {
+		types { } default_type "application/activity+json";
+		try_files $uri.json =404;
+	}
+
+	location /ap/outbox {
+		types { } default_type "application/activity+json";
+		try_files $outbox =404;
+	}
+
+	location /ap/notes {
+		types { } default_type "application/activity+json";
+		try_files $notes =404;
+	}
+}

package/package.json

@@ -1,6 +1,48 @@
-{
-  "name": "@bwog/bwog",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@bwog/bwog",
+  "version": "0.1.0",
+  "description": "bwog is a toy static site generator for a tumblelog/microblog",
+  "keywords": [
+    "blog",
+    "cms",
+    "fediverse",
+    "microblog",
+    "tumblelog",
+    "smallweb",
+    "static-site-generator",
+    "ssg"
+  ],
+  "author": "Chase Patterson (https://github.com/chapatt)",
+  "homepage": "https://github.com/chapatt/bwog",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chapatt/bwog.git"
+  },
+  "bugs": "https://github.com/chapatt/bwog/issues",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.23.5"
+  },
+  "type": "module",
+  "dependencies": {
+    "@hono/oauth-providers": "^0.9.1",
+    "@minify-html/wasm": "^0.18.1",
+    "commander": "^13.1.0",
+    "dotenv": "^18.0.10",
+    "eta": "^4.6.0",
+    "express": "^5.1.0",
+    "express-session": "^1.18.1",
+    "hono": "^4.13.18",
+    "html-minifier-next": "^9.1.2",
+    "js-beautify": "^2.0.3",
+    "passport": "^0.7.0",
+    "passport-google-oauth20": "^2.0.0",
+    "short-uuid": "^6.0.3"
+  },
+  "scripts": {
+    "build": "node scripts/compile_templates.js"
+  },
+  "bin": {
+    "bwog": "./cli.js"
+  }
+}