domma-cms 0.7.0 → 0.7.5

package/plugins/data-transfer/plugin.js

@@ -0,0 +1,424 @@
+/**
+ * Data Transfer Plugin — Backend
+ *
+ * Provides bulk collection transfer between file and MongoDB storage, plus
+ * timestamped backups and collection cloning.  All operations use raw adapter
+ * access (adapter.all / adapter.insertMany) so original IDs and metadata are
+ * preserved — in contrast to the per-collection migrate-storage endpoint which
+ * calls createEntry() and generates new UUIDs.
+ *
+ * Routes (prefixed /api/plugins/data-transfer/):
+ *   GET  /collections            — List transferable collections with adapter info
+ *   POST /transfer               — Bulk transfer selected collections
+ *   POST /backups                — Create a timestamped backup snapshot
+ *   GET  /backups                — List available backups
+ *   GET  /backups/:id            — Get single backup manifest
+ *   POST /backups/:id/restore    — Restore from a backup
+ *   DELETE /backups/:id          — Delete a backup
+ *   POST /clone                  — Clone a collection (schema + optional entries)
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import {randomUUID} from 'crypto';
+import {createCollection, getCollection, listCollections, updateCollection} from '../../server/services/collections.js';
+import {getAdapter} from '../../server/services/adapterRegistry.js';
+import {PRESET_COLLECTION_SLUGS} from '../../server/services/presetCollections.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BACKUPS_DIR = path.join(__dirname, 'backups');
+
+/** Slugs that are always forced to FileAdapter — cannot be transferred. */
+const PRESET_SLUGS = new Set(['roles', 'user-profiles', ...PRESET_COLLECTION_SLUGS]);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert an ISO timestamp to a filesystem-safe backup ID.
+ * Replaces colons with hyphens.
+ *
+ * @param {string} iso
+ * @returns {string}
+ */
+function toBackupId(iso) {
+    return iso.replace(/:/g, '-');
+}
+
+/**
+ * Convert a backup ID back to an ISO timestamp string.
+ *
+ * @param {string} id
+ * @returns {string}
+ */
+function fromBackupId(id) {
+    // Restore the two colons that belong in a full ISO timestamp (HH-MM-SS → HH:MM:SS)
+    return id.replace(/T(\d{2})-(\d{2})-(\d{2})/, 'T$1:$2:$3');
+}
+
+/**
+ * Read a backup manifest from disk.
+ *
+ * @param {string} id
+ * @returns {Promise<object>}
+ * @throws If directory or manifest does not exist
+ */
+async function readManifest(id) {
+    const manifestPath = path.join(BACKUPS_DIR, id, 'manifest.json');
+    const raw = await fs.readFile(manifestPath, 'utf8');
+    return JSON.parse(raw);
+}
+
+/**
+ * Enforce the maxBackups limit.  Deletes oldest backup directories when
+ * the count exceeds the configured maximum.
+ *
+ * @param {number} max
+ */
+async function pruneBackups(max) {
+    const entries = await fs.readdir(BACKUPS_DIR).catch(() => []);
+    if (entries.length <= max) return;
+
+    // Sort ascending (oldest first) by directory name (ISO timestamp prefix)
+    const sorted = entries.sort();
+    const toDelete = sorted.slice(0, entries.length - max);
+    await Promise.allSettled(
+        toDelete.map(name => fs.rm(path.join(BACKUPS_DIR, name), {recursive: true, force: true}))
+    );
+}
+
+/**
+ * Determine the target storage config for a given transfer direction.
+ *
+ * @param {'file-to-mongo'|'mongo-to-file'} direction
+ * @returns {{ storage: object }}
+ */
+function targetStorageConfig(direction) {
+    if (direction === 'file-to-mongo') {
+        return {adapter: 'mongodb', connection: 'default'};
+    }
+    return {adapter: 'file'};
+}
+
+// ---------------------------------------------------------------------------
+// Plugin
+// ---------------------------------------------------------------------------
+
+export default async function dataTransferPlugin(fastify, options) {
+    const {authenticate, requireAdmin} = options.auth;
+    const guard = [authenticate, requireAdmin];
+
+    // Ensure backup directory exists
+    await fs.mkdir(BACKUPS_DIR, {recursive: true});
+
+    // -------------------------------------------------------------------------
+    // GET /collections — list transferable collections
+    // -------------------------------------------------------------------------
+
+    fastify.get('/collections', {preHandler: guard}, async (_request, reply) => {
+        const all = await listCollections();
+
+        // Check MongoDB connectivity (best-effort)
+        let mongoConnected = false;
+        try {
+            const {isConnected} = await import('../../server/services/connectionManager.js');
+            mongoConnected = isConnected('default');
+        } catch {
+            // connectionManager not available (free mode) — leave false
+        }
+
+        const collections = all
+            .filter(col => !PRESET_SLUGS.has(col.slug))
+            .map(col => ({
+                slug: col.slug,
+                title: col.title,
+                adapter: col.storage?.adapter || 'file',
+                connection: col.storage?.connection || null,
+                entryCount: col.entryCount ?? 0
+            }));
+
+        return {collections, mongoConnected};
+    });
+
+    // -------------------------------------------------------------------------
+    // POST /transfer — bulk transfer selected collections
+    // -------------------------------------------------------------------------
+
+    fastify.post('/transfer', {preHandler: guard}, async (request, reply) => {
+        const {slugs, direction} = request.body || {};
+
+        if (!Array.isArray(slugs) || slugs.length === 0) {
+            return reply.status(400).send({error: 'slugs must be a non-empty array'});
+        }
+        if (direction !== 'file-to-mongo' && direction !== 'mongo-to-file') {
+            return reply.status(400).send({error: 'direction must be "file-to-mongo" or "mongo-to-file"'});
+        }
+
+        const results = [];
+
+        for (const slug of slugs) {
+            if (PRESET_SLUGS.has(slug)) {
+                results.push({slug, status: 'skipped', reason: 'preset collection — always file-based'});
+                continue;
+            }
+
+            try {
+                const schema = await getCollection(slug);
+                if (!schema) {
+                    results.push({slug, status: 'error', error: 'Collection not found'});
+                    continue;
+                }
+
+                const currentAdapter = schema.storage?.adapter || 'file';
+                const expectedSource = direction === 'file-to-mongo' ? 'file' : 'mongodb';
+                if (currentAdapter !== expectedSource) {
+                    results.push({slug, status: 'skipped', reason: `already on ${currentAdapter}`});
+                    continue;
+                }
+
+                // Step 1: read all entries from current adapter before schema change
+                const sourceAdapter = await getAdapter(slug);
+                const entries = await sourceAdapter.all(slug);
+
+                // Step 2: update schema to new adapter (invalidates cache)
+                const newStorage = targetStorageConfig(direction);
+                await updateCollection(slug, {...schema, storage: newStorage});
+
+                // Step 3: insert raw into new adapter (preserves IDs and meta)
+                const targetAdapter = await getAdapter(slug);
+                await targetAdapter.clear(slug);
+                if (entries.length > 0) {
+                    await targetAdapter.insertMany(slug, entries);
+                }
+
+                // Step 4: archive old data.json when leaving file storage
+                if (direction === 'file-to-mongo') {
+                    try {
+                        const dataPath = path.join(
+                            process.cwd(), 'content', 'collections', slug, 'data.json'
+                        );
+                        await fs.rename(dataPath, dataPath + '.bak');
+                    } catch {
+                        // data.json may not exist — not an error
+                    }
+                }
+
+                results.push({slug, status: 'ok', count: entries.length});
+            } catch (err) {
+                fastify.log.error(`[data-transfer] Transfer failed for "${slug}": ${err.message}`);
+                results.push({slug, status: 'error', error: err.message});
+            }
+        }
+
+        return {results};
+    });
+
+    // -------------------------------------------------------------------------
+    // POST /backups — create a timestamped backup
+    // -------------------------------------------------------------------------
+
+    fastify.post('/backups', {preHandler: guard}, async (request, reply) => {
+        const {slugs} = request.body || {};
+
+        const allCollections = await listCollections();
+        const targets = slugs
+            ? allCollections.filter(col => slugs.includes(col.slug))
+            : allCollections;
+
+        const timestamp = new Date().toISOString();
+        const backupId = toBackupId(timestamp);
+        const backupDir = path.join(BACKUPS_DIR, backupId);
+        await fs.mkdir(backupDir, {recursive: true});
+
+        const manifestCollections = [];
+
+        for (const col of targets) {
+            try {
+                const schema = await getCollection(col.slug);
+                const adapter = await getAdapter(col.slug);
+                const entries = await adapter.all(col.slug);
+
+                await fs.writeFile(
+                    path.join(backupDir, `${col.slug}.json`),
+                    JSON.stringify({schema, entries}, null, 2)
+                );
+
+                manifestCollections.push({
+                    slug: col.slug,
+                    title: col.title,
+                    entryCount: entries.length,
+                    adapter: schema?.storage?.adapter || 'file'
+                });
+            } catch (err) {
+                fastify.log.warn(`[data-transfer] Backup skipped "${col.slug}": ${err.message}`);
+            }
+        }
+
+        const manifest = {
+            id: backupId,
+            timestamp,
+            collections: manifestCollections,
+            totalEntries: manifestCollections.reduce((sum, c) => sum + c.entryCount, 0)
+        };
+
+        await fs.writeFile(
+            path.join(backupDir, 'manifest.json'),
+            JSON.stringify(manifest, null, 2)
+        );
+
+        // Prune old backups
+        await pruneBackups(options.settings.maxBackups ?? 50);
+
+        return reply.status(201).send(manifest);
+    });
+
+    // -------------------------------------------------------------------------
+    // GET /backups — list all backups
+    // -------------------------------------------------------------------------
+
+    fastify.get('/backups', {preHandler: guard}, async (_request, reply) => {
+        const entries = await fs.readdir(BACKUPS_DIR).catch(() => []);
+        const backups = [];
+
+        for (const id of entries.sort().reverse()) {
+            try {
+                const manifest = await readManifest(id);
+                backups.push(manifest);
+            } catch {
+                // Corrupt backup directory — skip
+            }
+        }
+
+        return {backups};
+    });
+
+    // -------------------------------------------------------------------------
+    // GET /backups/:id — get single backup manifest
+    // -------------------------------------------------------------------------
+
+    fastify.get('/backups/:id', {preHandler: guard}, async (request, reply) => {
+        try {
+            const manifest = await readManifest(request.params.id);
+            return manifest;
+        } catch {
+            return reply.status(404).send({error: 'Backup not found'});
+        }
+    });
+
+    // -------------------------------------------------------------------------
+    // POST /backups/:id/restore — restore collections from a backup
+    // -------------------------------------------------------------------------
+
+    fastify.post('/backups/:id/restore', {preHandler: guard}, async (request, reply) => {
+        const {mode = 'merge', slugs} = request.body || {};
+
+        if (mode !== 'replace' && mode !== 'merge') {
+            return reply.status(400).send({error: 'mode must be "replace" or "merge"'});
+        }
+
+        let manifest;
+        try {
+            manifest = await readManifest(request.params.id);
+        } catch {
+            return reply.status(404).send({error: 'Backup not found'});
+        }
+
+        const targets = slugs
+            ? manifest.collections.filter(c => slugs.includes(c.slug))
+            : manifest.collections;
+
+        const results = [];
+
+        for (const entry of targets) {
+            try {
+                const backupFile = path.join(BACKUPS_DIR, request.params.id, `${entry.slug}.json`);
+                const raw = await fs.readFile(backupFile, 'utf8');
+                const {schema, entries} = JSON.parse(raw);
+
+                // Recreate collection if it no longer exists
+                const existing = await getCollection(entry.slug);
+                if (!existing) {
+                    const {slug: _s, createdAt: _c, updatedAt: _u, preset: _p, ...rest} = schema;
+                    await createCollection({...rest, slug: entry.slug});
+                }
+
+                const adapter = await getAdapter(entry.slug);
+
+                if (mode === 'replace') {
+                    await adapter.clear(entry.slug);
+                }
+
+                if (entries.length > 0) {
+                    await adapter.insertMany(entry.slug, entries);
+                }
+
+                results.push({slug: entry.slug, status: 'ok', restored: entries.length});
+            } catch (err) {
+                fastify.log.error(`[data-transfer] Restore failed for "${entry.slug}": ${err.message}`);
+                results.push({slug: entry.slug, status: 'error', error: err.message});
+            }
+        }
+
+        return {results};
+    });
+
+    // -------------------------------------------------------------------------
+    // DELETE /backups/:id — delete a backup
+    // -------------------------------------------------------------------------
+
+    fastify.delete('/backups/:id', {preHandler: guard}, async (request, reply) => {
+        const backupDir = path.join(BACKUPS_DIR, request.params.id);
+        try {
+            await fs.access(backupDir);
+        } catch {
+            return reply.status(404).send({error: 'Backup not found'});
+        }
+
+        await fs.rm(backupDir, {recursive: true, force: true});
+        return {ok: true};
+    });
+
+    // -------------------------------------------------------------------------
+    // POST /clone — clone a collection
+    // -------------------------------------------------------------------------
+
+    fastify.post('/clone', {preHandler: guard}, async (request, reply) => {
+        const {sourceSlug, newTitle, newSlug, copyEntries = false} = request.body || {};
+
+        if (!sourceSlug || !newTitle) {
+            return reply.status(400).send({error: 'sourceSlug and newTitle are required'});
+        }
+
+        const source = await getCollection(sourceSlug);
+        if (!source) {
+            return reply.status(404).send({error: 'Source collection not found'});
+        }
+
+        const targetSlug = newSlug || newTitle.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        const existing = await getCollection(targetSlug);
+        if (existing) {
+            return reply.status(409).send({error: `Collection "${targetSlug}" already exists`});
+        }
+
+        // Build clean schema for new collection (drop system fields)
+        const {slug: _s, createdAt: _c, updatedAt: _u, preset: _p, ...rest} = source;
+        await createCollection({...rest, title: newTitle, slug: targetSlug});
+
+        let copiedCount = 0;
+        if (copyEntries) {
+            const sourceAdapter = await getAdapter(sourceSlug);
+            const entries = await sourceAdapter.all(sourceSlug);
+
+            // Generate new UUIDs to avoid ID conflicts across collections
+            const remapped = entries.map(e => ({...e, id: randomUUID()}));
+            const targetAdapter = await getAdapter(targetSlug);
+            if (remapped.length > 0) {
+                await targetAdapter.insertMany(targetSlug, remapped);
+            }
+            copiedCount = remapped.length;
+        }
+
+        return reply.status(201).send({slug: targetSlug, copiedEntries: copiedCount});
+    });
+}

