domma-cms 0.10.0 → 0.13.0

package/plugins/blog/plugin.js

@@ -0,0 +1,352 @@
+import defaultConfig from './config.js';
+import {createEntry, deleteEntry, getEntry, listEntries, updateEntry} from '../../server/services/collections.js';
+import {getConfig, saveConfig} from '../../server/config.js';
+
+const POSTS_SLUG      = 'blog-posts';
+const CATEGORIES_SLUG = 'blog-categories';
+const COMMENTS_SLUG   = 'blog-comments';
+
+const PUBLISH_ROLES = ['blog-editor', 'admin', 'super-admin'];
+
+function canPublish(user) {
+    return PUBLISH_ROLES.includes(user?.role);
+}
+
+function isEditorOrAdmin(user) {
+    return canPublish(user);
+}
+
+/** Derive a URL slug from a title string. */
+function slugify(str) {
+    return String(str)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+
+function toPost(entry) {
+    return {
+        id: entry.id,
+        ...entry.data,
+        createdAt: entry.meta.createdAt,
+        updatedAt: entry.meta.updatedAt
+    };
+}
+
+function toCategory(entry) {
+    return {
+        id: entry.id,
+        ...entry.data,
+        createdAt: entry.meta.createdAt,
+        updatedAt: entry.meta.updatedAt
+    };
+}
+
+function toComment(entry) {
+    return {
+        id: entry.id,
+        ...entry.data,
+        createdAt: entry.meta.createdAt,
+        updatedAt: entry.meta.updatedAt
+    };
+}
+
+export default async function blogPlugin(fastify, options) {
+    const { authenticate, requireAdmin } = options.auth;
+    const settings = { ...defaultConfig, ...(options.settings || {}) };
+
+    // -------------------------------------------------------------------------
+    // Posts
+    // -------------------------------------------------------------------------
+
+    /** GET /api/plugins/blog/posts */
+    fastify.get('/posts', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        const { entries } = await listEntries(POSTS_SLUG, { limit: 100000, sort: 'createdAt', order: 'desc' });
+        let posts = entries.map(toPost);
+
+        if (!isEditorOrAdmin(user) && user?.role === 'blog-author') {
+            const uid = user?.id ?? user?.sub ?? null;
+            posts = posts.filter(p => p.authorId === uid);
+        }
+
+        return reply.send(posts);
+    });
+
+    /** POST /api/plugins/blog/posts */
+    fastify.post('/posts', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        const uid  = user?.id ?? user?.sub ?? null;
+        const body = request.body ?? {};
+
+        const {
+            title, content, excerpt, featuredImage,
+            categories, tags, status, slug
+        } = body;
+
+        const derivedSlug = slug
+            ? String(slug).trim()
+            : slugify(title ?? '');
+
+        const entry = await createEntry(POSTS_SLUG, {
+            title:         typeof title === 'string' ? title.trim() : '',
+            slug:          derivedSlug,
+            content:       typeof content === 'string' ? content : '',
+            excerpt:       typeof excerpt === 'string' ? excerpt.trim() : '',
+            featuredImage: featuredImage ?? null,
+            categories:    Array.isArray(categories) ? categories : [],
+            tags:          Array.isArray(tags) ? tags : [],
+            status:        status ?? 'draft',
+            authorId:      uid
+        }, { createdBy: uid, source: 'admin' });
+
+        return reply.code(201).send(toPost(entry));
+    });
+
+    /** GET /api/plugins/blog/posts/:id */
+    fastify.get('/posts/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        const entry = await getEntry(POSTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Post not found' });
+        return reply.send(toPost(entry));
+    });
+
+    /** PUT /api/plugins/blog/posts/:id */
+    fastify.put('/posts/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        const uid  = user?.id ?? user?.sub ?? null;
+        const { id } = request.params;
+
+        const entry = await getEntry(POSTS_SLUG, id);
+        if (!entry) return reply.code(404).send({ error: 'Post not found' });
+
+        if (!isEditorOrAdmin(user) && entry.data.authorId !== uid) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const updates = request.body ?? {};
+        const merged  = { ...entry.data, ...updates };
+
+        const updated = await updateEntry(POSTS_SLUG, id, merged);
+        return reply.send(toPost(updated));
+    });
+
+    /** DELETE /api/plugins/blog/posts/:id */
+    fastify.delete('/posts/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        if (!isEditorOrAdmin(user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const entry = await getEntry(POSTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Post not found' });
+
+        await deleteEntry(POSTS_SLUG, request.params.id);
+        return reply.send({ ok: true });
+    });
+
+    /** POST /api/plugins/blog/posts/:id/publish */
+    fastify.post('/posts/:id/publish', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        if (!canPublish(user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const entry = await getEntry(POSTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Post not found' });
+
+        const updated = await updateEntry(POSTS_SLUG, request.params.id, {
+            ...entry.data,
+            status:      'published',
+            publishedAt: new Date().toISOString()
+        });
+
+        return reply.send(toPost(updated));
+    });
+
+    /** POST /api/plugins/blog/posts/:id/schedule */
+    fastify.post('/posts/:id/schedule', { preHandler: [authenticate] }, async (request, reply) => {
+        const user = request.user;
+        if (!canPublish(user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const { publishedAt } = request.body ?? {};
+        if (!publishedAt) {
+            return reply.code(400).send({ error: 'publishedAt is required' });
+        }
+
+        const entry = await getEntry(POSTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Post not found' });
+
+        const updated = await updateEntry(POSTS_SLUG, request.params.id, {
+            ...entry.data,
+            status:      'scheduled',
+            publishedAt: String(publishedAt)
+        });
+
+        return reply.send(toPost(updated));
+    });
+
+    // -------------------------------------------------------------------------
+    // Categories
+    // -------------------------------------------------------------------------
+
+    /** GET /api/plugins/blog/categories */
+    fastify.get('/categories', { preHandler: [authenticate] }, async (request, reply) => {
+        const { entries } = await listEntries(CATEGORIES_SLUG, { limit: 10000, sort: 'createdAt', order: 'asc' });
+        return reply.send(entries.map(toCategory));
+    });
+
+    /** POST /api/plugins/blog/categories */
+    fastify.post('/categories', { preHandler: [authenticate] }, async (request, reply) => {
+        if (!isEditorOrAdmin(request.user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const { name, slug, description } = request.body ?? {};
+        if (!name || typeof name !== 'string' || !name.trim()) {
+            return reply.code(400).send({ error: 'name is required' });
+        }
+
+        const derivedSlug = slug ? String(slug).trim() : slugify(name);
+
+        const entry = await createEntry(CATEGORIES_SLUG, {
+            name:        name.trim(),
+            slug:        derivedSlug,
+            description: typeof description === 'string' ? description.trim() : ''
+        }, { source: 'admin' });
+
+        return reply.code(201).send(toCategory(entry));
+    });
+
+    /** PUT /api/plugins/blog/categories/:id */
+    fastify.put('/categories/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        if (!isEditorOrAdmin(request.user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const entry = await getEntry(CATEGORIES_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Category not found' });
+
+        const updates = request.body ?? {};
+        const merged  = { ...entry.data, ...updates };
+
+        const updated = await updateEntry(CATEGORIES_SLUG, request.params.id, merged);
+        return reply.send(toCategory(updated));
+    });
+
+    /** DELETE /api/plugins/blog/categories/:id */
+    fastify.delete('/categories/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        if (!isEditorOrAdmin(request.user)) {
+            return reply.code(403).send({ error: 'Forbidden' });
+        }
+
+        const entry = await getEntry(CATEGORIES_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Category not found' });
+
+        await deleteEntry(CATEGORIES_SLUG, request.params.id);
+        return reply.send({ ok: true });
+    });
+
+    // -------------------------------------------------------------------------
+    // Comments
+    // -------------------------------------------------------------------------
+
+    /** GET /api/plugins/blog/comments */
+    fastify.get('/comments', { preHandler: [authenticate] }, async (request, reply) => {
+        const { status: statusFilter, postId } = request.query;
+        const { entries } = await listEntries(COMMENTS_SLUG, { limit: 100000, sort: 'createdAt', order: 'desc' });
+        let comments = entries.map(toComment);
+
+        if (statusFilter) {
+            comments = comments.filter(c => c.status === statusFilter);
+        }
+        if (postId) {
+            comments = comments.filter(c => c.postId === postId);
+        }
+
+        return reply.send(comments);
+    });
+
+    /** POST /api/plugins/blog/comments — public, no authenticate */
+    fastify.post('/comments', async (request, reply) => {
+        const body = request.body ?? {};
+
+        // Honeypot: non-empty `website` field = bot, silently discard
+        if (body.website) {
+            return reply.code(201).send({ ok: true });
+        }
+
+        const { postId, authorName, authorEmail, authorUrl, body: commentBody } = body;
+
+        if (!postId)      return reply.code(400).send({ error: 'postId is required' });
+        if (!authorName)  return reply.code(400).send({ error: 'authorName is required' });
+        if (!authorEmail) return reply.code(400).send({ error: 'authorEmail is required' });
+        if (!commentBody) return reply.code(400).send({ error: 'body is required' });
+
+        const commentStatus = settings.commentModeration !== false ? 'pending' : 'approved';
+
+        const entry = await createEntry(COMMENTS_SLUG, {
+            postId:      String(postId),
+            authorName:  String(authorName).trim(),
+            authorEmail: String(authorEmail).trim(),
+            authorUrl:   authorUrl ? String(authorUrl).trim() : '',
+            body:        String(commentBody),
+            status:      commentStatus,
+            createdAt:   new Date().toISOString()
+        }, { source: 'public' });
+
+        return reply.code(201).send(toComment(entry));
+    });
+
+    /** PUT /api/plugins/blog/comments/:id */
+    fastify.put('/comments/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        const entry = await getEntry(COMMENTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Comment not found' });
+
+        const { status } = request.body ?? {};
+        const VALID_STATUSES = ['pending', 'approved', 'rejected', 'spam'];
+
+        const merged = { ...entry.data };
+        if (status !== undefined) {
+            if (!VALID_STATUSES.includes(status)) {
+                return reply.code(400).send({ error: `status must be one of: ${VALID_STATUSES.join(', ')}` });
+            }
+            merged.status = status;
+        }
+
+        const updated = await updateEntry(COMMENTS_SLUG, request.params.id, merged);
+        return reply.send(toComment(updated));
+    });
+
+    /** DELETE /api/plugins/blog/comments/:id */
+    fastify.delete('/comments/:id', { preHandler: [authenticate] }, async (request, reply) => {
+        const entry = await getEntry(COMMENTS_SLUG, request.params.id);
+        if (!entry) return reply.code(404).send({ error: 'Comment not found' });
+
+        await deleteEntry(COMMENTS_SLUG, request.params.id);
+        return reply.send({ ok: true });
+    });
+
+    // -------------------------------------------------------------------------
+    // Settings
+    // -------------------------------------------------------------------------
+
+    /** GET /api/plugins/blog/settings */
+    fastify.get('/settings', { preHandler: [authenticate] }, async (request, reply) => {
+        const cfg      = getConfig();
+        const overrides = cfg.plugins?.blog?.settings ?? {};
+        return reply.send({ ...defaultConfig, ...overrides });
+    });
+
+    /** PUT /api/plugins/blog/settings */
+    fastify.put('/settings', { preHandler: [requireAdmin] }, async (request, reply) => {
+        const body = request.body ?? {};
+        const cfg  = getConfig();
+        cfg.plugins            ??= {};
+        cfg.plugins.blog       ??= {};
+        cfg.plugins.blog.settings = body;
+        await saveConfig(cfg);
+        return reply.send({ ok: true });
+    });
+}

