domma-cms 0.8.10 → 0.9.1

package/plugins/todo/collections/todos/schema.json

@@ -0,0 +1,59 @@
+{
+  "slug": "todos",
+  "title": "Todos",
+  "description": "Todo items managed by the Todo plugin.",
+  "plugin": "todo",
+  "fields": [
+    {
+      "name": "text",
+      "label": "Task",
+      "type": "text",
+      "required": true
+    },
+    {
+      "name": "status",
+      "label": "Status",
+      "type": "text",
+      "required": false
+    },
+    {
+      "name": "priority",
+      "label": "Priority",
+      "type": "text",
+      "required": false
+    },
+    {
+      "name": "dueAt",
+      "label": "Due Date",
+      "type": "text",
+      "required": false
+    },
+    {
+      "name": "userId",
+      "label": "User ID",
+      "type": "text",
+      "required": false
+    }
+  ],
+  "api": {
+    "create": {
+      "enabled": true,
+      "access": "admin"
+    },
+    "read": {
+      "enabled": true,
+      "access": "admin"
+    },
+    "update": {
+      "enabled": false,
+      "access": "admin"
+    },
+    "delete": {
+      "enabled": false,
+      "access": "admin"
+    }
+  },
+  "storage": {
+    "adapter": "file"
+  }
+}

package/plugins/todo/plugin.js

@@ -4,44 +4,10 @@ import {
     createEntry,
     updateEntry,
     deleteEntry,
-    getEntry,
-    getCollection,
-    createCollection
+    getEntry
 } from '../../server/services/collections.js';
 
 const SLUG = 'todos';
