domma-cms 0.13.5 → 0.14.0

package/server/routes/api/components.js

@@ -0,0 +1,115 @@
+/**
+ * Components API
+ * CRUD + compilation + export/import for .dmc components.
+ *
+ * GET    /api/components              - list
+ * GET    /api/components/:name        - raw source + parsed props
+ * GET    /api/components/:name.js     - compiled JS module (public)
+ * POST   /api/components/compile      - transient compile for preview
+ * GET    /api/components/:name/export - download .dmcomponent.json
+ * POST   /api/components/import       - import .dmcomponent.json
+ * PUT    /api/components/:name        - create/update (compiles first)
+ * DELETE /api/components/:name        - delete
+ */
+import {authenticate, requirePermission} from '../../middleware/auth.js';
+import {
+    compileComponent,
+    deleteComponent,
+    exportBundle,
+    getCompiledJs,
+    getComponent,
+    importBundle,
+    listComponents,
+    saveComponent
+} from '../../services/components.js';
+
+export async function componentsRoutes(fastify) {
+    const canRead   = {preHandler: [authenticate, requirePermission('components', 'read')]};
+    const canUpdate = {preHandler: [authenticate, requirePermission('components', 'update')]};
+    const canDelete = {preHandler: [authenticate, requirePermission('components', 'delete')]};
+
+    // Public: compiled JS module (served to every page visitor).
+    fastify.get('/components/:name.js', async (request, reply) => {
+        const {name} = request.params;
+        try {
+            const {js, errors, mtime} = await getCompiledJs(name);
+            if (errors.length) return reply.status(500).send({error: 'Compile failed', errors});
+            reply.header('Content-Type', 'application/javascript; charset=utf-8');
+            reply.header('Cache-Control', 'public, max-age=60, must-revalidate');
+            reply.header('ETag', `"${name}-${mtime}"`);
+            return js;
+        } catch (err) {
+            if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
+            if (err.code === 'ENOENT')       return reply.status(404).send({error: 'Component not found'});
+            throw err;
+        }
+    });
+
+    fastify.get('/components', canRead, () => listComponents());
+
+    fastify.get('/components/:name', canRead, async (request, reply) => {
+        try { return await getComponent(request.params.name); }
+        catch (err) {
+            if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
+            if (err.code === 'ENOENT')       return reply.status(404).send({error: 'Component not found'});
+            throw err;
+        }
+    });
+
+    fastify.post('/components/compile', canUpdate, async (request, reply) => {
+        const {source, name} = request.body || {};
+        if (typeof source !== 'string' || typeof name !== 'string') {
+            return reply.status(400).send({error: 'source and name are required'});
+        }
+        return compileComponent(source, name);
+    });
+
+    fastify.get('/components/:name/export', canRead, async (request, reply) => {
+        const {name} = request.params;
+        try {
+            const bundle = await exportBundle(name);
+            reply.header('Content-Type', 'application/json; charset=utf-8');
+            reply.header('Content-Disposition', `attachment; filename="${name}.dmcomponent.json"`);
+            return JSON.stringify(bundle, null, 2);
+        } catch (err) {
+            if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
+            if (err.code === 'ENOENT')       return reply.status(404).send({error: 'Component not found'});
+            throw err;
+        }
+    });
+
+    fastify.post('/components/import', canUpdate, async (request, reply) => {
+        try { return await importBundle(request.body, {overwrite: !!request.body?.overwrite}); }
+        catch (err) {
+            if (err.code === 'CONFLICT')       return reply.status(409).send({error: err.message, name: err.name});
+            if (err.code === 'INVALID_BUNDLE') return reply.status(400).send({error: err.message});
+            if (err.code === 'INVALID_NAME')   return reply.status(400).send({error: err.message});
+            throw err;
+        }
+    });
+
+    fastify.put('/components/:name', canUpdate, async (request, reply) => {
+        const {name} = request.params;
+        const {source, bundled} = request.body || {};
+        if (typeof source !== 'string') return reply.status(400).send({error: 'source (string) is required'});
+        try {
+            const result = await saveComponent(name, source, {bundled: !!bundled});
+            if (!result.success) return reply.status(400).send({error: 'Compile failed', errors: result.errors});
+            return result;
+        } catch (err) {
+            if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
+            if (err.code === 'PLUGIN_OWNED') return reply.status(409).send({error: err.message});
+            throw err;
+        }
+    });
+
+    fastify.delete('/components/:name', canDelete, async (request, reply) => {
+        try { await deleteComponent(request.params.name); return reply.status(204).send(); }
+        catch (err) {
+            if (err.code === 'INVALID_NAME') return reply.status(400).send({error: err.message});
+            if (err.code === 'ENOENT')       return reply.status(404).send({error: 'Component not found'});
+            if (err.code === 'PLUGIN_OWNED') return reply.status(409).send({error: err.message});
+            throw err;
+        }
+    });
+}