package/plugins/data-transfer/plugin.json

@@ -0,0 +1,33 @@
+{
+  "name": "data-transfer",
+  "displayName": "Data Transfer",
+  "version": "1.0.0",
+  "description": "Bulk transfer, backup, restore, and clone collections between file and MongoDB storage.",
+  "author": "Darryl Waterhouse",
+  "date": "2026-03-28",
+  "icon": "hard-drive",
+  "admin": {
+    "sidebar": [
+      {
+        "id": "data-transfer",
+        "text": "Data Transfer",
+        "icon": "hard-drive",
+        "url": "#/plugins/data-transfer",
+        "section": "#/plugins/data-transfer"
+      }
+    ],
+    "routes": [
+      {
+        "path": "/plugins/data-transfer",
+        "view": "plugin-data-transfer",
+        "title": "Data Transfer - Domma CMS"
+      }
+    ],
+    "views": {
+      "plugin-data-transfer": {
+        "entry": "data-transfer/admin/views/data-transfer.js?v=4",
+        "exportName": "dataTransferView"
+      }
+    }
+  }
+}

package/plugins/garage/admin/templates/garage.html

@@ -0,0 +1,81 @@
+<div class="garage-plugin">
+
+    <!-- Lookup Card -->
+    <div class="card mb-4">
+        <div class="card-header" style="display:flex;align-items:center;gap:0.5rem;">
+            <span data-icon="truck"></span>
+            <strong>Vehicle Lookup</strong>
+        </div>
+        <div class="card-body">
+            <div style="display:flex;gap:0.75rem;align-items:center;flex-wrap:wrap;">
+                <input
+                        id="reg-input"
+                        type="text"
+                        class="form-input"
+                        placeholder="AB12 CDE"
+                        maxlength="8"
+                        autocomplete="off"
+                        spellcheck="false"
+                        style="width:160px;background:#FFD900;color:#000;font-family:'Arial Black',Arial,sans-serif;font-size:1.25rem;font-weight:900;text-transform:uppercase;text-align:center;letter-spacing:3px;border:3px solid #000;border-radius:6px;padding:0.4rem 0.5rem;"
+                >
+                <button id="lookup-btn" class="btn btn-primary">
+                    <span data-icon="search"></span> Look Up
+                </button>
+                <span id="rate-limit-info" style="font-size:0.8rem;color:var(--dm-text-muted,#888);"></span>
+            </div>
+            <div id="lookup-error" style="display:none;margin-top:0.75rem;" class="text-danger"></div>
+        </div>
+    </div>
+
+    <!-- Tabs -->
+    <div id="garage-tabs" class="tabs">
+        <div class="tab-list">
+            <button class="tab-item active">Results</button>
+            <button class="tab-item" id="tab-btn-garage">My Garage</button>
+            <button class="tab-item" id="tab-btn-history">History</button>
+        </div>
+        <div class="tab-content">
+
+            <!-- Results Tab -->
+            <div class="tab-panel active" id="tab-results">
+                <div id="vehicle-result" style="display:none;margin-top:1rem;"></div>
+                <div id="result-empty" style="text-align:center;padding:3rem 1rem;color:var(--dm-text-muted,#888);">
+                    <span data-icon="truck"
+                          style="font-size:2.5rem;display:block;margin-bottom:0.75rem;opacity:0.4;"></span>
+                    Enter a registration number above to look up a vehicle.
+                </div>
+            </div>
+
+            <!-- My Garage Tab -->
+            <div class="tab-panel" id="tab-garage">
+                <div style="display:flex;align-items:center;margin:1rem 0 0.75rem;">
+                    <span id="garage-count" style="font-size:0.8rem;color:var(--dm-text-muted,#888);"></span>
+                </div>
+                <div id="garage-table" style="border-radius:8px;overflow:hidden;"></div>
+                <div id="garage-empty"
+                     style="display:none;text-align:center;padding:3rem 1rem;color:var(--dm-text-muted,#888);">
+                    <span data-icon="truck"
+                          style="font-size:2.5rem;display:block;margin-bottom:0.75rem;opacity:0.4;"></span>
+                    No saved vehicles yet. Look up a vehicle and save it to your garage.
+                </div>
+            </div>
+
+            <!-- History Tab -->
+            <div class="tab-panel" id="tab-history">
+                <div style="display:flex;gap:0.5rem;align-items:center;margin:1rem 0 0.75rem;flex-wrap:wrap;">
+                    <span id="history-count" style="font-size:0.8rem;color:var(--dm-text-muted,#888);flex:1;"></span>
+                    <button id="clear-history-btn" class="btn btn-sm btn-danger">
+                        <span data-icon="trash"></span> Clear History
+                    </button>
+                </div>
+                <div id="history-table" style="border-radius:8px;overflow:hidden;"></div>
+                <div id="history-empty"
+                     style="display:none;text-align:center;padding:3rem 1rem;color:var(--dm-text-muted,#888);">
+                    No lookup history yet.
+                </div>
+            </div>
+
+        </div>
+    </div>
+
+</div>