package/plugins/blog/plugin.json

@@ -0,0 +1,96 @@
+{
+  "name": "blog",
+  "displayName": "Blog",
+  "version": "1.0.0",
+  "description": "Public-facing blog with posts, categories, and comments.",
+  "author": "Domma CMS",
+  "date": "2026-04-07",
+  "icon": "file-text",
+  "admin": {
+    "sidebar": [
+      {
+        "id": "blog",
+        "text": "Blog",
+        "icon": "file-text",
+        "url": "#/plugins/blog",
+        "section": "#/plugins/blog",
+        "children": [
+          {
+            "id": "blog-posts",
+            "text": "Posts",
+            "url": "#/plugins/blog/posts"
+          },
+          {
+            "id": "blog-categories",
+            "text": "Categories",
+            "url": "#/plugins/blog/categories"
+          },
+          {
+            "id": "blog-comments",
+            "text": "Comments",
+            "url": "#/plugins/blog/comments"
+          },
+          {
+            "id": "blog-settings",
+            "text": "Settings",
+            "url": "#/plugins/blog/settings"
+          }
+        ]
+      }
+    ],
+    "routes": [
+      {
+        "path": "/plugins/blog/posts",
+        "view": "plugin-blog-posts",
+        "title": "Blog Posts - Domma CMS"
+      },
+      {
+        "path": "/plugins/blog/posts/new",
+        "view": "plugin-blog-post-editor",
+        "title": "New Post - Domma CMS"
+      },
+      {
+        "path": "/plugins/blog/posts/:id",
+        "view": "plugin-blog-post-editor",
+        "title": "Edit Post - Domma CMS"
+      },
+      {
+        "path": "/plugins/blog/categories",
+        "view": "plugin-blog-categories",
+        "title": "Blog Categories - Domma CMS"
+      },
+      {
+        "path": "/plugins/blog/comments",
+        "view": "plugin-blog-comments",
+        "title": "Blog Comments - Domma CMS"
+      },
+      {
+        "path": "/plugins/blog/settings",
+        "view": "plugin-blog-settings",
+        "title": "Blog Settings - Domma CMS"
+      }
+    ],
+    "views": {
+      "plugin-blog-posts": {
+        "entry": "blog/admin/views/blog.js?v=73a4a936",
+        "exportName": "blogView"
+      },
+      "plugin-blog-post-editor": {
+        "entry": "blog/admin/views/post-editor.js?v=3288949c",
+        "exportName": "postEditorView"
+      },
+      "plugin-blog-categories": {
+        "entry": "blog/admin/views/categories.js?v=489c8dfe",
+        "exportName": "categoriesView"
+      },
+      "plugin-blog-comments": {
+        "entry": "blog/admin/views/comments.js?v=47c59ee8",
+        "exportName": "commentsView"
+      },
+      "plugin-blog-settings": {
+        "entry": "blog/admin/views/settings.js?v=3fab4235",
+        "exportName": "settingsView"
+      }
+    }
+  }
+}

