collabmd 0.1.33 → 0.1.34

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -117,263 +117,285 @@ async function streamDirectoryArchive(req, res, {
   await responsePromise;
 }
 
-export function createVaultApiQueryHandler({
-  baseQueryService = null,
-  backlinkIndex,
-  vaultFileStore,
-  workspaceMutationCoordinator = null,
-}) {
-  return async function handleVaultApiQuery(req, res, requestUrl) {
-    if (requestUrl.pathname === '/api/base/query' && req.method === 'POST') {
-      try {
-        if (!baseQueryService?.query) {
-          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
-          return true;
-        }
-
-        const body = await parseJsonBody(req);
-        const result = await baseQueryService.query({
-          activeFilePath: body?.activeFilePath ?? '',
-          basePath: body?.path ?? '',
-          search: body?.search ?? '',
-          source: typeof body?.source === 'string' ? body.source : null,
-          sourcePath: body?.sourcePath ?? '',
-          view: body?.view ?? '',
-        });
-
-        jsonResponse(req, res, 200, { ok: true, result });
-      } catch (error) {
-        console.error('[api] Failed to query base:', error.message);
-        jsonResponse(req, res, 400, { error: error.message || 'Failed to query base' });
-      }
-      return true;
-    }
+// --- Route handlers ---
 
-    if (requestUrl.pathname === '/api/base/property-values' && req.method === 'POST') {
-      try {
-        if (!baseQueryService?.propertyValues) {
-          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
-          return true;
-        }
-
-        const body = await parseJsonBody(req);
-        const result = await baseQueryService.propertyValues({
-          activeFilePath: body?.activeFilePath ?? '',
-          basePath: body?.path ?? '',
-          propertyId: body?.propertyId ?? '',
-          query: body?.query ?? '',
-          source: typeof body?.source === 'string' ? body.source : null,
-          sourcePath: body?.sourcePath ?? '',
-          view: body?.view ?? '',
-        });
-
-        jsonResponse(req, res, 200, { ok: true, result });
-      } catch (error) {
-        console.error('[api] Failed to read base property values:', error.message);
-        jsonResponse(req, res, 400, { error: error.message || 'Failed to read base property values' });
-      }
-      return true;
+async function handleBaseQuery(req, res, _requestUrl, { baseQueryService }) {
+  try {
+    if (!baseQueryService?.query) {
+      jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/base/transform' && req.method === 'POST') {
-      try {
-        if (!baseQueryService?.transform) {
-          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
-          return true;
-        }
-
-        const body = await parseJsonBody(req);
-        const result = await baseQueryService.transform({
-          activeFilePath: body?.activeFilePath ?? '',
-          basePath: body?.path ?? '',
-          mutation: body?.mutation ?? null,
-          source: typeof body?.source === 'string' ? body.source : null,
-          sourcePath: body?.sourcePath ?? '',
-          view: body?.view ?? '',
-        });
-
-        jsonResponse(req, res, 200, { ok: true, result });
-      } catch (error) {
-        console.error('[api] Failed to transform base:', error.message);
-        jsonResponse(req, res, 400, { error: error.message || 'Failed to transform base' });
-      }
-      return true;
+    const body = await parseJsonBody(req);
+    const result = await baseQueryService.query({
+      activeFilePath: body?.activeFilePath ?? '',
+      basePath: body?.path ?? '',
+      search: body?.search ?? '',
+      source: typeof body?.source === 'string' ? body.source : null,
+      sourcePath: body?.sourcePath ?? '',
+      view: body?.view ?? '',
+    });
+
+    jsonResponse(req, res, 200, { ok: true, result });
+  } catch (error) {
+    console.error('[api] Failed to query base:', error.message);
+    jsonResponse(req, res, 400, { error: error.message || 'Failed to query base' });
+  }
+}
+
+async function handleBasePropertyValues(req, res, _requestUrl, { baseQueryService }) {
+  try {
+    if (!baseQueryService?.propertyValues) {
+      jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/base/export' && req.method === 'POST') {
-      try {
-        if (!baseQueryService?.query) {
-          jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
-          return true;
-        }
-
-        const body = await parseJsonBody(req);
-        const result = await baseQueryService.query({
-          activeFilePath: body?.activeFilePath ?? '',
-          basePath: body?.path ?? '',
-          includeCsv: true,
-          search: body?.search ?? '',
-          source: typeof body?.source === 'string' ? body.source : null,
-          sourcePath: body?.sourcePath ?? '',
-          view: body?.view ?? '',
-        });
-        const fileName = basename(String(body?.path || body?.sourcePath || 'base')).replace(/\.[^.]+$/u, '') || 'base';
-        sendResponse(req, res, {
-          body: result.csv,
-          headers: {
-            'Cache-Control': 'no-store',
-            'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(`${fileName}.csv`)}"; filename*=UTF-8''${encodeContentDispositionFilename(`${fileName}.csv`)}`,
-            'Content-Type': 'text/csv; charset=utf-8',
-            'X-Content-Type-Options': 'nosniff',
-          },
-          statusCode: 200,
-        });
-      } catch (error) {
-        console.error('[api] Failed to export base CSV:', error.message);
-        jsonResponse(req, res, 400, { error: error.message || 'Failed to export base CSV' });
-      }
-      return true;
+    const body = await parseJsonBody(req);
+    const result = await baseQueryService.propertyValues({
+      activeFilePath: body?.activeFilePath ?? '',
+      basePath: body?.path ?? '',
+      propertyId: body?.propertyId ?? '',
+      query: body?.query ?? '',
+      source: typeof body?.source === 'string' ? body.source : null,
+      sourcePath: body?.sourcePath ?? '',
+      view: body?.view ?? '',
+    });
+
+    jsonResponse(req, res, 200, { ok: true, result });
+  } catch (error) {
+    console.error('[api] Failed to read base property values:', error.message);
+    jsonResponse(req, res, 400, { error: error.message || 'Failed to read base property values' });
+  }
+}
+
+async function handleBaseTransform(req, res, _requestUrl, { baseQueryService }) {
+  try {
+    if (!baseQueryService?.transform) {
+      jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
-      try {
-        const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();
-        jsonResponse(req, res, 200, { tree });
-      } catch (error) {
-        console.error('[api] Failed to read file tree:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to read file tree' });
-      }
-      return true;
+    const body = await parseJsonBody(req);
+    const result = await baseQueryService.transform({
+      activeFilePath: body?.activeFilePath ?? '',
+      basePath: body?.path ?? '',
+      mutation: body?.mutation ?? null,
+      source: typeof body?.source === 'string' ? body.source : null,
+      sourcePath: body?.sourcePath ?? '',
+      view: body?.view ?? '',
+    });
+
+    jsonResponse(req, res, 200, { ok: true, result });
+  } catch (error) {
+    console.error('[api] Failed to transform base:', error.message);
+    jsonResponse(req, res, 400, { error: error.message || 'Failed to transform base' });
+  }
+}
+
+async function handleBaseExport(req, res, _requestUrl, { baseQueryService }) {
+  try {
+    if (!baseQueryService?.query) {
+      jsonResponse(req, res, 503, { error: 'Bases query service is unavailable' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/file' && req.method === 'GET') {
-      const filePath = requestUrl.searchParams.get('path');
-      if (!filePath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+    const body = await parseJsonBody(req);
+    const result = await baseQueryService.query({
+      activeFilePath: body?.activeFilePath ?? '',
+      basePath: body?.path ?? '',
+      includeCsv: true,
+      search: body?.search ?? '',
+      source: typeof body?.source === 'string' ? body.source : null,
+      sourcePath: body?.sourcePath ?? '',
+      view: body?.view ?? '',
+    });
+    const fileName = basename(String(body?.path || body?.sourcePath || 'base')).replace(/\.[^.]+$/u, '') || 'base';
+    sendResponse(req, res, {
+      body: result.csv,
+      headers: {
+        'Cache-Control': 'no-store',
+        'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(`${fileName}.csv`)}"; filename*=UTF-8''${encodeContentDispositionFilename(`${fileName}.csv`)}`,
+        'Content-Type': 'text/csv; charset=utf-8',
+        'X-Content-Type-Options': 'nosniff',
+      },
+      statusCode: 200,
+    });
+  } catch (error) {
+    console.error('[api] Failed to export base CSV:', error.message);
+    jsonResponse(req, res, 400, { error: error.message || 'Failed to export base CSV' });
+  }
+}
 
-      try {
-        const content = await selectReadOperation(vaultFileStore, filePath);
-        if (content === null) {
-          jsonResponse(req, res, 404, { error: 'File not found' });
-          return true;
-        }
-
-        jsonResponse(req, res, 200, { path: filePath, content });
-      } catch (error) {
-        console.error('[api] Failed to read file:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to read file' });
-      }
-      return true;
+async function handleFileTree(req, res, _requestUrl, { vaultFileStore, workspaceMutationCoordinator }) {
+  try {
+    const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();
+    jsonResponse(req, res, 200, { tree });
+  } catch (error) {
+    console.error('[api] Failed to read file tree:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to read file tree' });
+  }
+}
+
+async function handleFileRead(req, res, requestUrl, { vaultFileStore }) {
+  const filePath = requestUrl.searchParams.get('path');
+  if (!filePath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return;
+  }
+
+  try {
+    const content = await selectReadOperation(vaultFileStore, filePath);
+    if (content === null) {
+      jsonResponse(req, res, 404, { error: 'File not found' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/download/file' && req.method === 'GET') {
-      const filePath = requestUrl.searchParams.get('path');
-      if (!filePath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+    jsonResponse(req, res, 200, { path: filePath, content });
+  } catch (error) {
+    console.error('[api] Failed to read file:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to read file' });
+  }
+}
 
-      try {
-        const download = await vaultFileStore.readDownloadFile(filePath);
-        if (!download) {
-          jsonResponse(req, res, 404, { error: 'File not found' });
-          return true;
-        }
-
-        sendResponse(req, res, {
-          body: download.content,
-          headers: createDownloadHeaders(
-            basename(String(download.path ?? 'download')),
-            download.mimeType || 'application/octet-stream',
-          ),
-          statusCode: 200,
-        });
-      } catch (error) {
-        console.error('[api] Failed to download file:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to download file' });
-      }
-      return true;
+async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
+  const filePath = requestUrl.searchParams.get('path');
+  if (!filePath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return;
+  }
+
+  try {
+    const download = await vaultFileStore.readDownloadFile(filePath);
+    if (!download) {
+      jsonResponse(req, res, 404, { error: 'File not found' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/download/directory' && req.method === 'GET') {
-      const directoryPath = requestUrl.searchParams.get('path');
-      if (!directoryPath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+    sendResponse(req, res, {
+      body: download.content,
+      headers: createDownloadHeaders(
+        basename(String(download.path ?? 'download')),
+        download.mimeType || 'application/octet-stream',
+      ),
+      statusCode: 200,
+    });
+  } catch (error) {
+    console.error('[api] Failed to download file:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to download file' });
+  }
+}
 
-      try {
-        const result = await vaultFileStore.listDirectoryEntriesForDownload(directoryPath);
-        if (!result.ok) {
-          jsonResponse(req, res, result.error === 'Directory not found' ? 404 : 400, { error: result.error });
-          return true;
-        }
-
-        await streamDirectoryArchive(req, res, {
-          entries: result.entries,
-          rootName: result.rootName || 'archive',
-        });
-      } catch (error) {
-        console.error('[api] Failed to download directory:', error.message);
-        if (!res.headersSent) {
-          jsonResponse(req, res, 500, { error: 'Failed to download directory' });
-        } else {
-          res.destroy(error);
-        }
-      }
-      return true;
+async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore }) {
+  const directoryPath = requestUrl.searchParams.get('path');
+  if (!directoryPath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return;
+  }
+
+  try {
+    const result = await vaultFileStore.listDirectoryEntriesForDownload(directoryPath);
+    if (!result.ok) {
+      jsonResponse(req, res, result.error === 'Directory not found' ? 404 : 400, { error: result.error });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/attachment' && req.method === 'GET') {
-      const filePath = requestUrl.searchParams.get('path');
-      if (!filePath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+    await streamDirectoryArchive(req, res, {
+      entries: result.entries,
+      rootName: result.rootName || 'archive',
+    });
+  } catch (error) {
+    console.error('[api] Failed to download directory:', error.message);
+    if (!res.headersSent) {
+      jsonResponse(req, res, 500, { error: 'Failed to download directory' });
+    } else {
+      res.destroy(error);
+    }
+  }
+}
 
-      if (!isImageAttachmentFilePath(filePath)) {
-        jsonResponse(req, res, 400, { error: 'Unsupported attachment path' });
-        return true;
-      }
+async function handleAttachmentRead(req, res, requestUrl, { vaultFileStore }) {
+  const filePath = requestUrl.searchParams.get('path');
+  if (!filePath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return;
+  }
 
-      try {
-        const attachment = await vaultFileStore.readImageAttachmentFile(filePath);
-        if (!attachment) {
-          jsonResponse(req, res, 404, { error: 'Attachment not found' });
-          return true;
-        }
-
-        sendResponse(req, res, {
-          body: attachment.content,
-          headers: createAttachmentHeaders(attachment),
-          statusCode: 200,
-        });
-      } catch (error) {
-        console.error('[api] Failed to read attachment:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to read attachment' });
-      }
-      return true;
+  if (!isImageAttachmentFilePath(filePath)) {
+    jsonResponse(req, res, 400, { error: 'Unsupported attachment path' });
+    return;
+  }
+
+  try {
+    const attachment = await vaultFileStore.readImageAttachmentFile(filePath);
+    if (!attachment) {
+      jsonResponse(req, res, 404, { error: 'Attachment not found' });
+      return;
     }
 
-    if (requestUrl.pathname === '/api/backlinks' && req.method === 'GET') {
-      const filePath = requestUrl.searchParams.get('file');
-      if (!filePath) {
-        jsonResponse(req, res, 400, { error: 'Missing file parameter' });
-        return true;
-      }
+    sendResponse(req, res, {
+      body: attachment.content,
+      headers: createAttachmentHeaders(attachment),
+      statusCode: 200,
+    });
+  } catch (error) {
+    console.error('[api] Failed to read attachment:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to read attachment' });
+  }
+}
+
+async function handleBacklinks(req, res, requestUrl, { backlinkIndex }) {
+  const filePath = requestUrl.searchParams.get('file');
+  if (!filePath) {
+    jsonResponse(req, res, 400, { error: 'Missing file parameter' });
+    return;
+  }
+
+  try {
+    jsonResponse(req, res, 200, {
+      backlinks: backlinkIndex ? await backlinkIndex.getBacklinks(filePath) : [],
+      file: filePath,
+    });
+  } catch (error) {
+    console.error('[api] Failed to get backlinks:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to get backlinks' });
+  }
+}
 
-      try {
-        jsonResponse(req, res, 200, {
-          backlinks: backlinkIndex ? await backlinkIndex.getBacklinks(filePath) : [],
-          file: filePath,
-        });
-      } catch (error) {
-        console.error('[api] Failed to get backlinks:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to get backlinks' });
+// --- Route table ---
+
+function createRouteTable(context) {
+  return [
+    { method: 'POST', path: '/api/base/query', handler: handleBaseQuery },
+    { method: 'POST', path: '/api/base/property-values', handler: handleBasePropertyValues },
+    { method: 'POST', path: '/api/base/transform', handler: handleBaseTransform },
+    { method: 'POST', path: '/api/base/export', handler: handleBaseExport },
+    { method: 'GET', path: '/api/files', handler: handleFileTree },
+    { method: 'GET', path: '/api/file', handler: handleFileRead },
+    { method: 'GET', path: '/api/download/file', handler: handleFileDownload },
+    { method: 'GET', path: '/api/download/directory', handler: handleDirectoryDownload },
+    { method: 'GET', path: '/api/attachment', handler: handleAttachmentRead },
+    { method: 'GET', path: '/api/backlinks', handler: handleBacklinks },
+  ].map((route) => ({
+    ...route,
+    handler: (req, res, requestUrl) => route.handler(req, res, requestUrl, context),
+  }));
+}
+
+export function createVaultApiQueryHandler({
+  baseQueryService = null,
+  backlinkIndex,
+  vaultFileStore,
+  workspaceMutationCoordinator = null,
+}) {
+  const context = { baseQueryService, backlinkIndex, vaultFileStore, workspaceMutationCoordinator };
+  const routes = createRouteTable(context);
+
+  return async function handleVaultApiQuery(req, res, requestUrl) {
+    for (const route of routes) {
+      if (req.method === route.method && requestUrl.pathname === route.path) {
+        await route.handler(req, res, requestUrl);
+        return true;
       }
-      return true;
     }
 
     return false;

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
+import sharp from 'sharp';
 
 import {
   getVaultFileKind,
@@ -38,6 +39,9 @@ const MIME_TYPE_TO_IMAGE_EXTENSION = Object.freeze({
   'image/svg+xml': '.svg',
   'image/webp': '.webp',
 });
+const MAX_RASTER_ATTACHMENT_PIXELS = 40_000_000;
+const RASTER_IMAGE_MIME_TYPES_TO_CONVERT = new Set(['image/jpeg', 'image/png']);
+const RASTER_IMAGE_EXTENSIONS_TO_CONVERT = new Set(['.jpeg', '.jpg', '.png']);
 const TEXT_FILE_MIME_TYPES = Object.freeze({
   base: 'text/yaml; charset=utf-8',
   drawio: 'application/xml; charset=utf-8',
@@ -159,13 +163,8 @@ function createAttachmentTimestamp(date = new Date()) {
     ].join('');
 }
 
-function createDocumentAttachmentDirectoryPath(documentPath) {
-  const normalizedPath = String(documentPath ?? '').replace(/\\/g, '/');
-  const documentDir = dirname(normalizedPath).replace(/\\/g, '/');
-  const documentStem = basename(normalizedPath, extname(normalizedPath));
-  return documentDir === '.'
-    ? `${documentStem}.assets`
-    : `${documentDir}/${documentStem}.assets`;
+function createDocumentAttachmentDirectoryPath() {
+  return 'assets';
 }
 
 function createAttachmentAltText(originalFileName = '') {
@@ -204,6 +203,59 @@ function resolveAttachmentExtension({ mimeType, originalFileName }) {
   return MIME_TYPE_TO_IMAGE_EXTENSION[normalizedMimeType] ?? '';
 }
 
+async function prepareImageAttachmentForStorage({
+  content,
+  mimeType,
+  originalFileName,
+}) {
+  const normalizedMimeType = normalizeAttachmentMimeType(mimeType);
+  const extension = resolveAttachmentExtension({
+    mimeType: normalizedMimeType,
+    originalFileName,
+  });
+
+  if (!extension) {
+    return { ok: false, error: 'Unsupported image type' };
+  }
+
+  const shouldConvertToWebp = RASTER_IMAGE_MIME_TYPES_TO_CONVERT.has(normalizedMimeType)
+    || (!normalizedMimeType && RASTER_IMAGE_EXTENSIONS_TO_CONVERT.has(extension));
+  if (!shouldConvertToWebp) {
+    return {
+      content,
+      extension,
+      ok: true,
+    };
+  }
+
+  try {
+    const image = sharp(content, {
+      failOn: 'error',
+      limitInputPixels: MAX_RASTER_ATTACHMENT_PIXELS,
+    });
+    const metadata = await image.metadata();
+    const pixelCount = Number(metadata.width || 0) * Number(metadata.height || 0);
+    if (!metadata.width || !metadata.height || pixelCount > MAX_RASTER_ATTACHMENT_PIXELS) {
+      return { ok: false, error: 'Image dimensions exceed limit' };
+    }
+
+    return {
+      content: await image
+        .rotate()
+        .webp()
+        .toBuffer(),
+      extension: '.webp',
+      ok: true,
+    };
+  } catch (error) {
+    if (String(error?.message || '').includes('pixel limit')) {
+      return { ok: false, error: 'Image dimensions exceed limit' };
+    }
+
+    return { ok: false, error: 'Failed to convert image to WebP' };
+  }
+}
+
 function createAttachmentMarkdownSnippet({ altText, documentPath, storedPath }) {
   const relativePath = relative(dirname(documentPath), storedPath).replace(/\\/g, '/');
   const encodedRelativePath = encodeMarkdownPath(relativePath || basename(storedPath));
@@ -434,9 +486,13 @@ export class VaultFileStore {
       return { ok: false, error: 'Source document must be a markdown file' };
     }
 
-    const extension = resolveAttachmentExtension({ mimeType, originalFileName });
-    if (!extension) {
-      return { ok: false, error: 'Unsupported image type' };
+    const preparedAttachment = await prepareImageAttachmentForStorage({
+      content,
+      mimeType,
+      originalFileName,
+    });
+    if (!preparedAttachment.ok) {
+      return { ok: false, error: preparedAttachment.error };
     }
 
     const stemSource = basename(String(originalFileName ?? ''), extname(String(originalFileName ?? '')));
@@ -450,7 +506,7 @@ export class VaultFileStore {
 
     do {
       const suffix = collisionIndex > 0 ? `-${collisionIndex + 1}` : '';
-      storedPath = `${attachmentDirPath}/${baseFileName}${suffix}${extension}`;
+      storedPath = `${attachmentDirPath}/${baseFileName}${suffix}${preparedAttachment.extension}`;
       absolutePath = this.resolveContentPath(storedPath, { requireVaultFile: false });
       collisionIndex += 1;
     } while (absolutePath && await pathExists(absolutePath));
@@ -462,7 +518,7 @@ export class VaultFileStore {
     try {
       await this.runManagedWrite([storedPath], async () => {
         await mkdir(dirname(absolutePath), { recursive: true });
-        await writeFile(absolutePath, content);
+        await writeFile(absolutePath, preparedAttachment.content);
       });
     } catch (error) {
       return { ok: false, error: error.message };