-const STORAGE = defaultConfig.storage ?? {adapter: 'file'};
-
-const FIELDS = [
-    {name: 'text', label: 'Task', type: 'text', required: true},
-    {name: 'status', label: 'Status', type: 'text', required: false},
-    {name: 'priority', label: 'Priority', type: 'text', required: false},
-    {name: 'dueAt', label: 'Due Date', type: 'text', required: false},
-    {name: 'userId', label: 'User ID', type: 'text', required: false}
-];
-
-/**
- * Lifecycle: create the todos collection (MongoDB-backed) on plugin enable.
- */
-export async function onEnable({services: {collections}}) {
-    const existing = await collections.getCollection(SLUG).catch(() => null);
-    if (existing) return;
-    await collections.createCollection({
-        title: 'Todos',
-        slug: SLUG,
-        description: 'Todo items managed by the Todo plugin.',
-        fields: FIELDS,
-        storage: STORAGE
-    });
-}
-
-/**
- * Lifecycle: remove the todos collection on plugin disable.
- */
-export async function onDisable({services: {collections}}) {
-    await collections.deleteCollection(SLUG).catch(() => {
-    });
-}
 
 /** Flatten a collection entry into the shape the admin view expects. */
 function toTodo(entry) {
@@ -57,19 +23,6 @@ export default async function todoPlugin(fastify, options) {
     const { authenticate } = options.auth;
     const config = {...defaultConfig, ...(options.settings || {})};
     const scope = config.scope ?? 'user';
-    const storage = config.storage ?? STORAGE;
-
-    // Auto-create the collection if it doesn't exist yet.
-    const existing = await getCollection(SLUG).catch(() => null);
-    if (!existing) {
-        await createCollection({
-            title: 'Todos',
-            slug: SLUG,
-            description: 'Todo items managed by the Todo plugin.',
-            fields: FIELDS,
-            storage
-        }).catch(err => fastify.log.warn(`[todo] Collection setup: ${err.message}`));
-    }
 
     function userId(request) {
         return scope === 'user' ? (request.user?.id ?? request.user?.sub ?? null) : null;

package/server/routes/api/blocks.js

@@ -34,11 +34,11 @@ export async function blocksRoutes(fastify) {
     // Create or update block
     fastify.put('/blocks/:name', canUpdate, async (request, reply) => {
         const {name} = request.params;
-        const {content} = request.body || {};
+        const {content, bundled} = request.body || {};
         if (typeof content !== 'string') return reply.status(400).send({error: 'content (string) is required'});
 
         try {
-            return await saveBlock(name, content);
+            return await saveBlock(name, content, {bundled: !!bundled});
         } catch (err) {
             if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
             throw err;

package/server/services/blocks.js

@@ -180,10 +180,17 @@ export async function listBlocks() {
     for (const file of files.filter(f => f.endsWith('.html'))) {
         const name = file.slice(0, -5);
         const fileStat = await fs.stat(path.join(BLOCKS_DIR, file)).catch(() => null);
+        let bundled = false;
+        try {
+            const meta = JSON.parse(await fs.readFile(path.join(BLOCKS_DIR, `${name}.meta.json`), 'utf8'));
+            bundled = !!meta.bundled;
+        } catch { /* no meta file */
+        }
         blocks.push({
             name,
             size: fileStat?.size ?? 0,
             updatedAt: fileStat?.mtime?.toISOString() ?? null,
+            bundled,
         });
     }
     return blocks.sort((a, b) => a.name.localeCompare(b.name));
@@ -200,7 +207,13 @@ export async function getBlock(name) {
     assertValidName(name);
     try {
         const content = await fs.readFile(blockFilePath(name), 'utf8');
-        return {name, content};
+        let bundled = false;
+        try {
+            const meta = JSON.parse(await fs.readFile(path.join(BLOCKS_DIR, `${name}.meta.json`), 'utf8'));
+            bundled = !!meta.bundled;
+        } catch { /* no meta file */
+        }
+        return {name, content, bundled};
     } catch (err) {
         if (err.code === 'ENOENT') {
             const notFound = new Error('Block not found');
@@ -219,10 +232,17 @@ export async function getBlock(name) {
  * @returns {Promise<{success: boolean, name: string}>}
  * @throws {Error} With code INVALID_NAME on bad name
  */
-export async function saveBlock(name, content) {
+export async function saveBlock(name, content, {bundled} = {}) {
     assertValidName(name);
     await fs.mkdir(BLOCKS_DIR, {recursive: true});
     await fs.writeFile(blockFilePath(name), content, 'utf8');
+    const metaPath = path.join(BLOCKS_DIR, `${name}.meta.json`);
+    if (bundled) {
+        await fs.writeFile(metaPath, JSON.stringify({bundled: true}, null, 2) + '\n', 'utf8');
+    } else {
+        await fs.unlink(metaPath).catch(() => {
+        });
+    }
     return {success: true, name};
 }
 

package/server/services/collections.js

@@ -36,7 +36,13 @@ function slugify(str) {
 
 async function readSchema(slug) {
     const raw = await fs.readFile(schemaPath(slug), 'utf8');
-    return JSON.parse(raw);
+    const schema = JSON.parse(raw);
+    // Normalise legacy 'preset' flag — both mean "bundled with fresh installs"
+    if (schema.preset && !schema.bundled) {
+        schema.bundled = true;
+        delete schema.preset;
+    }
+    return schema;
 }
 
 async function writeSchema(schema) {
@@ -115,7 +121,7 @@ export async function getCollection(slug) {
  * @returns {Promise<object>} Created schema
  * @throws {Error} If a collection with that slug already exists
  */
-export async function createCollection({title, slug, description = '', fields = [], api = {}, storage}) {
+export async function createCollection({title, slug, description = '', fields = [], api = {}, storage, bundled, plugin}) {
     await ensureDir();
     const finalSlug = slug ? slugify(slug) : slugify(title);
     if (!finalSlug) throw new Error('Could not derive a slug from the title');
@@ -133,6 +139,8 @@ export async function createCollection({title, slug, description = '', fields =
         slug: finalSlug,
         title: title.trim(),
         description: description.trim(),
+        ...(bundled ? {bundled: true} : {}),
+        ...(plugin ? {plugin} : {}),
         fields,
         api: { ...defaultApiAccess(), ...api },
         storage: storage || {adapter: 'file'},
@@ -157,14 +165,20 @@ export async function updateCollection(slug, updates) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
 
-    const { slug: _ignore, createdAt, ...rest } = updates;
+    const { slug: _ignore, createdAt, plugin: _plugin, bundled: _bundled, ...rest } = updates;
     const updated = {
         ...schema,
         ...rest,
+        // bundled is user-editable — set from update, omit if falsy
+        ...(updates.bundled ? {bundled: true} : {}),
+        // plugin is ownership metadata — never overwrite from updates
+        ...(schema.plugin ? {plugin: schema.plugin} : {}),
         slug,
         createdAt: schema.createdAt,
         updatedAt: new Date().toISOString()
     };
+    // Clear bundled from schema if it was unchecked (schema spread may have preserved old value)
+    if (!updates.bundled) delete updated.bundled;
 
     await writeSchema(updated);
 

package/server/services/forms.js

@@ -115,7 +115,7 @@ export async function getForm(slug) {
  * @throws {Error} If title is missing, slug cannot be derived, or a form with the slug already exists.
  */
 export async function createForm(data) {
-    const { title, slug: rawSlug, description = '', fields = [], settings = {}, actions = {} } = data || {};
+    const { title, slug: rawSlug, description = '', fields = [], settings = {}, actions = {}, plugin } = data || {};
 
     if (!title?.trim() && !rawSlug?.trim()) {
         throw new Error('A title or slug is required to create a form.');
@@ -144,6 +144,7 @@ export async function createForm(data) {
         slug,
         title: trimmedTitle,
         description,
+        ...(plugin ? {plugin} : {}),
         fields: Array.isArray(fields) ? fields : [],
         settings: {
             submitText: 'Submit',

package/server/services/plugins.js

@@ -12,6 +12,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
+import matter from 'gray-matter';
 import {getConfig, saveConfig} from '../config.js';
 import {authenticate, requireAdmin, requireRole} from '../middleware/auth.js';
 import {hooks, registerSanitizeRules, registerShortcode, registerTransform} from './hooks.js';
@@ -231,6 +232,154 @@ export async function getInjectionSnippets() {
   return {head, headLate, bodyEnd};
 }
 
+/**
+ * Recursively collect all .md files under a directory.
+ * Returns an empty array if the directory does not exist.
+ *
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+async function walkMdFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, {withFileTypes: true});
+    } catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) results.push(...await walkMdFiles(full));
+        else if (entry.name.endsWith('.md')) results.push(full);
+    }
+    return results;
+}
+
+/**
+ * Set up all resources owned by a plugin: collections, forms, and pages.
+ * Each resource type is created only if it does not already exist (idempotent).
+ * Called automatically before `onEnable`.
+ *
+ * @param {string} pluginName
+ * @param {object} services - Service map from runLifecycleHook
+ * @returns {Promise<{collections: string[], forms: string[], pages: string[]}>}
+ */
+export async function setupPlugin(pluginName, services) {
+    const pluginDir = path.join(PLUGINS_DIR, pluginName);
+    const result = {collections: [], forms: [], pages: []};
+
+    // Collections
+    if (services.collections) {
+        let entries = [];
+        try {
+            entries = await fs.readdir(path.join(pluginDir, 'collections'), {withFileTypes: true});
+        } catch { /* no collections dir */ }
+        for (const entry of entries.filter(e => e.isDirectory())) {
+            const schemaPath = path.join(pluginDir, 'collections', entry.name, 'schema.json');
+            let schema;
+            try {
+                schema = JSON.parse(await fs.readFile(schemaPath, 'utf8'));
+            } catch {
+                continue;
+            }
+            schema.plugin = pluginName;
+            const existing = await services.collections.getCollection(schema.slug).catch(() => null);
+            if (!existing) {
+                await services.collections.createCollection(schema);
+                result.collections.push(schema.slug);
+            }
+        }
+    }
+
+    // Forms
+    if (services.forms) {
+        let entries = [];
+        try {
+            entries = await fs.readdir(path.join(pluginDir, 'forms'));
+        } catch { /* no forms dir */ }
+        for (const file of entries.filter(e => e.endsWith('.json'))) {
+            let data;
+            try {
+                data = JSON.parse(await fs.readFile(path.join(pluginDir, 'forms', file), 'utf8'));
+            } catch {
+                continue;
+            }
+            data.plugin = pluginName;
+            try {
+                await services.forms.createForm(data);
+                result.forms.push(data.slug || data.title);
+            } catch (err) {
+                if (err.code !== 'FORM_ALREADY_EXISTS') throw err;
+            }
+        }
+    }
+
+    // Pages
+    if (services.content) {
+        const pagesDir = path.join(pluginDir, 'pages');
+        const pageFiles = await walkMdFiles(pagesDir);
+        for (const filePath of pageFiles) {
+            let raw;
+            try {
+                raw = await fs.readFile(filePath, 'utf8');
+            } catch {
+                continue;
+            }
+            const parsed = matter(raw);
+            const rel = path.relative(pagesDir, filePath).replace(/\\/g, '/');
+            const urlPath = '/' + rel.replace(/\.md$/, '').replace(/\/index$/, '').replace(/^index$/, '');
+            parsed.data.plugin = pluginName;
+            const existing = await services.content.getPage(urlPath);
+            if (!existing) {
+                await services.content.createPage(urlPath, parsed.data, parsed.content.trim());
+                result.pages.push(urlPath);
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Remove all pages and forms owned by a plugin.
+ * Collections are intentionally preserved to protect stored data.
+ * Called automatically before `onDisable`.
+ *
+ * @param {string} pluginName
+ * @param {object} services - Service map from runLifecycleHook
+ * @param {import('fastify').FastifyInstance} [fastify]
+ * @returns {Promise<{forms: string[], pages: string[]}>}
+ */
+export async function teardownPlugin(pluginName, services, fastify) {
+    const removed = {forms: [], pages: []};
+
+    if (services.content) {
+        try {
+            const pages = await services.content.listPages();
+            for (const page of pages.filter(p => p.plugin === pluginName)) {
+                await services.content.deletePage(page.urlPath);
+                removed.pages.push(page.urlPath);
+            }
+        } catch (err) {
+            fastify?.log.warn(`[plugins] Could not remove pages for "${pluginName}": ${err.message}`);
+        }
+    }
+
+    if (services.forms) {
+        try {
+            const forms = await services.forms.listForms();
+            for (const form of forms.filter(f => f.plugin === pluginName)) {
+                await services.forms.deleteForm(form.slug);
+                removed.forms.push(form.slug);
+            }
+        } catch (err) {
+            fastify?.log.warn(`[plugins] Could not remove forms for "${pluginName}": ${err.message}`);
+        }
+    }
+
+    return removed;
+}
+
 /**
  * Run a lifecycle hook (onEnable or onDisable) for a plugin if it exports one.
  * Dynamically imports plugin.js and calls the named export with a context object.
@@ -241,6 +390,7 @@ export async function getInjectionSnippets() {
  * @param {import('fastify').FastifyInstance} fastify
  * @returns {Promise<void>}
  */
+
 export async function runLifecycleHook(name, hook, fastify) {
     // Validate hook name
     if (!['onEnable', 'onDisable'].includes(hook)) return;
@@ -285,7 +435,22 @@ export async function runLifecycleHook(name, hook, fastify) {
             }
         });
 
-        await mod[hook]({ fastify, services });
+        if (hook === 'onEnable') {
+            const setup = await setupPlugin(name, services);
+            if (setup.collections.length) fastify.log.info(`[plugins] Created collections for "${name}": ${setup.collections.join(', ')}`);
+            if (setup.forms.length) fastify.log.info(`[plugins] Created forms for "${name}": ${setup.forms.join(', ')}`);
+            if (setup.pages.length) fastify.log.info(`[plugins] Created pages for "${name}": ${setup.pages.join(', ')}`);
+        }
+
+        if (hook === 'onDisable') {
+            const torn = await teardownPlugin(name, services, fastify);
+            if (torn.pages.length) fastify.log.info(`[plugins] Removed pages for "${name}": ${torn.pages.join(', ')}`);
+            if (torn.forms.length) fastify.log.info(`[plugins] Removed forms for "${name}": ${torn.forms.join(', ')}`);
+        }
+
+        if (typeof mod[hook] === 'function') {
+            await mod[hook]({ fastify, services });
+        }
     } catch (err) {
         fastify.log.error(`Plugin "${name}" lifecycle hook "${hook}" failed: ${err.message}`);
     }