package/server/routes/api/layouts.js

@@ -22,12 +22,36 @@ const BUILTIN_PRESETS = {
         builtin: true, navbar: true, footer: true, sidebar: false,
         width: 'normal', bgColor: '', bgImage: '', class: ''
     },
+    article: {
+        key: 'article', label: 'Article',
+        description: 'Narrow reading column for long-form prose and blog posts.',
+        builtin: true, navbar: true, footer: true, sidebar: false,
+        width: 'narrow', bgColor: '', bgImage: '', class: ''
+    },
+    wide: {
+        key: 'wide', label: 'Wide',
+        description: 'Standard page with navbar and footer, using a wide content column (~75% of viewport).',
+        builtin: true, navbar: true, footer: true, sidebar: false,
+        width: 'wide', bgColor: '', bgImage: '', class: ''
+    },
     landing: {
         key: 'landing', label: 'Landing Page',
         description: 'Full-width landing page with navbar, no footer.',
         builtin: true, navbar: true, footer: false, sidebar: false,
         width: 'full', bgColor: '', bgImage: '', class: ''
     },
+    product: {
+        key: 'product', label: 'Product Page',
+        description: 'Full-width marketing page that keeps the footer.',
+        builtin: true, navbar: true, footer: true, sidebar: false,
+        width: 'full', bgColor: '', bgImage: '', class: ''
+    },
+    dashboard: {
+        key: 'dashboard', label: 'Dashboard',
+        description: 'Wide layout for data-heavy or app-like pages; no footer.',
+        builtin: true, navbar: true, footer: false, sidebar: false,
+        width: 'wide', bgColor: '', bgImage: '', class: ''
+    },
     blank: {
         key: 'blank', label: 'Blank',
         description: 'Minimal page with no navbar or footer.',

package/server/routes/api/pages.js

@@ -1,132 +1,135 @@
-/**
- * Pages API
- * GET    /api/pages          - list all pages
- * GET    /api/pages/*        - get single page by URL path
- * POST   /api/pages          - create page
- * PUT    /api/pages/*        - update page
- * DELETE /api/pages/*        - delete page
- */
-import {createPage, deletePage, getPage, listPages, renamePage, updatePage} from '../../services/content.js';
-import {parseMarkdown} from '../../services/markdown.js';
-import {authenticate, requirePermission} from '../../middleware/auth.js';
-import {getConfig, saveConfig} from '../../config.js';
-
-export async function pagesRoutes(fastify) {
-    const canRead = {preHandler: [authenticate, requirePermission('pages', 'read')]};
-    const canCreate = {preHandler: [authenticate, requirePermission('pages', 'create')]};
-    const canUpdate = {preHandler: [authenticate, requirePermission('pages', 'update')]};
-    const canDelete = {preHandler: [authenticate, requirePermission('pages', 'delete')]};
-
-  // Render markdown preview (shortcodes + sanitize, no frontmatter)
-    fastify.post('/pages/preview', canRead, async (request, reply) => {
-    const {markdown} = request.body;
-    if (typeof markdown !== 'string') return reply.status(400).send({error: 'markdown must be a string'});
-    const {html} = await parseMarkdown(`---\ntitle: preview\n---\n${markdown}`);
-    return {html};
-  });
-
-    // Aggregate unique tags from all pages — must be registered before the wildcard /pages/* route
-    fastify.get('/pages/tags', canRead, async (request, reply) => {
-        const pages = await listPages();
-        const tagSet = new Set();
-        pages.forEach(p => {
-            if (Array.isArray(p.tags)) p.tags.forEach(t => { if (t) tagSet.add(t); });
-        });
-        return { tags: [...tagSet].sort() };
-    });
-
-    // List all pages
-    fastify.get('/pages', canRead, async (request, reply) => {
-        const pages = await listPages();
-        return pages.map(p => ({
-            urlPath: p.urlPath,
-            title: p.title,
-            slug: p.slug,
-            status: p.status,
-            layout: p.layout,
-            showInNav: p.showInNav,
-            sortOrder: p.sortOrder,
-          category: p.category || null,
-          visibility: p.visibility || 'public',
-          tags: p.tags || [],
-            updatedAt: p.updatedAt,
-            createdAt: p.createdAt
-        }));
-    });
-
-    // Get single page
-    fastify.get('/pages/*', canRead, async (request, reply) => {
-        const urlPath = '/' + request.params['*'];
-        const page = await getPage(urlPath);
-        if (!page) return reply.status(404).send({ error: 'Page not found' });
-        return page;
-    });
-
-    // Create page
-    fastify.post('/pages', canCreate, async (request, reply) => {
-        const { urlPath, frontmatter, body } = request.body;
-        if (!urlPath) return reply.status(400).send({ error: 'urlPath is required' });
-
-        const existing = await getPage(urlPath);
-        if (existing) return reply.status(409).send({ error: 'Page already exists at that path' });
-
-        const page = await createPage(urlPath, frontmatter || {}, body || '');
-        return reply.status(201).send(page);
-    });
-
-    // Update page (optionally rename to a new URL path)
-    fastify.put('/pages/*', canUpdate, async (request, reply) => {
-        const urlPath = '/' + request.params['*'];
-        const { frontmatter, body, newUrlPath } = request.body;
-
-        const existing = await getPage(urlPath);
-        if (!existing) return reply.status(404).send({ error: 'Page not found' });
-
-        if (newUrlPath && newUrlPath !== urlPath) {
-            const conflict = await getPage(newUrlPath);
-            if (conflict) return reply.status(409).send({ error: 'A page already exists at that path' });
-
-            await renamePage(urlPath, newUrlPath);
-            await rewriteNavLinks(urlPath, newUrlPath);
-
-            const page = await updatePage(newUrlPath, frontmatter || {}, body, {author: request.user.username});
-            return page;
-        }
-
-        const page = await updatePage(urlPath, frontmatter || {}, body, {author: request.user.username});
-        return page;
-    });
-
-    // Delete page
-    fastify.delete('/pages/*', canDelete, async (request, reply) => {
-        const urlPath = '/' + request.params['*'];
-        const existing = await getPage(urlPath);
-        if (!existing) return reply.status(404).send({ error: 'Page not found' });
-
-        await deletePage(urlPath);
-        return { success: true };
-    });
-}
-
-/**
- * Rewrite any navigation item URLs that match oldUrlPath to newUrlPath,
- * then persist the updated navigation config.
- *
- * @param {string} oldUrlPath
- * @param {string} newUrlPath
- * @returns {Promise<void>}
- */
-async function rewriteNavLinks(oldUrlPath, newUrlPath) {
-    const nav = getConfig('navigation');
-    if (!nav?.items?.length) return;
-
-    let changed = false;
-    for (const item of nav.items) {
-        if (item.url === oldUrlPath) { item.url = newUrlPath; changed = true; }
-        for (const child of item.children || []) {
-            if (child.url === oldUrlPath) { child.url = newUrlPath; changed = true; }
-        }
-    }
-
-    if (changed) await saveConfig('navigation', nav);
-}
+/**
+ * Pages API
+ * GET    /api/pages          - list all pages
+ * GET    /api/pages/*        - get single page by URL path
+ * POST   /api/pages          - create page
+ * PUT    /api/pages/*        - update page
+ * DELETE /api/pages/*        - delete page
+ */
+import {createPage, deletePage, getPage, listPages, renamePage, updatePage} from '../../services/content.js';
+import {parseMarkdown} from '../../services/markdown.js';
+import {getVersionCount} from '../../services/versions.js';
+import {authenticate, requirePermission} from '../../middleware/auth.js';
+import {getConfig, saveConfig} from '../../config.js';
+
+export async function pagesRoutes(fastify) {
+    const canRead = {preHandler: [authenticate, requirePermission('pages', 'read')]};
+    const canCreate = {preHandler: [authenticate, requirePermission('pages', 'create')]};
+    const canUpdate = {preHandler: [authenticate, requirePermission('pages', 'update')]};
+    const canDelete = {preHandler: [authenticate, requirePermission('pages', 'delete')]};
+
+  // Render markdown preview (shortcodes + sanitize, no frontmatter)
+    fastify.post('/pages/preview', canRead, async (request, reply) => {
+    const {markdown} = request.body;
+    if (typeof markdown !== 'string') return reply.status(400).send({error: 'markdown must be a string'});
+    const {html} = await parseMarkdown(`---\ntitle: preview\n---\n${markdown}`);
+    return {html};
+  });
+
+    // Aggregate unique tags from all pages — must be registered before the wildcard /pages/* route
+    fastify.get('/pages/tags', canRead, async (request, reply) => {
+        const pages = await listPages();
+        const tagSet = new Set();
+        pages.forEach(p => {
+            if (Array.isArray(p.tags)) p.tags.forEach(t => { if (t) tagSet.add(t); });
+        });
+        return { tags: [...tagSet].sort() };
+    });
+
+    // List all pages
+    fastify.get('/pages', canRead, async (request, reply) => {
+        const pages = await listPages();
+        const counts = await Promise.all(pages.map(p => getVersionCount(p.urlPath)));
+        return pages.map((p, i) => ({
+            urlPath: p.urlPath,
+            title: p.title,
+            slug: p.slug,
+            status: p.status,
+            layout: p.layout,
+            showInNav: p.showInNav,
+            sortOrder: p.sortOrder,
+            category: p.category || null,
+            visibility: p.visibility || 'public',
+            tags: p.tags || [],
+            updatedAt: p.updatedAt,
+            createdAt: p.createdAt,
+            versionCount: counts[i]
+        }));
+    });
+
+    // Get single page
+    fastify.get('/pages/*', canRead, async (request, reply) => {
+        const urlPath = '/' + request.params['*'];
+        const page = await getPage(urlPath);
+        if (!page) return reply.status(404).send({ error: 'Page not found' });
+        return page;
+    });
+
+    // Create page
+    fastify.post('/pages', canCreate, async (request, reply) => {
+        const { urlPath, frontmatter, body } = request.body;
+        if (!urlPath) return reply.status(400).send({ error: 'urlPath is required' });
+
+        const existing = await getPage(urlPath);
+        if (existing) return reply.status(409).send({ error: 'Page already exists at that path' });
+
+        const page = await createPage(urlPath, frontmatter || {}, body || '');
+        return reply.status(201).send(page);
+    });
+
+    // Update page (optionally rename to a new URL path)
+    fastify.put('/pages/*', canUpdate, async (request, reply) => {
+        const urlPath = '/' + request.params['*'];
+        const { frontmatter, body, newUrlPath } = request.body;
+
+        const existing = await getPage(urlPath);
+        if (!existing) return reply.status(404).send({ error: 'Page not found' });
+
+        if (newUrlPath && newUrlPath !== urlPath) {
+            const conflict = await getPage(newUrlPath);
+            if (conflict) return reply.status(409).send({ error: 'A page already exists at that path' });
+
+            await renamePage(urlPath, newUrlPath);
+            await rewriteNavLinks(urlPath, newUrlPath);
+
+            const page = await updatePage(newUrlPath, frontmatter || {}, body, {author: request.user.username});
+            return page;
+        }
+
+        const page = await updatePage(urlPath, frontmatter || {}, body, {author: request.user.username});
+        return page;
+    });
+
+    // Delete page
+    fastify.delete('/pages/*', canDelete, async (request, reply) => {
+        const urlPath = '/' + request.params['*'];
+        const existing = await getPage(urlPath);
+        if (!existing) return reply.status(404).send({ error: 'Page not found' });
+
+        await deletePage(urlPath);
+        return { success: true };
+    });
+}
+
+/**
+ * Rewrite any navigation item URLs that match oldUrlPath to newUrlPath,
+ * then persist the updated navigation config.
+ *
+ * @param {string} oldUrlPath
+ * @param {string} newUrlPath
+ * @returns {Promise<void>}
+ */
+async function rewriteNavLinks(oldUrlPath, newUrlPath) {
+    const nav = getConfig('navigation');
+    if (!nav?.items?.length) return;
+
+    let changed = false;
+    for (const item of nav.items) {
+        if (item.url === oldUrlPath) { item.url = newUrlPath; changed = true; }
+        for (const child of item.children || []) {
+            if (child.url === oldUrlPath) { child.url = newUrlPath; changed = true; }
+        }
+    }
+
+    if (changed) await saveConfig('navigation', nav);
+}

package/server/routes/api/versions.js

@@ -14,6 +14,7 @@ import {
     deleteVersions,
     getVersion,
     listVersions,
+    pruneVersions,
     restoreVersion
 } from '../../services/versions.js';
 import {authenticate, requirePermission} from '../../middleware/auth.js';
@@ -82,6 +83,21 @@ export async function versionsRoutes(fastify) {
         }
     });
 
