domma-cms 0.1.0

package/server/services/content.js

@@ -0,0 +1,298 @@
+/**
+ * Content Service
+ * File-based CRUD for pages and media.
+ * Pages live in content/pages/ mirroring URL structure.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import {parseMarkdown, serialiseMarkdown} from './markdown.js';
+import {config} from '../config.js';
+
+const CONTENT_DIR = config.content.contentDir;
+const PAGES_DIR = path.join(CONTENT_DIR, 'pages');
+const MEDIA_DIR = config.content.mediaDir;
+
+// ---------------------------------------------------------------------------
+// Pages
+// ---------------------------------------------------------------------------
+
+/**
+ * Recursively list all .md files under PAGES_DIR.
+ * Returns parsed page objects sorted by sortOrder then title.
+ *
+ * @returns {Promise<object[]>}
+ */
+export async function listPages() {
+    const files = await collectMdFiles(PAGES_DIR);
+    const pages = await Promise.all(files.map(filePath => readPageFile(filePath)));
+    return pages.sort((a, b) => (a.sortOrder ?? 99) - (b.sortOrder ?? 99) || a.title.localeCompare(b.title));
+}
+
+/**
+ * Get a single page by its URL path (e.g. '/about' or '/services/web-dev').
+ * The empty string / '/' resolves to index.md.
+ *
+ * @param {string} urlPath
+ * @returns {Promise<object|null>}
+ */
+export async function getPage(urlPath) {
+    const filePath = await resolveExistingFilePath(urlPath);
+    try {
+        return await readPageFile(filePath);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Create a new page. Auto-creates parent directories.
+ *
+ * @param {string} urlPath
+ * @param {object} frontmatter
+ * @param {string} body
+ * @returns {Promise<object>}
+ */
+export async function createPage(urlPath, frontmatter, body) {
+    const filePath = urlPathToFilePath(urlPath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+    const defaults = config.content.pageDefaults;
+    const now = new Date().toISOString();
+    const meta = {
+        title: frontmatter.title || 'Untitled',
+        slug: slugFromPath(urlPath),
+        description: frontmatter.description || '',
+        layout: frontmatter.layout || defaults.layout,
+        status: frontmatter.status || defaults.status,
+        sortOrder: frontmatter.sortOrder ?? defaults.sortOrder,
+        showInNav: frontmatter.showInNav ?? false,
+        sidebar: frontmatter.sidebar ?? false,
+        seo: frontmatter.seo || {},
+        createdAt: now,
+        updatedAt: now
+    };
+
+    await fs.writeFile(filePath, serialiseMarkdown(meta, body || ''), 'utf8');
+    return readPageFile(filePath);
+}
+
+/**
+ * Update an existing page.
+ *
+ * @param {string} urlPath
+ * @param {object} frontmatter
+ * @param {string} body
+ * @returns {Promise<object>}
+ */
+export async function updatePage(urlPath, frontmatter, body) {
+    const filePath = await resolveExistingFilePath(urlPath);
+    const existing = await readPageFile(filePath);
+    const { urlPath: _u, content: existingContent, html: _h, ...existingMeta } = existing;
+
+    const meta = {
+        ...existingMeta,
+        ...frontmatter,
+        updatedAt: new Date().toISOString()
+    };
+
+    if (existingMeta.createdAt) meta.createdAt = existingMeta.createdAt;
+
+    await fs.writeFile(filePath, serialiseMarkdown(meta, body ?? existingContent), 'utf8');
+    return readPageFile(filePath);
+}
+
+/**
+ * Rename (move) a page to a new URL path.
+ * Creates any required parent directories for the destination.
+ *
+ * @param {string} oldUrlPath
+ * @param {string} newUrlPath
+ * @returns {Promise<void>}
+ */
+export async function renamePage(oldUrlPath, newUrlPath) {
+    const oldFile = await resolveExistingFilePath(oldUrlPath);
+    const newFile = urlPathToFilePath(newUrlPath);
+    await fs.mkdir(path.dirname(newFile), { recursive: true });
+    await fs.rename(oldFile, newFile);
+}
+
+/**
+ * Delete a page file.
+ *
+ * @param {string} urlPath
+ * @returns {Promise<void>}
+ */
+export async function deletePage(urlPath) {
+    const filePath = await resolveExistingFilePath(urlPath);
+    await fs.unlink(filePath);
+}
+
+// ---------------------------------------------------------------------------
+// Media
+// ---------------------------------------------------------------------------
+
+/**
+ * List all files in the media directory.
+ *
+ * @returns {Promise<object[]>}
+ */
+export async function listMedia() {
+    await fs.mkdir(MEDIA_DIR, { recursive: true });
+    const files = await fs.readdir(MEDIA_DIR);
+    const stats = await Promise.all(
+        files.map(async (file) => {
+            const filePath = path.join(MEDIA_DIR, file);
+            const stat = await fs.stat(filePath);
+            return {
+                name: file,
+                url: `/media/${file}`,
+                size: stat.size,
+                createdAt: stat.birthtime.toISOString()
+            };
+        })
+    );
+    return stats.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+/**
+ * Save an uploaded file to the media directory.
+ *
+ * @param {string} filename
+ * @param {Buffer} buffer
+ * @returns {Promise<object>}
+ */
+export async function saveMedia(filename, buffer) {
+    await fs.mkdir(MEDIA_DIR, { recursive: true });
+    const filePath = path.join(MEDIA_DIR, filename);
+    await fs.writeFile(filePath, buffer);
+    return { name: filename, url: `/media/${filename}` };
+}
+
+/**
+ * Delete a media file.
+ *
+ * @param {string} filename
+ * @returns {Promise<void>}
+ */
+export async function deleteMedia(filename) {
+    const filePath = path.join(MEDIA_DIR, filename);
+    await fs.unlink(filePath);
+}
+
+/**
+ * Rename a media file.
+ *
+ * @param {string} oldName - Current filename
+ * @param {string} newName - Desired filename
+ * @returns {Promise<{ name: string, url: string }>}
+ * @throws {Error} If the destination already exists
+ */
+export async function renameMedia(oldName, newName) {
+  const srcPath = path.join(MEDIA_DIR, oldName);
+  const destPath = path.join(MEDIA_DIR, newName);
+
+  try {
+    await fs.access(destPath);
+    throw new Error(`A file named "${newName}" already exists.`);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  await fs.rename(srcPath, destPath);
+  return {name: newName, url: `/media/${newName}`};
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the actual file path for an existing page.
+ * Tries the direct file first (e.g. about.md), then the directory index (e.g. blog/index.md).
+ *
+ * @param {string} urlPath
+ * @returns {Promise<string>}
+ */
+async function resolveExistingFilePath(urlPath) {
+    const directFile = urlPathToFilePath(urlPath);
+    try {
+        await fs.access(directFile);
+        return directFile;
+    } catch {
+        const normalised = urlPath === '/' || !urlPath ? 'index' : urlPath.replace(/^\//, '').replace(/\/$/, '');
+        return path.join(PAGES_DIR, normalised, 'index.md');
+    }
+}
+
+/**
+ * Recursively collect all .md file paths under a directory.
+ *
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+async function collectMdFiles(dir) {
+    let results = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results = results.concat(await collectMdFiles(full));
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+
+/**
+ * Read and parse a single .md file, injecting the derived urlPath.
+ *
+ * @param {string} filePath
+ * @returns {Promise<object>}
+ */
+async function readPageFile(filePath) {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const { data, content, html } = parseMarkdown(raw);
+    const urlPath = filePathToUrlPath(filePath);
+    return { ...data, urlPath, content, html };
+}
+
+/**
+ * Derive the URL path from a file path.
+ * e.g. content/pages/services/web-dev.md → /services/web-dev
+ *      content/pages/index.md            → /
+ *      content/pages/services/index.md   → /services
+ */
+function filePathToUrlPath(filePath) {
+    const relative = path.relative(PAGES_DIR, filePath);
+    const withoutExt = relative.replace(/\.md$/, '');
+    if (withoutExt === 'index') return '/';
+    const parts = withoutExt.split(path.sep);
+    if (parts[parts.length - 1] === 'index') parts.pop();
+    return '/' + parts.join('/');
+}
+
+/**
+ * Derive the file path from a URL path.
+ * e.g. /             → content/pages/index.md
+ *      /about        → content/pages/about.md
+ *      /services     → content/pages/services/index.md (checked second)
+ */
+function urlPathToFilePath(urlPath) {
+    const normalised = urlPath === '/' || !urlPath ? 'index' : urlPath.replace(/^\//, '').replace(/\/$/, '');
+    return path.join(PAGES_DIR, normalised + '.md');
+}
+
+/**
+ * Extract a slug from a URL path.
+ */
+function slugFromPath(urlPath) {
+    if (urlPath === '/' || !urlPath) return 'index';
+    const parts = urlPath.split('/').filter(Boolean);
+    return parts[parts.length - 1] || 'index';
+}

package/server/services/images.js

@@ -0,0 +1,334 @@
+/**
+ * Image Service
+ * Sharp-based image processing for the media library.
+ * Supports crop, resize, rotate, flip, colour presets, adjustments,
+ * watermark compositing, border/padding, and format conversion.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import sharp from 'sharp';
+import {config} from '../config.js';
+
+const MEDIA_DIR = config.content.mediaDir;
+
+const EDITABLE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp', '.gif', '.tiff']);
+
+/**
+ * Check whether a filename is an editable image type.
+ *
+ * @param {string} filename
+ * @returns {boolean}
+ */
+export function isEditableImage(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return EDITABLE_EXTENSIONS.has(ext);
+}
+
+/**
+ * Get image dimensions and format from a media file.
+ *
+ * @param {string} filename
+ * @returns {Promise<{ width: number, height: number, format: string }>}
+ * @throws {Error} If file not found or unreadable
+ */
+export async function getImageInfo(filename) {
+  const filePath = path.join(MEDIA_DIR, filename);
+  const {width, height, format} = await sharp(filePath).metadata();
+  return {width, height, format};
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline helpers (private)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a hex colour string into an {r,g,b} object.
+ *
+ * @param {string} hex  e.g. '#ff0000' or 'ff0000'
+ * @returns {{ r: number, g: number, b: number }}
+ */
+function parseHexColour(hex) {
+  const clean = hex.replace('#', '');
+  return {
+    r: parseInt(clean.slice(0, 2), 16),
+    g: parseInt(clean.slice(2, 4), 16),
+    b: parseInt(clean.slice(4, 6), 16),
+  };
+}
+
+/**
+ * Apply a named colour preset to the pipeline.
+ * 'sharpen' and 'soften' are skipped when the matching adjustment is set,
+ * avoiding a double-application.
+ *
+ * @param {import('sharp').Sharp} pipeline
+ * @param {string} preset
+ * @param {object} [adjustments]
+ * @returns {import('sharp').Sharp}
+ */
+function applyPreset(pipeline, preset, adjustments = {}) {
+  switch (preset) {
+    case 'grayscale':
+      return pipeline.greyscale();
+    case 'sepia':
+      return pipeline.greyscale().tint({r: 112, g: 66, b: 20});
+    case 'warm':
+      return pipeline.modulate({hue: 30}).tint({r: 255, g: 220, b: 180});
+    case 'cool':
+      return pipeline.modulate({hue: 210}).tint({r: 180, g: 210, b: 255});
+    case 'enhance':
+      return pipeline.normalise();
+    case 'sharpen':
+      return adjustments.sharpen > 0 ? pipeline : pipeline.sharpen({sigma: 2});
+    case 'soften':
+      return adjustments.blur > 0 ? pipeline : pipeline.blur(2);
+    case 'invert':
+      return pipeline.negate();
+    default:
+      return pipeline;
+  }
+}
+
+/**
+ * Apply numeric adjustment sliders to the pipeline.
+ * Only values that differ from defaults trigger Sharp calls.
+ *
+ * @param {import('sharp').Sharp} pipeline
+ * @param {object} adj
+ * @param {number} [adj.brightness]  1.0 = no change
+ * @param {number} [adj.saturation]  1.0 = no change
+ * @param {number} [adj.contrast]    1.0 = no change
+ * @param {number} [adj.blur]        sigma (> 0.3 to apply)
+ * @param {number} [adj.sharpen]     sigma
+ * @param {number} [adj.gamma]       1.0 = no change
+ * @returns {import('sharp').Sharp}
+ */
+function applyAdjustments(pipeline, adj) {
+  if (!adj) return pipeline;
+
+  const modulate = {};
+  if (adj.brightness !== undefined && adj.brightness !== 1) modulate.brightness = adj.brightness;
+  if (adj.saturation !== undefined && adj.saturation !== 1) modulate.saturation = adj.saturation;
+  if (Object.keys(modulate).length > 0) pipeline = pipeline.modulate(modulate);
+
+  if (adj.contrast !== undefined && adj.contrast !== 1) {
+    const a = adj.contrast;
+    pipeline = pipeline.linear(a, 128 * (1 - a));
+  }
+
+  if (adj.blur !== undefined && adj.blur > 0.3) {
+    pipeline = pipeline.blur(adj.blur);
+  }
+
+  if (adj.sharpen !== undefined && adj.sharpen > 0) {
+    pipeline = pipeline.sharpen({sigma: adj.sharpen});
+  }
+
+  if (adj.gamma !== undefined && adj.gamma !== 1) {
+    pipeline = pipeline.gamma(adj.gamma);
+  }
+
+  return pipeline;
+}
+
+/**
+ * Composite a watermark image onto the pipeline.
+ * Materialises the pipeline to an intermediate buffer so current dimensions
+ * are known before sizing the watermark.
+ *
+ * @param {import('sharp').Sharp} pipeline
+ * @param {object} wm
+ * @param {string} wm.image     Filename in MEDIA_DIR
+ * @param {number} wm.opacity   0–1
+ * @param {number} wm.scale     Fraction of image width (0–1)
+ * @param {string} wm.position  e.g. 'bottom-right'
+ * @returns {Promise<import('sharp').Sharp>}
+ * @throws {Error} If watermark file cannot be read
+ */
+async function applyWatermark(pipeline, wm) {
+  if (!wm?.image) return pipeline;
+
+  const intermediate = await pipeline.toBuffer();
+  const {width: imgWidth} = await sharp(intermediate).metadata();
+
+  const wmPath = path.join(MEDIA_DIR, wm.image);
+  const wmSize = Math.max(1, Math.round((wm.scale || 0.15) * imgWidth));
+
+  let wmBuffer = await sharp(wmPath)
+    .resize(wmSize, null, {fit: 'inside'})
+    .ensureAlpha()
+    .toBuffer();
+
+  // Apply opacity: multiply each pixel's alpha by wm.opacity using dest-in blend
+  const {width: wmWidth, height: wmHeight} = await sharp(wmBuffer).metadata();
+  const opacity = wm.opacity !== undefined ? Math.max(0, Math.min(1, wm.opacity)) : 0.5;
+
+  const maskBuffer = await sharp({
+    create: {width: wmWidth, height: wmHeight, channels: 4, background: {r: 0, g: 0, b: 0, alpha: opacity}},
+  }).png().toBuffer();
+
+  wmBuffer = await sharp(wmBuffer)
+    .composite([{input: maskBuffer, blend: 'dest-in'}])
+    .png()
+    .toBuffer();
+
+  const gravityMap = {
+    'top-left': 'northwest', 'top-center': 'north', 'top-right': 'northeast',
+    'center-left': 'west', 'center': 'centre', 'center-right': 'east',
+    'bottom-left': 'southwest', 'bottom-center': 'south', 'bottom-right': 'southeast',
+  };
+  const gravity = gravityMap[wm.position || 'bottom-right'] || 'southeast';
+
+  return sharp(intermediate).composite([{input: wmBuffer, gravity}]);
+}
+
+/**
+ * Extend the image with a solid colour, mirror, or repeat border.
+ *
+ * @param {import('sharp').Sharp} pipeline
+ * @param {object} border
+ * @param {number} border.width   Pixels per side
+ * @param {string} border.colour  Hex colour e.g. '#ffffff'
+ * @param {string} border.mode    'solid' | 'mirror' | 'repeat'
+ * @returns {import('sharp').Sharp}
+ */
+function applyBorder(pipeline, border) {
+  if (!border?.width || border.width <= 0) return pipeline;
+
+  const colour = parseHexColour(border.colour || '#000000');
+  const w = Math.round(border.width);
+  const extendWith = border.mode === 'mirror' ? 'mirror'
+    : border.mode === 'repeat' ? 'repeat'
+      : 'background';
+
+  return pipeline.extend({
+    top: w, right: w, bottom: w, left: w,
+    extendWith,
+    background: {r: colour.r, g: colour.g, b: colour.b, alpha: 1},
+  });
+}
+
+/**
+ * Set the output format and quality.
+ *
+ * @param {import('sharp').Sharp} pipeline
+ * @param {object} format
+ * @param {string} format.type     'jpeg' | 'png' | 'webp'
+ * @param {number} [format.quality] 1–100
+ * @returns {import('sharp').Sharp}
+ */
+function applyFormat(pipeline, format) {
+  if (!format?.type) return pipeline;
+  const quality = format.quality ? Math.round(format.quality) : 85;
+  switch (format.type) {
+    case 'jpeg':
+      return pipeline.jpeg({quality});
+    case 'png':
+      return pipeline.png();
+    case 'webp':
+      return pipeline.webp({quality});
+    default:
+      return pipeline;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply a set of operations to an image and write the result.
+ *
+ * Pipeline order:
+ *   rotate → flip/flop → crop → resize → preset → adjustments → watermark → border → format
+ *
+ * @param {string} filename - Source media filename
+ * @param {object} operations
+ * @param {number}   [operations.rotate]       - Degrees (multiple of 90)
+ * @param {boolean}  [operations.flip]         - Flip vertically
+ * @param {boolean}  [operations.flop]         - Flip horizontally
+ * @param {{ left, top, width, height }} [operations.crop]
+ * @param {{ width, height }} [operations.resize]
+ * @param {string}   [operations.preset]       - Named colour preset
+ * @param {object}   [operations.adjustments]  - Numeric slider values
+ * @param {object}   [operations.watermark]    - Watermark composite options
+ * @param {object}   [operations.border]       - Border/extend options
+ * @param {object}   [operations.format]       - Output format override
+ * @param {string}   [operations._deleteOriginal] - Filename to delete after write
+ * @param {string|null} [outputFilename]       - Destination filename; null = overwrite source
+ * @returns {Promise<{ name: string, url: string, width: number, height: number }>}
+ * @throws {Error} If the source file cannot be read or written
+ */
+export async function transformImage(filename, operations = {}, outputFilename = null) {
+  const srcPath = path.join(MEDIA_DIR, filename);
+
+  // Read into buffer first — avoids file-lock when overwriting the source
+  const inputBuffer = await fs.readFile(srcPath);
+
+  let pipeline = sharp(inputBuffer);
+
+  if (operations.rotate) pipeline = pipeline.rotate(operations.rotate);
+  if (operations.flip) pipeline = pipeline.flip();
+  if (operations.flop) pipeline = pipeline.flop();
+
+  if (operations.crop) {
+    const {left, top, width, height} = operations.crop;
+    pipeline = pipeline.extract({
+      left: Math.round(left),
+      top: Math.round(top),
+      width: Math.round(width),
+      height: Math.round(height),
+    });
+  }
+
+  if (operations.resize) {
+    const {width, height} = operations.resize;
+    pipeline = pipeline.resize(width || null, height || null, {
+      fit: 'inside',
+      withoutEnlargement: true,
+    });
+  }
+
+  if (operations.preset) {
+    pipeline = applyPreset(pipeline, operations.preset, operations.adjustments || {});
+  }
+
+  if (operations.adjustments) {
+    pipeline = applyAdjustments(pipeline, operations.adjustments);
+  }
+
+  if (operations.watermark) {
+    pipeline = await applyWatermark(pipeline, operations.watermark);
+  }
+
+  if (operations.border) {
+    pipeline = applyBorder(pipeline, operations.border);
+  }
+
+  if (operations.format) {
+    pipeline = applyFormat(pipeline, operations.format);
+  }
+
+  const destFilename = outputFilename || filename;
+  const destPath = path.join(MEDIA_DIR, destFilename);
+
+  const outputBuffer = await pipeline.toBuffer();
+  await fs.writeFile(destPath, outputBuffer);
+
+  // Delete the original file when a format conversion overwrites it
+  if (operations._deleteOriginal && operations._deleteOriginal !== destFilename) {
+    const oldPath = path.join(MEDIA_DIR, operations._deleteOriginal);
+    await fs.unlink(oldPath).catch(() => {
+    });
+  }
+
+  const {width, height} = await sharp(outputBuffer).metadata();
+
+  const urlBase = config.content.mediaDir.replace(/^\.\/content/, '/media');
+  return {
+    name: destFilename,
+    url: `${urlBase}/${destFilename}`,
+    width,
+    height,
+  };
+}