domma-cms 0.7.8 → 0.7.9

package/config/plugins.json

@@ -33,8 +33,4 @@
     "enabled": true,
     "settings": {}
   },
-  "data-transfer": {
-    "enabled": true,
-    "settings": {}
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/plugins/data-transfer/admin/templates/data-transfer.html

@@ -1,172 +0,0 @@
-<div class="data-transfer-plugin">
-
-    <div class="mb-4" style="display:flex;align-items:center;gap:0.75rem;">
-        <span data-icon="hard-drive" style="width:28px;height:28px;opacity:0.8;"></span>
-        <div>
-            <h1 style="font-size:1.25rem;font-weight:600;margin:0;">Data Transfer</h1>
-            <p style="font-size:0.875rem;color:var(--dm-text-muted);margin:0;">Bulk transfer, backup, restore, and clone
-                collections.</p>
-        </div>
-    </div>
-
-    <div id="dt-tabs" class="tabs">
-        <div class="tab-list" role="tablist">
-            <button class="tab-item active" data-tab="transfer">Transfer</button>
-            <button class="tab-item" data-tab="backups">Backups</button>
-            <button class="tab-item" data-tab="clone">Clone</button>
-        </div>
-
-        <div class="tab-content">
-
-            <!-- ===== Transfer ===== -->
-            <div class="tab-panel active" data-panel="transfer">
-                <div class="card mt-4">
-                    <div class="card-header">
-                        <strong>Move Collections Between Storage Adapters</strong>
-                    </div>
-                    <div class="card-body">
-
-                        <div id="dt-mongo-warning" class="card mb-3"
-                             style="display:none;border-left:3px solid var(--dm-warning);">
-                            <div class="card-body"
-                                 style="display:flex;align-items:center;gap:0.5rem;padding:0.65rem 0.875rem;">
-                                <span data-icon="alert-triangle" style="width:16px;height:16px;flex-shrink:0;"></span>
-                                <span style="font-size:0.875rem;">MongoDB is not connected. File &rarr; MongoDB transfers are unavailable.</span>
-                            </div>
-                        </div>
-
-                        <div class="form-group mb-4">
-                            <label class="form-label">Direction</label>
-                            <div style="display:flex;gap:1.5rem;margin-top:0.25rem;">
-                                <label style="display:flex;align-items:center;gap:0.5rem;cursor:pointer;">
-                                    <input type="radio" name="dt-direction" value="file-to-mongo" id="dt-dir-ftm"
-                                           checked class="form-check-input">
-                                    File &rarr; MongoDB
-                                </label>
-                                <label style="display:flex;align-items:center;gap:0.5rem;cursor:pointer;">
-                                    <input type="radio" name="dt-direction" value="mongo-to-file" id="dt-dir-mtf"
-                                           class="form-check-input">
-                                    MongoDB &rarr; File
-                                </label>
-                            </div>
-                        </div>
-
-                        <div id="dt-collections-loading" style="font-size:0.875rem;color:var(--dm-text-muted);">Loading
-                            collections…
-                        </div>
-
-                        <div id="dt-collections-wrap" style="display:none;">
-                            <table class="table mb-3" id="dt-collections-table">
-                                <thead>
-                                <tr>
-                                    <th style="width:36px;">
-                                        <input type="checkbox" id="dt-select-all" class="form-check-input"
-                                               title="Select all">
-                                    </th>
-                                    <th>Collection</th>
-                                    <th>Slug</th>
-                                    <th>Adapter</th>
-                                    <th>Entries</th>
-                                </tr>
-                                </thead>
-                                <tbody id="dt-collections-body"></tbody>
-                            </table>
-
-                            <button class="btn btn-primary" id="dt-transfer-btn">
-                                <span data-icon="arrow-left-right" style="width:14px;height:14px;"></span>
-                                Transfer Selected
-                            </button>
-                        </div>
-
-                        <div id="dt-transfer-results" style="display:none;margin-top:1.5rem;">
-                            <strong style="display:block;margin-bottom:0.5rem;">Results</strong>
-                            <div id="dt-transfer-results-body"></div>
-                        </div>
-
-                    </div>
-                </div>
-            </div>
-
-            <!-- ===== Backups ===== -->
-            <div class="tab-panel" data-panel="backups">
-                <div class="card mt-4">
-                    <div class="card-header" style="display:flex;align-items:center;justify-content:space-between;">
-                        <strong>Backup Snapshots</strong>
-                        <button class="btn btn-primary btn-sm" id="dt-create-backup-btn">
-                            <span data-icon="download" style="width:14px;height:14px;"></span>
-                            Create Backup
-                        </button>
-                    </div>
-                    <div class="card-body">
-                        <div id="dt-backups-loading" style="font-size:0.875rem;color:var(--dm-text-muted);">Loading
-                            backups…
-                        </div>
-                        <div id="dt-backups-wrap" style="display:none;">
-                            <table class="table" id="dt-backups-table">
-                                <thead>
-                                <tr>
-                                    <th>Timestamp</th>
-                                    <th>Collections</th>
-                                    <th>Total Entries</th>
-                                    <th style="width:180px;">Actions</th>
-                                </tr>
-                                </thead>
-                                <tbody id="dt-backups-body"></tbody>
-                            </table>
-                            <p id="dt-backups-empty"
-                               style="display:none;font-size:0.875rem;color:var(--dm-text-muted);">No backups yet.</p>
-                        </div>
-                    </div>
-                </div>
-            </div>
-
-            <!-- ===== Clone ===== -->
-            <div class="tab-panel" data-panel="clone">
-                <div class="card mt-4" style="max-width:520px;">
-                    <div class="card-header">
-                        <strong>Clone a Collection</strong>
-                    </div>
-                    <div class="card-body">
-
-                        <div class="form-group mb-3">
-                            <label class="form-label" for="dt-clone-source">Source Collection</label>
-                            <select class="form-input" id="dt-clone-source">
-                                <option value="">— select —</option>
-                            </select>
-                        </div>
-
-                        <div class="form-group mb-3">
-                            <label class="form-label" for="dt-clone-title">New Title</label>
-                            <input type="text" class="form-input" id="dt-clone-title"
-                                   placeholder="e.g. My Collection Copy">
-                        </div>
-
-                        <div class="form-group mb-3">
-                            <label class="form-label" for="dt-clone-slug">
-                                New Slug
-                                <span style="font-size:0.8rem;color:var(--dm-text-muted);">(auto-generated)</span>
-                            </label>
-                            <input type="text" class="form-input" id="dt-clone-slug"
-                                   placeholder="e.g. my-collection-copy">
-                        </div>
-
-                        <div class="form-group mb-4">
-                            <label style="display:flex;align-items:center;gap:0.5rem;cursor:pointer;">
-                                <input type="checkbox" class="form-check-input" id="dt-clone-entries">
-                                Copy entries (with new IDs)
-                            </label>
-                        </div>
-
-                        <button class="btn btn-primary" id="dt-clone-btn">
-                            <span data-icon="copy" style="width:14px;height:14px;"></span>
-                            Clone Collection
-                        </button>
-
-                    </div>
-                </div>
-            </div>
-
-        </div>
-    </div>
-
-</div>

package/plugins/data-transfer/admin/views/data-transfer.js

@@ -1,558 +0,0 @@
-/**
- * Data Transfer Plugin — Admin View
- *
- * Three tabs: Transfer, Backups, Clone.
- * Uses raw adapter-level API for faithful bulk operations.
- *
- * Pattern: follows garage plugin conventions.
- *   - api()               — fetch wrapper with CMS Bearer token (same as garage)
- *   - registerIcons()     — registers arrow-left-right (not in Domma built-ins)
- *   - loadCollections()   — populates Transfer tab table
- *   - loadBackups()       — populates Backups tab table
- *   - wireClone()         — wires Clone tab form
- */
-
-const BASE = '/api/plugins/data-transfer';
-
-// ---------------------------------------------------------------------------
-// HTTP helper
-// ---------------------------------------------------------------------------
-
-/**
- * Authenticated fetch helper. Mirrors the garage plugin pattern exactly.
- *
- * @param {string} url
- * @param {string} [method]
- * @param {object} [body]
- * @returns {Promise<any>}
- */
-async function api(url, method = 'GET', body) {
-    const opts = {method, headers: {'Authorization': 'Bearer ' + (S.get('auth_token') || '')}};
-    if (body !== undefined) {
-        opts.headers['Content-Type'] = 'application/json';
-        opts.body = JSON.stringify(body);
-    }
-    const res = await fetch(url, opts);
-    if (!res.ok) {
-        const err = await res.json().catch(() => ({error: res.statusText}));
-        throw new Error(err.error || res.statusText);
-    }
-    return res.json();
-}
-
-// ---------------------------------------------------------------------------
-// Icons
-// ---------------------------------------------------------------------------
-
-/**
- * Register the arrow-left-right icon — two outward-pointing arrowheads joined
- * by a horizontal line.  Not in the Domma built-in set so registered here.
- */
-function registerIcons() {
-    try {
-        I.register('arrow-left-right', {
-            viewBox: '0 0 24 24',
-            path: 'M7 16 L3 12 L7 8 M3 12 L21 12 M17 8 L21 12 L17 16',
-            stroke: 'currentColor',
-            fill: 'none',
-            strokeWidth: 2,
-            strokeLinecap: 'round',
-            strokeLinejoin: 'round'
-        });
-    } catch {
-        // Already registered — safe to ignore on re-mount
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Format an ISO backup ID (filesystem-safe) into a readable local datetime.
- *
- * @param {string} id - e.g. "2026-03-28T14-30-00.000Z"
- * @returns {string}
- */
-function formatBackupId(id) {
-    const iso = id.replace(/T(\d{2})-(\d{2})-(\d{2})/, 'T$1:$2:$3');
-    return new Date(iso).toLocaleString();
-}
-
-/**
- * Slugify a title string for the clone slug field.
- *
- * @param {string} title
- * @returns {string}
- */
-function slugify(title) {
-    return title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-}
-
-/**
- * Create a status badge element.
- *
- * @param {'ok'|'error'|'skipped'} status
- * @returns {HTMLElement}
- */
-function createStatusBadge(status) {
-    const map = {ok: 'badge-success', error: 'badge-danger', skipped: 'badge-secondary'};
-    const span = document.createElement('span');
-    span.className = `badge ${map[status] || 'badge-secondary'}`;
-    span.textContent = status;
-    return span;
-}
-
-/**
- * Create a small icon button element.
- *
- * @param {string} label
- * @param {string} iconName
- * @param {string} className
- * @returns {HTMLButtonElement}
- */
-function createIconBtn(label, iconName, className) {
-    const btn = document.createElement('button');
-    btn.className = className;
-    const icon = document.createElement('span');
-    icon.dataset.icon = iconName;
-    icon.style.cssText = 'width:12px;height:12px;';
-    btn.appendChild(icon);
-    if (label) {
-        btn.appendChild(document.createTextNode(` ${label}`));
-    }
-    return btn;
-}
-
-// ---------------------------------------------------------------------------
-// Transfer tab
-// ---------------------------------------------------------------------------
-
-/**
- * Load collections list and populate the transfer table.
- * Disables File→Mongo direction if MongoDB is not connected.
- *
- * @param {object} $container - Domma wrapper
- */
-async function loadCollections($container) {
-    let res;
-    try {
-        res = await api(`${BASE}/collections`);
-    } catch (err) {
-        const loading = $container.find('#dt-collections-loading').get(0);
-        loading.textContent = `Could not load collections: ${err.message}`;
-        loading.style.color = 'var(--dm-danger)';
-        return;
-    }
-
-    $container.find('#dt-collections-loading').hide();
-    $container.find('#dt-collections-wrap').show();
-
-    if (!res.mongoConnected) {
-        $container.find('#dt-mongo-warning').show();
-        $container.find('#dt-dir-ftm').get(0).disabled = true;
-        $container.find('#dt-dir-mtf').get(0).checked = true;
-    }
-
-    const tbody = $container.find('#dt-collections-body').get(0);
-    tbody.innerHTML = '';
-
-    for (const col of res.collections) {
-        const tr = document.createElement('tr');
-
-        const checkTd = document.createElement('td');
-        const check = document.createElement('input');
-        check.type = 'checkbox';
-        check.className = 'dt-col-check form-check-input';
-        check.dataset.slug = col.slug;
-        check.dataset.adapter = col.adapter;
-        checkTd.appendChild(check);
-
-        const titleTd = document.createElement('td');
-        titleTd.textContent = col.title;
-
-        const slugTd = document.createElement('td');
-        const code = document.createElement('code');
-        code.textContent = col.slug;
-        slugTd.appendChild(code);
-
-        const adapterTd = document.createElement('td');
-        const badge = document.createElement('span');
-        badge.className = 'badge badge-secondary';
-        badge.textContent = col.adapter;
-        adapterTd.appendChild(badge);
-
-        const countTd = document.createElement('td');
-        countTd.textContent = col.entryCount;
-
-        tr.appendChild(checkTd);
-        tr.appendChild(titleTd);
-        tr.appendChild(slugTd);
-        tr.appendChild(adapterTd);
-        tr.appendChild(countTd);
-        tbody.appendChild(tr);
-    }
-
-    // Populate clone source dropdown with the same data
-    const cloneSelect = $container.find('#dt-clone-source').get(0);
-    while (cloneSelect.options.length > 1) cloneSelect.remove(1);
-    for (const col of res.collections) {
-        const opt = document.createElement('option');
-        opt.value = col.slug;
-        opt.textContent = `${col.title} (${col.slug})`;
-        cloneSelect.appendChild(opt);
-    }
-
-    I.scan();
-}
-
-/**
- * Wire the select-all checkbox for the transfer table.
- *
- * @param {object} $container
- */
-function wireSelectAll($container) {
-    $container.find('#dt-select-all').get(0).addEventListener('change', function () {
-        const checked = this.checked;
-        $container.find('.dt-col-check').each(function () {
-            this.checked = checked;
-        });
-    });
-}
-
-/**
- * Execute bulk transfer for checked collections.
- *
- * @param {object} $container
- */
-async function executeTransfer($container) {
-    const checked = [];
-    $container.find('.dt-col-check').each(function () {
-        if (this.checked) checked.push(this.dataset.slug);
-    });
-
-    if (checked.length === 0) {
-        E.toast('Select at least one collection.', {type: 'warning'});
-        return;
-    }
-
-    const direction = $container.find('input[name="dt-direction"]:checked').val();
-    const btn = $container.find('#dt-transfer-btn').get(0);
-    btn.disabled = true;
-    btn.textContent = 'Transferring…';
-
-    try {
-        const res = await api(`${BASE}/transfer`, 'POST', {slugs: checked, direction});
-        renderTransferResults($container, res.results);
-        E.toast('Transfer complete.', {type: 'success'});
-        await loadCollections($container);
-    } catch (err) {
-        E.toast(`Transfer failed: ${err.message || 'Unknown error'}`, {type: 'error'});
-    } finally {
-        btn.disabled = false;
-        const icon = document.createElement('span');
-        icon.dataset.icon = 'arrow-left-right';
-        icon.style.cssText = 'width:14px;height:14px;';
-        btn.textContent = ' Transfer Selected';
-        btn.prepend(icon);
-        I.scan();
-    }
-}
-
-/**
- * Render per-collection transfer results below the table.
- *
- * @param {object} $container
- * @param {Array<object>} results
- */
-function renderTransferResults($container, results) {
-    const wrap = $container.find('#dt-transfer-results').get(0);
-    const body = $container.find('#dt-transfer-results-body').get(0);
-
-    body.textContent = '';
-
-    for (const r of results) {
-        const row = document.createElement('div');
-        row.style.cssText = 'display:flex;align-items:center;gap:0.75rem;padding:0.35rem 0;border-bottom:1px solid var(--dm-border);font-size:0.875rem;';
-
-        row.appendChild(createStatusBadge(r.status));
-
-        const slugCode = document.createElement('code');
-        slugCode.textContent = r.slug;
-        row.appendChild(slugCode);
-
-        const detail = document.createElement('span');
-        detail.style.color = 'var(--dm-text-muted)';
-        detail.textContent = r.count !== undefined
-            ? `${r.count} entries`
-            : (r.reason || r.error || '');
-        row.appendChild(detail);
-
-        body.appendChild(row);
-    }
-
-    wrap.style.display = 'block';
-}
-
-// ---------------------------------------------------------------------------
-// Backups tab
-// ---------------------------------------------------------------------------
-
-/**
- * Load and render the backups list.
- *
- * @param {object} $container
- */
-async function loadBackups($container) {
-    $container.find('#dt-backups-loading').show();
-    $container.find('#dt-backups-wrap').hide();
-
-    let res;
-    try {
-        res = await api(`${BASE}/backups`);
-    } catch (err) {
-        const loading = $container.find('#dt-backups-loading').get(0);
-        loading.textContent = `Could not load backups: ${err.message}`;
-        loading.style.color = 'var(--dm-danger)';
-        return;
-    }
-
-    $container.find('#dt-backups-loading').hide();
-    $container.find('#dt-backups-wrap').show();
-
-    const tbody = $container.find('#dt-backups-body').get(0);
-    const empty = $container.find('#dt-backups-empty').get(0);
-    tbody.textContent = '';
-
-    if (res.backups.length === 0) {
-        empty.style.display = '';
-        return;
-    }
-    empty.style.display = 'none';
-
-    for (const backup of res.backups) {
-        const tr = document.createElement('tr');
-        tr.dataset.backupId = backup.id;
-
-        const dateCell = document.createElement('td');
-        dateCell.textContent = formatBackupId(backup.id);
-
-        const colCell = document.createElement('td');
-        colCell.textContent = backup.collections.length;
-
-        const entryCell = document.createElement('td');
-        entryCell.textContent = backup.totalEntries;
-
-        const actionsCell = document.createElement('td');
-
-        const restoreBtn = createIconBtn('Restore', 'upload', 'btn btn-secondary btn-xs mr-1');
-        restoreBtn.addEventListener('click', () => promptRestore($container, backup));
-
-        const deleteBtn = createIconBtn('', 'trash', 'btn btn-danger btn-xs');
-        deleteBtn.addEventListener('click', () => deleteBackup($container, backup.id));
-
-        actionsCell.appendChild(restoreBtn);
-        actionsCell.appendChild(deleteBtn);
-
-        tr.appendChild(dateCell);
-        tr.appendChild(colCell);
-        tr.appendChild(entryCell);
-        tr.appendChild(actionsCell);
-        tbody.appendChild(tr);
-    }
-
-    I.scan();
-}
-
-/**
- * Prompt the user for restore mode then execute.
- *
- * TODO: Implement a richer restore mode selection UI here.
- *
- * The restore API accepts { mode: 'replace' | 'merge', slugs?: string[] }.
- *  - 'replace' clears existing entries before inserting — a clean, full restore.
- *  - 'merge'   appends backup entries alongside existing data — for partial restores.
- *
- * Your task: replace the E.confirm() below with a proper selection UI so the
- * admin can consciously choose between the two modes. Ideas:
- *   a) A modal with two distinct buttons ("Replace" / "Merge") instead of a
- *      single confirm — clearer intent, harder to misclick.
- *   b) A radio group inside an E.modal() followed by a single confirm button,
- *      which also lets you add a collection filter checklist.
- *   c) Two separate "Restore (Replace)" / "Restore (Merge)" action buttons
- *      per row in the backups table.
- *
- * Constraints:
- *   - Use E.confirm() or E.modal() — NOT window.confirm()
- *   - Call executeRestore($container, backup.id, mode) once the user confirms
- *   - mode must be the string 'replace' or 'merge'
- *
- * @param {object} $container
- * @param {object} backup - the backup manifest object
- */
-async function promptRestore($container, backup) {
-    // TODO: Replace with a mode-selection UI (see jsdoc above).
-    const confirmed = await E.confirm(
-        `Restore backup from ${formatBackupId(backup.id)}?\n\nThis uses REPLACE mode — existing entries in each restored collection will be cleared first.`
-    );
-    if (!confirmed) return;
-    await executeRestore($container, backup.id, 'replace');
-}
-
-/**
- * Execute a restore operation.
- *
- * @param {object} $container
- * @param {string} backupId
- * @param {'replace'|'merge'} mode
- * @param {string[]} [slugs] - optional subset of collections to restore
- */
-async function executeRestore($container, backupId, mode, slugs) {
-    try {
-        const body = {mode};
-        if (slugs) body.slugs = slugs;
-        const res = await api(`${BASE}/backups/${backupId}/restore`, 'POST', body);
-        const ok = res.results.filter(r => r.status === 'ok').length;
-        const errs = res.results.filter(r => r.status === 'error').length;
-        E.toast(
-            errs > 0
-                ? `Restored ${ok} collection(s), ${errs} error(s).`
-                : `Restored ${ok} collection(s) successfully.`,
-            {type: errs > 0 ? 'warning' : 'success'}
-        );
-    } catch (err) {
-        E.toast(`Restore failed: ${err.message || 'Unknown error'}`, {type: 'error'});
-    }
-}
-
-/**
- * Delete a backup after confirmation.
- *
- * @param {object} $container
- * @param {string} backupId
- */
-async function deleteBackup($container, backupId) {
-    const confirmed = await E.confirm(
-        `Delete backup from ${formatBackupId(backupId)}? This cannot be undone.`
-    );
-    if (!confirmed) return;
-
-    try {
-        await api(`${BASE}/backups/${backupId}`, 'DELETE');
-        E.toast('Backup deleted.', {type: 'success'});
-        await loadBackups($container);
-    } catch (err) {
-        E.toast(`Delete failed: ${err.message || 'Unknown error'}`, {type: 'error'});
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Clone tab
-// ---------------------------------------------------------------------------
-
-/**
- * Wire the title → slug auto-generation and clone button.
- *
- * @param {object} $container
- */
-function wireClone($container) {
-    const titleInput = $container.find('#dt-clone-title').get(0);
-    const slugInput = $container.find('#dt-clone-slug').get(0);
-    let slugEdited = false;
-
-    titleInput.addEventListener('input', () => {
-        if (!slugEdited) slugInput.value = slugify(titleInput.value);
-    });
-    slugInput.addEventListener('input', () => {
-        slugEdited = !!slugInput.value;
-    });
-
-    $container.find('#dt-clone-btn').on('click', async () => {
-        const sourceSlug = $container.find('#dt-clone-source').val();
-        const newTitle = titleInput.value.trim();
-        const newSlug = slugInput.value.trim() || undefined;
-        const copyEntries = $container.find('#dt-clone-entries').get(0).checked;
-
-        if (!sourceSlug || !newTitle) {
-            E.toast('Choose a source collection and enter a title.', {type: 'warning'});
-            return;
-        }
-
-        const btn = $container.find('#dt-clone-btn').get(0);
-        btn.disabled = true;
-        btn.textContent = 'Cloning…';
-
-        try {
-            const res = await api(`${BASE}/clone`, 'POST', {sourceSlug, newTitle, newSlug, copyEntries});
-            E.toast(
-                copyEntries
-                    ? `Cloned to "${res.slug}" with ${res.copiedEntries} entries.`
-                    : `Cloned to "${res.slug}".`,
-                {type: 'success'}
-            );
-            $container.find('#dt-clone-source').val('');
-            titleInput.value = '';
-            slugInput.value = '';
-            slugEdited = false;
-            $container.find('#dt-clone-entries').get(0).checked = false;
-        } catch (err) {
-            E.toast(`Clone failed: ${err.message || 'Unknown error'}`, {type: 'error'});
-        } finally {
-            btn.disabled = false;
-            const icon = document.createElement('span');
-            icon.dataset.icon = 'copy';
-            icon.style.cssText = 'width:14px;height:14px;';
-            btn.textContent = ' Clone Collection';
-            btn.prepend(icon);
-            I.scan();
-        }
-    });
-}
-
-// ---------------------------------------------------------------------------
-// Mount
-// ---------------------------------------------------------------------------
-
-export const dataTransferView = {
-    templateUrl: '/plugins/data-transfer/admin/templates/data-transfer.html',
-
-    async onMount($container) {
-        registerIcons();
-        E.tabs($container.find('#dt-tabs').get(0));
-
-        // Transfer tab
-        wireSelectAll($container);
-        await loadCollections($container);
-        $container.find('#dt-transfer-btn').on('click', () => executeTransfer($container));
-
-        // Backups tab — pre-fetch and reload on tab switch
-        $container.find('[data-tab="backups"]').on('click', () => loadBackups($container));
-        loadBackups($container);
-
-        $container.find('#dt-create-backup-btn').on('click', async () => {
-            const btn = $container.find('#dt-create-backup-btn').get(0);
-            btn.disabled = true;
-            btn.textContent = 'Creating…';
-            try {
-                await api(`${BASE}/backups`, 'POST', {});
-                E.toast('Backup created.', {type: 'success'});
-                await loadBackups($container);
-            } catch (err) {
-                E.toast(`Backup failed: ${err.message || 'Unknown error'}`, {type: 'error'});
-            } finally {
-                btn.disabled = false;
-                const icon = document.createElement('span');
-                icon.dataset.icon = 'download';
-                icon.style.cssText = 'width:14px;height:14px;';
-                btn.textContent = ' Create Backup';
-                btn.prepend(icon);
-                I.scan();
-            }
-        });
-
-        // Clone tab
-        wireClone($container);
-
-        I.scan();
-    }
-};

package/plugins/data-transfer/config.js

@@ -1,9 +0,0 @@
-/**
- * Data Transfer Plugin — Default Configuration
- *
- * Override any of these via config/plugins.json under "data-transfer.settings".
- */
-export default {
-    /** Maximum number of backups to retain. Oldest are pruned automatically. */
-    maxBackups: 50
-};

package/plugins/data-transfer/plugin.js

@@ -1,424 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-{
-  "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"
-      }
-    }
-  }
-}