package/plugins/blog/roles/blog-author.json

@@ -0,0 +1,10 @@
+{
+  "name": "blog-author",
+  "label": "Blog Author",
+  "level": 2,
+  "permissions": ["blog-posts"],
+  "badgeClass": "badge-info",
+  "resources": [
+    { "key": "blog-posts", "label": "Blog Posts", "actions": ["read", "create", "update"] }
+  ]
+}

package/plugins/blog/roles/blog-editor.json

@@ -0,0 +1,12 @@
+{
+  "name": "blog-editor",
+  "label": "Blog Editor",
+  "level": 2,
+  "permissions": ["blog-posts", "blog-categories", "blog-comments"],
+  "badgeClass": "badge-success",
+  "resources": [
+    { "key": "blog-posts",      "label": "Blog Posts",      "actions": ["read", "create", "update", "delete", "publish"] },
+    { "key": "blog-categories", "label": "Blog Categories", "actions": ["read", "create", "update", "delete"] },
+    { "key": "blog-comments",   "label": "Blog Comments",   "actions": ["read", "update", "delete"] }
+  ]
+}

package/plugins/blog/templates/author.html

@@ -0,0 +1,9 @@
+<main class="container" style="padding: 2rem 0;">
+  <h1 class="mb-4">{{archiveTitle}}</h1>
+  <div id="blog-posts-list">
+    {{posts}}
+  </div>
+  <div id="blog-pagination" class="mt-4">
+    {{pagination}}
+  </div>
+</main>

