domma-cms 0.2.1 → 0.5.0

package/server/services/collections.js

@@ -1,18 +1,21 @@
 /**
  * Collections Service
  * Schema-first data store — one directory per collection under content/collections/{slug}/.
- * Each collection has a schema.json (field definitions + API access config) and a data.json
- * (array of entries with id, data, and meta).
+ * Each collection has a schema.json (field definitions + API access config).
+ *
+ * Entry storage is delegated to the active adapter (FileAdapter or MongoAdapter).
+ * Schema management (schema.json) is always file-based.
  */
 import fs from 'fs/promises';
 import path from 'path';
-import { v4 as uuidv4 } from 'uuid';
-import { config } from '../config.js';
+import {v4 as uuidv4} from 'uuid';
+import {config} from '../config.js';
+import {getAdapter, invalidate} from './adapterRegistry.js';
 
 const COLLECTIONS_DIR = path.resolve(config.content.collectionsDir);
 
 // ---------------------------------------------------------------------------
-// Internal helpers
+// Internal helpers (schema only)
 // ---------------------------------------------------------------------------
 
 async function ensureDir() {
@@ -27,10 +30,6 @@ function schemaPath(slug) {
     return path.join(collectionDir(slug), 'schema.json');
 }
 
-function dataPath(slug) {
-    return path.join(collectionDir(slug), 'data.json');
-}
-
 function slugify(str) {
     return str.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
 }
@@ -44,19 +43,6 @@ async function writeSchema(schema) {
     await fs.writeFile(schemaPath(schema.slug), JSON.stringify(schema, null, 2) + '\n', 'utf8');
 }
 
-async function readData(slug) {
-    try {
-        const raw = await fs.readFile(dataPath(slug), 'utf8');
-        return JSON.parse(raw);
-    } catch {
-        return [];
-    }
-}
-
-async function writeData(slug, entries) {
-    await fs.writeFile(dataPath(slug), JSON.stringify(entries, null, 2) + '\n', 'utf8');
-}
-
 /**
  * Default API access configuration for a new collection.
  *
@@ -72,7 +58,7 @@ function defaultApiAccess() {
 }
 
 // ---------------------------------------------------------------------------
-// Schema (collection) operations
+// Schema (collection) operations — always file-based
 // ---------------------------------------------------------------------------
 
 /**
@@ -91,9 +77,10 @@ export async function listCollections() {
     }
 
     const results = await Promise.allSettled(slugs.map(async (slug) => {
-        const schema = await readSchema(slug);
-        const data   = await readData(slug);
-        return { ...schema, entryCount: data.length };
+        const schema     = await readSchema(slug);
+        const adapter    = await getAdapter(slug);
+        const entryCount = await adapter.count(slug);
+        return { ...schema, entryCount };
     }));
 
     return results
@@ -128,7 +115,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 = {} }) {
+export async function createCollection({title, slug, description = '', fields = [], api = {}, storage}) {
     await ensureDir();
     const finalSlug = slug ? slugify(slug) : slugify(title);
     if (!finalSlug) throw new Error('Could not derive a slug from the title');
@@ -148,12 +135,13 @@ export async function createCollection({ title, slug, description = '', fields =
         description: description.trim(),
         fields,
         api: { ...defaultApiAccess(), ...api },
+        storage: storage || {adapter: 'file'},
         createdAt: now,
         updatedAt: now
     };
 
     await writeSchema(schema);
-    await writeData(finalSlug, []);
+    await (await getAdapter(finalSlug)).insertMany(finalSlug, []);
     return schema;
 }
 
@@ -179,6 +167,10 @@ export async function updateCollection(slug, updates) {
     };
 
     await writeSchema(updated);
+
+    // Invalidate cached adapter in case storage config changed.
+    invalidate(slug);
+
     return updated;
 }
 
@@ -192,11 +184,23 @@ export async function updateCollection(slug, updates) {
 export async function deleteCollection(slug) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
+
+    // Clear adapter data first (handles MongoDB collections on non-file adapters).
+    try {
+        const adapter = await getAdapter(slug);
+        if (adapter.constructor.name !== 'FileAdapter') {
+            await adapter.clear(slug);
+        }
+    } catch {
+        // Ignore errors — directory removal handles file-backed data.
+    }
+
+    invalidate(slug);
     await fs.rm(collectionDir(slug), { recursive: true, force: true });
 }
 
 // ---------------------------------------------------------------------------
-// Entry operations
+// Validation
 // ---------------------------------------------------------------------------
 
 /**
@@ -218,6 +222,10 @@ export function validateEntryData(schema, data) {
     return { valid: errors.length === 0, errors };
 }
 
+// ---------------------------------------------------------------------------
+// Entry operations — delegated to storage adapter
+// ---------------------------------------------------------------------------
+
 /**
  * List entries with optional pagination, sorting, and search.
  *
@@ -230,29 +238,11 @@ export function validateEntryData(schema, data) {
  * @param {string}  [opts.search]
  * @returns {Promise<{ entries: object[], total: number, page: number, limit: number }>}
  */
-export async function listEntries(slug, { page = 1, limit = 50, sort = 'createdAt', order = 'desc', search } = {}) {
+export async function listEntries(slug, opts = {}) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
-
-    let entries = await readData(slug);
-
-    if (search) {
-        const term = search.toLowerCase();
-        entries = entries.filter(entry => {
-            return Object.values(entry.data || {}).some(v => String(v).toLowerCase().includes(term));
-        });
-    }
-
-    entries.sort((a, b) => {
-        const aVal = sort === 'createdAt' ? a.meta?.createdAt : (a.data?.[sort] ?? '');
-        const bVal = sort === 'createdAt' ? b.meta?.createdAt : (b.data?.[sort] ?? '');
-        const cmp  = String(aVal).localeCompare(String(bVal));
-        return order === 'desc' ? -cmp : cmp;
-    });
-
-    const total  = entries.length;
-    const offset = (page - 1) * limit;
-    return { entries: entries.slice(offset, offset + limit), total, page, limit };
+    const adapter = await getAdapter(slug);
+    return adapter.list(slug, opts);
 }
 
 /**
@@ -263,8 +253,8 @@ export async function listEntries(slug, { page = 1, limit = 50, sort = 'createdA
  * @returns {Promise<object|null>}
  */
 export async function getEntry(slug, entryId) {
-    const entries = await readData(slug);
-    return entries.find(e => e.id === entryId) || null;
+    const adapter = await getAdapter(slug);
+    return adapter.get(slug, entryId);
 }
 
 /**
@@ -285,17 +275,15 @@ export async function createEntry(slug, data, { createdBy = null, source = 'admi
     const { valid, errors } = validateEntryData(schema, data);
     if (!valid) throw new Error(`Validation failed: ${errors.join('; ')}`);
 
-    const now = new Date().toISOString();
+    const now   = new Date().toISOString();
     const entry = {
-        id: uuidv4(),
+        id:   uuidv4(),
         data,
         meta: { createdAt: now, updatedAt: now, createdBy, source }
     };
 
-    const entries = await readData(slug);
-    entries.push(entry);
-    await writeData(slug, entries);
-    return entry;
+    const adapter = await getAdapter(slug);
+    return adapter.insert(slug, entry);
 }
 
 /**
@@ -311,21 +299,20 @@ export async function updateEntry(slug, entryId, data) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
 
-    const entries = await readData(slug);
-    const idx     = entries.findIndex(e => e.id === entryId);
-    if (idx === -1) throw new Error('Entry not found');
-
     const { valid, errors } = validateEntryData(schema, data);
     if (!valid) throw new Error(`Validation failed: ${errors.join('; ')}`);
 
-    entries[idx] = {
-        ...entries[idx],
+    const adapter  = await getAdapter(slug);
+    const existing = await adapter.get(slug, entryId);
+    if (!existing) throw new Error('Entry not found');
+
+    const updated = {
+        ...existing,
         data,
-        meta: { ...entries[idx].meta, updatedAt: new Date().toISOString() }
+        meta: { ...existing.meta, updatedAt: new Date().toISOString() }
     };
 
-    await writeData(slug, entries);
-    return entries[idx];
+    return adapter.update(slug, entryId, updated);
 }
 
 /**
@@ -337,11 +324,8 @@ export async function updateEntry(slug, entryId, data) {
  * @throws {Error} If entry not found
  */
 export async function deleteEntry(slug, entryId) {
-    const entries = await readData(slug);
-    const idx     = entries.findIndex(e => e.id === entryId);
-    if (idx === -1) throw new Error('Entry not found');
-    entries.splice(idx, 1);
-    await writeData(slug, entries);
+    const adapter = await getAdapter(slug);
+    return adapter.remove(slug, entryId);
 }
 
 /**
@@ -353,7 +337,8 @@ export async function deleteEntry(slug, entryId) {
 export async function clearEntries(slug) {
     const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
-    await writeData(slug, []);
+    const adapter = await getAdapter(slug);
+    return adapter.clear(slug);
 }
 
 // ---------------------------------------------------------------------------
@@ -368,9 +353,11 @@ export async function clearEntries(slug) {
  * @returns {Promise<string>}
  */
 export async function exportEntries(slug, format = 'json') {
-    const schema  = await getCollection(slug);
+    const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
-    const entries = await readData(slug);
+
+    const adapter = await getAdapter(slug);
+    const entries = await adapter.all(slug);
 
     if (format === 'csv') {
         const fields = schema.fields.map(f => f.name);
@@ -399,32 +386,33 @@ export async function exportEntries(slug, format = 'json') {
  * @returns {Promise<{ imported: number, skipped: number, errors: string[] }>}
  */
 export async function importEntries(slug, incoming, { createdBy = null } = {}) {
-    const schema  = await getCollection(slug);
+    const schema = await getCollection(slug);
     if (!schema) throw new Error(`Collection "${slug}" not found`);
 
-    const existing = await readData(slug);
-    const now = new Date().toISOString();
-
-    let imported = 0;
+    const now    = new Date().toISOString();
     let skipped  = 0;
     const errors = [];
+    const valid  = [];
 
     for (const item of incoming) {
         const data = item.data || item;
-        const { valid, errors: valErrors } = validateEntryData(schema, data);
-        if (!valid) {
+        const { valid: ok, errors: valErrors } = validateEntryData(schema, data);
+        if (!ok) {
             skipped++;
             errors.push(valErrors.join('; '));
             continue;
         }
-        existing.push({
+        valid.push({
             id:   uuidv4(),
             data,
             meta: { createdAt: now, updatedAt: now, createdBy, source: 'import' }
         });
-        imported++;
     }
 
-    await writeData(slug, existing);
-    return { imported, skipped, errors };
+    const adapter = await getAdapter(slug);
+    if (valid.length > 0) {
+        await adapter.insertMany(slug, valid);
+    }
+
+    return { imported: valid.length, skipped, errors };
 }

package/server/services/connectionManager.js

@@ -0,0 +1,102 @@
+/**
+ * Connection Manager (Pro feature)
+ *
+ * Manages MongoDB client lifecycle for named database connections.
+ * Loaded dynamically via import() — never required in the free version.
+ *
+ * Usage:
+ *   await initialise(connectionsConfig)   // on server startup
+ *   const db = getDb('default')           // in adapters
+ *   await shutdown()                      // on server close
+ */
+
+/** @type {Map<string, { client: import('mongodb').MongoClient, db: import('mongodb').Db }>} */
+const clients = new Map();
+
+/**
+ * Initialise all named MongoDB connections from config.
+ * Connects lazily — each client is created but connect() is deferred to first use.
+ *
+ * @param {Record<string, { type: string, uri: string, database: string, options?: object }>} connectionsConfig
+ * @returns {Promise<void>}
+ */
+export async function initialise(connectionsConfig) {
+    // Dynamic import — mongodb package is optional and not loaded in the free version.
+    const { MongoClient } = await import('mongodb');
+
+    for (const [name, cfg] of Object.entries(connectionsConfig)) {
+        if (cfg.type !== 'mongodb') {
+            console.warn(`[connectionManager] Skipping connection "${name}": unsupported type "${cfg.type}"`);
+            continue;
+        }
+
+        if (!cfg.uri || !cfg.database) {
+            console.warn(`[connectionManager] Skipping connection "${name}": missing uri or database`);
+            continue;
+        }
+
+        try {
+            const client = new MongoClient(cfg.uri, cfg.options || {});
+            await client.connect();
+            const db = client.db(cfg.database);
+            clients.set(name, { client, db });
+            console.log(`[connectionManager] Connected: ${name} → ${cfg.database}`);
+        } catch (err) {
+            console.error(`[connectionManager] Failed to connect "${name}": ${err.message}`);
+            // Don't throw — allow server to start with degraded MongoDB support.
+        }
+    }
+}
+
+/**
+ * Get the MongoClient for a named connection.
+ *
+ * @param {string} name
+ * @returns {import('mongodb').MongoClient}
+ * @throws {Error} If the connection is unknown or failed to connect
+ */
+export function getClient(name) {
+    const conn = clients.get(name);
+    if (!conn) throw new Error(`[connectionManager] Unknown connection: "${name}". Is it configured in config/connections.json?`);
+    return conn.client;
+}
+
+/**
+ * Get the Db instance for a named connection.
+ *
+ * @param {string} name
+ * @returns {import('mongodb').Db}
+ * @throws {Error} If the connection is unknown or failed to connect
+ */
+export function getDb(name) {
+    const conn = clients.get(name);
+    if (!conn) throw new Error(`[connectionManager] Unknown connection: "${name}". Is it configured in config/connections.json?`);
+    return conn.db;
+}
+
+/**
+ * Check whether a named connection is active.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isConnected(name) {
+    return clients.has(name);
+}
+
+/**
+ * Close all active MongoDB connections gracefully.
+ * Called by the Fastify onClose hook.
+ *
+ * @returns {Promise<void>}
+ */
+export async function shutdown() {
+    const closePromises = [];
+    for (const [name, { client }] of clients) {
+        closePromises.push(
+            client.close().then(() => console.log(`[connectionManager] Closed: ${name}`))
+        );
+    }
+    await Promise.allSettled(closePromises);
+    clients.clear();
+}