+    // Prune versions — keep the most recent N (policy decided in pruneVersions)
+    fastify.post('/versions/prune/*', canDelete, async (request, reply) => {
+        const urlPath = '/' + request.params['*'];
+        const keep = Number.parseInt(request.body?.keep, 10);
+        if (!Number.isFinite(keep) || keep < 0) {
+            return reply.status(400).send({error: 'keep must be a non-negative integer'});
+        }
+        try {
+            const result = await pruneVersions(urlPath, {keep});
+            return result;
+        } catch (err) {
+            return reply.status(400).send({error: err.message});
+        }
+    });
+
     // Bulk delete versions (POST used as DELETE with body is poorly supported)
     fastify.post('/versions/bulk-delete/*', canDelete, async (request, reply) => {
         const urlPath = '/' + request.params['*'];

package/server/server.js

@@ -22,6 +22,8 @@ import {load as loadRoles, seed as seedRoles} from './services/roles.js';
 import {ensureAllProfiles, seed as seedUserProfiles} from './services/userProfiles.js';
 import {seedAll as seedPresetCollections} from './services/presetCollections.js';
 import {seedDefaultBlocks} from './services/blocks.js';
+import {seedDefaultComponents} from './services/components.js';
+import {refreshComponentTagAllowlist} from './services/markdown.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '..');
@@ -167,6 +169,8 @@ await seedUserProfiles();
 await ensureAllProfiles();
 await seedPresetCollections();
 await seedDefaultBlocks();
+await seedDefaultComponents();
+await refreshComponentTagAllowlist();
 
 // Serve uploaded media files — nosniff prevents browsers rendering spoofed content types
 await app.register(staticPlugin, {
@@ -241,6 +245,7 @@ const { formsRoutes }       = await import('./routes/api/forms.js');
 const { viewsRoutes }       = await import('./routes/api/views.js');
 const { actionsRoutes }     = await import('./routes/api/actions.js');
 const {blocksRoutes} = await import('./routes/api/blocks.js');
+const {componentsRoutes} = await import('./routes/api/components.js');
 const {versionsRoutes} = await import('./routes/api/versions.js');
 const {effectsRoutes} = await import('./routes/api/effects.js');
 const {notificationsRoutes} = await import('./routes/api/notifications.js');
@@ -258,6 +263,7 @@ await app.register(formsRoutes,       { prefix: '/api' });
 await app.register(viewsRoutes,       { prefix: '/api' });
 await app.register(actionsRoutes,     { prefix: '/api' });
 await app.register(blocksRoutes, {prefix: '/api'});
+await app.register(componentsRoutes, {prefix: '/api'});
 await app.register(versionsRoutes, {prefix: '/api'});
 await app.register(effectsRoutes, {prefix: '/api'});
 await app.register(notificationsRoutes, {prefix: '/api'});