package/plugins/blog/templates/category.html

@@ -0,0 +1,9 @@
+<main class="container" style="padding: 2rem 0;">
+  <h1 class="mb-4">{{archiveTitle}}</h1>
+  <div id="blog-posts-list">
+    {{posts}}
+  </div>
+  <div id="blog-pagination" class="mt-4">
+    {{pagination}}
+  </div>
+</main>

package/plugins/blog/templates/index.html

@@ -0,0 +1,9 @@
+<main class="container" style="padding: 2rem 0;">
+  <h1 class="mb-4">{{archiveTitle}}</h1>
+  <div id="blog-posts-list">
+    {{posts}}
+  </div>
+  <div id="blog-pagination" class="mt-4">
+    {{pagination}}
+  </div>
+</main>

package/plugins/blog/templates/post.html

@@ -0,0 +1,17 @@
+<main class="container" style="padding: 2rem 0;">
+  <article>
+    <header class="mb-4">
+      <h1>{{title}}</h1>
+      <p class="text-muted">by {{authorName}} &bull; <time>{{publishedAt}}</time></p>
+      <div class="mb-2">{{categories}}{{tags}}</div>
+    </header>
+    <div class="post-content mb-5">
+      {{content}}
+    </div>
+  </article>
+
+  <section id="comments" class="mt-5">
+    {{comments}}
+    {{commentForm}}
+  </section>
+</main>

package/plugins/blog/templates/tag.html

@@ -0,0 +1,9 @@
+<main class="container" style="padding: 2rem 0;">
+  <h1 class="mb-4">{{archiveTitle}}</h1>
+  <div id="blog-posts-list">
+    {{posts}}
+  </div>
+  <div id="blog-pagination" class="mt-4">
+    {{pagination}}
+  </div>
+</main>

package/plugins/contacts/collections/user-contact-groups/schema.json

@@ -1,5 +1,5 @@
 {
-  "slug": "user-contact-groups",
+  "slug": "contacts-groups",
   "title": "Contact Groups",
   "description": "Groups for the Contacts plugin.",
   "plugin": "contacts",

package/plugins/contacts/collections/user-contacts/schema.json

@@ -1,5 +1,5 @@
 {
-  "slug": "user-contacts",
+  "slug": "contacts-contacts",
   "title": "Contacts",
   "description": "Contacts managed by the Contacts plugin.",
   "plugin": "contacts",

package/plugins/contacts/plugin.js

@@ -1,14 +1,8 @@
 import defaultConfig from './config.js';
-import {
-    listEntries,
-    createEntry,
-    updateEntry,
-    deleteEntry,
-    getEntry
-} from '../../server/services/collections.js';
-
-const CONTACTS_SLUG = 'user-contacts';
-const GROUPS_SLUG = 'user-contact-groups';
+import {createEntry, deleteEntry, getEntry, listEntries, updateEntry} from '../../server/services/collections.js';
+
+const CONTACTS_SLUG = 'contacts-contacts';
+const GROUPS_SLUG = 'contacts-groups';
 
 /** Map a collection entry to the shape the admin view expects. */
 function toContact(entry) {

package/plugins/contacts/plugin.json

@@ -8,14 +8,24 @@
   "icon": "users",
   "admin": {
     "sidebar": [
-      { "id": "contacts", "text": "Contacts", "icon": "users", "url": "#/plugins/contacts", "section": "#/plugins/contacts" }
+      {
+        "id": "contacts",
+        "text": "Contacts",
+        "icon": "users",
+        "url": "#/plugins/contacts",
+        "section": "#/plugins/contacts"
+      }
     ],
     "routes": [
-      { "path": "/plugins/contacts", "view": "plugin-contacts", "title": "Contacts - Domma CMS" }
+      {
+        "path": "/plugins/contacts",
+        "view": "plugin-contacts",
+        "title": "Contacts - Domma CMS"
+      }
     ],
     "views": {
       "plugin-contacts": {
-        "entry": "contacts/admin/views/contacts.js",
+        "entry": "contacts/admin/views/contacts.js?v=4d7ec7f7",
         "exportName": "contactsView"
       }
     }

package/plugins/notes/collections/user-notes/schema.json

@@ -1,5 +1,5 @@
 {
-  "slug": "user-notes",
+  "slug": "notes-notes",
   "title": "Notes",
   "description": "Notes managed by the Notes plugin.",
   "plugin": "notes",

package/plugins/notes/plugin.js

@@ -1,13 +1,7 @@
 import defaultConfig from './config.js';
-import {
-    listEntries,
-    createEntry,
-    updateEntry,
-    deleteEntry,
-    getEntry
-} from '../../server/services/collections.js';
-
-const SLUG = 'user-notes';
+import {createEntry, deleteEntry, getEntry, listEntries, updateEntry} from '../../server/services/collections.js';
+
+const SLUG = 'notes-notes';
 
 /** Flatten a collection entry into the shape the admin view expects. */
 function toNote(entry) {

package/plugins/notes/plugin.json

@@ -8,14 +8,24 @@
   "icon": "file-text",
   "admin": {
     "sidebar": [
-      { "id": "notes", "text": "Notes", "icon": "file-text", "url": "#/plugins/notes", "section": "#/plugins/notes" }
+      {
+        "id": "notes",
+        "text": "Notes",
+        "icon": "file-text",
+        "url": "#/plugins/notes",
+        "section": "#/plugins/notes"
+      }
     ],
     "routes": [
-      { "path": "/plugins/notes", "view": "plugin-notes", "title": "Notes - Domma CMS" }
+      {
+        "path": "/plugins/notes",
+        "view": "plugin-notes",
+        "title": "Notes - Domma CMS"
+      }
     ],
     "views": {
       "plugin-notes": {
-        "entry": "notes/admin/views/notes.js?v=2",
+        "entry": "notes/admin/views/notes.js?v=43194b9f",
         "exportName": "notesView"
       }
     }

package/plugins/site-search/plugin.json

@@ -13,7 +13,10 @@
         "text": "Site Search",
         "icon": "search",
         "url": "#/plugins/site-search",
-        "section": "#/plugins/site-search"
+        "section": "#/plugins/site-search",
+        "permissions": [
+          "settings"
+        ]
       }
     ],
     "routes": [
@@ -25,7 +28,7 @@
     ],
     "views": {
       "plugin-site-search": {
-        "entry": "site-search/admin/views/site-search.js?v=4",
+        "entry": "site-search/admin/views/site-search.js?v=ff425f47",
         "exportName": "siteSearchView"
       }
     }