collabmd 0.1.33 → 0.1.35

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

@@ -96,291 +96,310 @@ function getDirectoryDeleteStatusCode(message = '') {
   return String(message).includes('Directory is not empty') ? 409 : 400;
 }
 
-export function createVaultApiCommandHandler({
-  docxExporter = null,
-  vaultFileStore,
-  workspaceMutationCoordinator = null,
-}) {
-  return async function handleVaultApiCommand(req, res, requestUrl) {
-    if (requestUrl.pathname === '/api/export/docx' && req.method === 'POST') {
-      try {
-        const body = await parseJsonBody(req, DOCX_EXPORT_REQUEST_LIMIT_BYTES);
-        if (!body?.filePath || typeof body?.html !== 'string') {
-          jsonResponse(req, res, 400, { error: 'Missing filePath or html' });
-          return true;
-        }
-
-        if (!docxExporter?.render) {
-          jsonResponse(req, res, 503, { error: 'DOCX export is unavailable' });
-          return true;
-        }
-
-        const docxBuffer = await docxExporter.render({
-          html: body.html,
-          title: body.title || '',
-        });
-
-        sendResponse(req, res, {
-          body: docxBuffer,
-          headers: createDocxDownloadHeaders(body.filePath),
-          statusCode: 200,
-        });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to export DOCX:', 'Failed to export DOCX');
-      }
+async function handleExportDocx({ docxExporter }, req, res) {
+  try {
+    const body = await parseJsonBody(req, DOCX_EXPORT_REQUEST_LIMIT_BYTES);
+    if (!body?.filePath || typeof body?.html !== 'string') {
+      jsonResponse(req, res, 400, { error: 'Missing filePath or html' });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/file' && req.method === 'PUT') {
-      try {
-        const body = await parseJsonBody(req);
-        if (!body.path || typeof body.content !== 'string') {
-          jsonResponse(req, res, 400, { error: 'Missing path or content' });
-          return true;
-        }
-
-        const result = await selectWriteOperation(vaultFileStore, body.path, body.content);
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'write-file',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            changedPaths: [body.path],
-          }),
-        });
-
-        jsonResponse(req, res, 200, { ok: true });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
-      }
+    if (!docxExporter?.render) {
+      jsonResponse(req, res, 503, { error: 'DOCX export is unavailable' });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/attachments' && req.method === 'POST') {
-      try {
-        const sourceDocumentPath = decodeHeaderMetadata(req.headers['x-collabmd-source-path']);
-        const originalFileName = decodeHeaderMetadata(req.headers['x-collabmd-file-name']);
-        const mimeType = String(req.headers['content-type'] || '').trim();
-
-        if (!sourceDocumentPath) {
-          jsonResponse(req, res, 400, { error: 'Missing source document path' });
-          return true;
-        }
-
-        const content = await readBinaryRequestBody(req);
-        const result = await vaultFileStore.writeImageAttachmentForDocument(sourceDocumentPath, {
-          content,
-          mimeType,
-          originalFileName,
-        });
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'upload-attachment',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            changedPaths: [result.path],
-          }),
-        });
-
-        jsonResponse(req, res, 201, {
-          markdown: result.markdownSnippet,
-          ok: true,
-          path: result.path,
-        });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to upload attachment:', 'Failed to upload attachment');
-      }
+    const docxBuffer = await docxExporter.render({
+      html: body.html,
+      title: body.title || '',
+    });
+
+    sendResponse(req, res, {
+      body: docxBuffer,
+      headers: createDocxDownloadHeaders(body.filePath),
+      statusCode: 200,
+    });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to export DOCX:', 'Failed to export DOCX');
+  }
+  return true;
+}
+
+async function handleWriteFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const body = await parseJsonBody(req);
+    if (!body.path || typeof body.content !== 'string') {
+      jsonResponse(req, res, 400, { error: 'Missing path or content' });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/file' && req.method === 'POST') {
-      try {
-        const body = await parseJsonBody(req);
-        if (!body.path) {
-          jsonResponse(req, res, 400, { error: 'Missing path' });
-          return true;
-        }
-
-        const result = await vaultFileStore.createFile(body.path, body.content || '');
-        if (!result.ok) {
-          jsonResponse(req, res, 409, { error: result.error });
-          return true;
-        }
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'create-file',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            changedPaths: [body.path],
-          }),
-        });
-        jsonResponse(req, res, 201, { ok: true, path: body.path });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
-      }
+    const result = await selectWriteOperation(vaultFileStore, body.path, body.content);
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/file' && req.method === 'DELETE') {
-      const filePath = requestUrl.searchParams.get('path');
-      if (!filePath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'write-file',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        changedPaths: [body.path],
+      }),
+    });
+
+    jsonResponse(req, res, 200, { ok: true });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
+  }
+  return true;
+}
 
-      try {
-        const result = await vaultFileStore.deleteFile(filePath);
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'delete-file',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            deletedPaths: [filePath],
-          }),
-        });
-        jsonResponse(req, res, 200, { ok: true });
-      } catch (error) {
-        console.error('[api] Failed to delete file:', error.message);
-        jsonResponse(req, res, 500, { error: 'Failed to delete file' });
-      }
+async function handleUploadAttachment({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const sourceDocumentPath = decodeHeaderMetadata(req.headers['x-collabmd-source-path']);
+    const originalFileName = decodeHeaderMetadata(req.headers['x-collabmd-file-name']);
+    const mimeType = String(req.headers['content-type'] || '').trim();
+
+    if (!sourceDocumentPath) {
+      jsonResponse(req, res, 400, { error: 'Missing source document path' });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/file' && req.method === 'PATCH') {
-      try {
-        const body = await parseJsonBody(req);
-        if (!body.oldPath || !body.newPath) {
-          jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
-          return true;
-        }
-
-        const result = await vaultFileStore.renameFile(body.oldPath, body.newPath);
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'rename-file',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
-          }),
-        });
-        jsonResponse(req, res, 200, { ok: true, path: body.newPath });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to rename file:', 'Failed to rename file');
-      }
+    const content = await readBinaryRequestBody(req);
+    const result = await vaultFileStore.writeImageAttachmentForDocument(sourceDocumentPath, {
+      content,
+      mimeType,
+      originalFileName,
+    });
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/directory' && req.method === 'POST') {
-      try {
-        const body = await parseJsonBody(req);
-        if (!body.path) {
-          jsonResponse(req, res, 400, { error: 'Missing path' });
-          return true;
-        }
-
-        const result = await vaultFileStore.createDirectory(body.path);
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'create-directory',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: createWorkspaceChange({
-            changedPaths: [body.path],
-          }),
-        });
-
-        jsonResponse(req, res, 201, { ok: true });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');
-      }
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'upload-attachment',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        changedPaths: [result.path],
+      }),
+    });
+
+    jsonResponse(req, res, 201, {
+      markdown: result.markdownSnippet,
+      ok: true,
+      path: result.path,
+    });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to upload attachment:', 'Failed to upload attachment');
+  }
+  return true;
+}
+
+async function handleCreateFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const body = await parseJsonBody(req);
+    if (!body.path) {
+      jsonResponse(req, res, 400, { error: 'Missing path' });
       return true;
     }
 
-    if (requestUrl.pathname === '/api/directory' && req.method === 'PATCH') {
-      try {
-        const body = await parseJsonBody(req);
-        if (!body.oldPath || !body.newPath) {
-          jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
-          return true;
-        }
-
-        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryRenameWorkspaceChange?.(body.oldPath, body.newPath);
-        const result = await vaultFileStore.renameDirectory(body.oldPath, body.newPath);
-        if (!result.ok) {
-          jsonResponse(req, res, 400, { error: result.error });
-          return true;
-        }
-
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'rename-directory',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: workspaceChange ?? {
-            renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
-          },
-        });
-
-        jsonResponse(req, res, 200, { ok: true, path: body.newPath });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to rename directory:', 'Failed to rename directory');
-      }
+    const result = await vaultFileStore.createFile(body.path, body.content || '');
+    if (!result.ok) {
+      jsonResponse(req, res, 409, { error: result.error });
       return true;
     }
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'create-file',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        changedPaths: [body.path],
+      }),
+    });
+    jsonResponse(req, res, 201, { ok: true, path: body.path });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
+  }
+  return true;
+}
 
-    if (requestUrl.pathname === '/api/directory' && req.method === 'DELETE') {
-      const dirPath = requestUrl.searchParams.get('path');
-      const recursive = requestUrl.searchParams.get('recursive') === '1';
-      if (!dirPath) {
-        jsonResponse(req, res, 400, { error: 'Missing path parameter' });
-        return true;
-      }
+async function handleDeleteFile({ vaultFileStore, workspaceMutationCoordinator }, req, res, requestUrl) {
+  const filePath = requestUrl.searchParams.get('path');
+  if (!filePath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return true;
+  }
 
-      try {
-        const workspaceChange = await workspaceMutationCoordinator?.createDirectoryDeleteWorkspaceChange?.(dirPath);
-        const result = await vaultFileStore.deleteDirectory(dirPath, { recursive });
-        if (!result.ok) {
-          jsonResponse(req, res, getDirectoryDeleteStatusCode(result.error), { error: result.error });
-          return true;
-        }
-
-        await workspaceMutationCoordinator?.apply?.({
-          action: 'delete-directory',
-          origin: 'api',
-          requestId: readRequestId(req),
-          workspaceChange: workspaceChange ?? {
-            deletedPaths: [dirPath],
-          },
-        });
-
-        jsonResponse(req, res, 200, { ok: true });
-      } catch (error) {
-        handleVaultError(req, res, error, '[api] Failed to delete directory:', 'Failed to delete directory');
-      }
+  try {
+    const result = await vaultFileStore.deleteFile(filePath);
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
+      return true;
+    }
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'delete-file',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        deletedPaths: [filePath],
+      }),
+    });
+    jsonResponse(req, res, 200, { ok: true });
+  } catch (error) {
+    console.error('[api] Failed to delete file:', error.message);
+    jsonResponse(req, res, 500, { error: 'Failed to delete file' });
+  }
+  return true;
+}
+
+async function handleRenameFile({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const body = await parseJsonBody(req);
+    if (!body.oldPath || !body.newPath) {
+      jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
       return true;
     }
 
+    const result = await vaultFileStore.renameFile(body.oldPath, body.newPath);
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
+      return true;
+    }
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'rename-file',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
+      }),
+    });
+    jsonResponse(req, res, 200, { ok: true, path: body.newPath });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to rename file:', 'Failed to rename file');
+  }
+  return true;
+}
+
+async function handleCreateDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const body = await parseJsonBody(req);
+    if (!body.path) {
+      jsonResponse(req, res, 400, { error: 'Missing path' });
+      return true;
+    }
+
+    const result = await vaultFileStore.createDirectory(body.path);
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
+      return true;
+    }
+
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'create-directory',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: createWorkspaceChange({
+        changedPaths: [body.path],
+      }),
+    });
+
+    jsonResponse(req, res, 201, { ok: true });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');
+  }
+  return true;
+}
+
+async function handleRenameDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res) {
+  try {
+    const body = await parseJsonBody(req);
+    if (!body.oldPath || !body.newPath) {
+      jsonResponse(req, res, 400, { error: 'Missing oldPath or newPath' });
+      return true;
+    }
+
+    const workspaceChange = await workspaceMutationCoordinator?.createDirectoryRenameWorkspaceChange?.(body.oldPath, body.newPath);
+    const result = await vaultFileStore.renameDirectory(body.oldPath, body.newPath);
+    if (!result.ok) {
+      jsonResponse(req, res, 400, { error: result.error });
+      return true;
+    }
+
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'rename-directory',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: workspaceChange ?? {
+        renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
+      },
+    });
+
+    jsonResponse(req, res, 200, { ok: true, path: body.newPath });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to rename directory:', 'Failed to rename directory');
+  }
+  return true;
+}
+
+async function handleDeleteDirectory({ vaultFileStore, workspaceMutationCoordinator }, req, res, requestUrl) {
+  const dirPath = requestUrl.searchParams.get('path');
+  const recursive = requestUrl.searchParams.get('recursive') === '1';
+  if (!dirPath) {
+    jsonResponse(req, res, 400, { error: 'Missing path parameter' });
+    return true;
+  }
+
+  try {
+    const workspaceChange = await workspaceMutationCoordinator?.createDirectoryDeleteWorkspaceChange?.(dirPath);
+    const result = await vaultFileStore.deleteDirectory(dirPath, { recursive });
+    if (!result.ok) {
+      jsonResponse(req, res, getDirectoryDeleteStatusCode(result.error), { error: result.error });
+      return true;
+    }
+
+    await workspaceMutationCoordinator?.apply?.({
+      action: 'delete-directory',
+      origin: 'api',
+      requestId: readRequestId(req),
+      workspaceChange: workspaceChange ?? {
+        deletedPaths: [dirPath],
+      },
+    });
+
+    jsonResponse(req, res, 200, { ok: true });
+  } catch (error) {
+    handleVaultError(req, res, error, '[api] Failed to delete directory:', 'Failed to delete directory');
+  }
+  return true;
+}
+
+const ROUTE_TABLE = [
+  { method: 'POST', path: '/api/export/docx', handler: handleExportDocx },
+  { method: 'PUT', path: '/api/file', handler: handleWriteFile },
+  { method: 'POST', path: '/api/attachments', handler: handleUploadAttachment },
+  { method: 'POST', path: '/api/file', handler: handleCreateFile },
+  { method: 'DELETE', path: '/api/file', handler: handleDeleteFile },
+  { method: 'PATCH', path: '/api/file', handler: handleRenameFile },
+  { method: 'POST', path: '/api/directory', handler: handleCreateDirectory },
+  { method: 'PATCH', path: '/api/directory', handler: handleRenameDirectory },
+  { method: 'DELETE', path: '/api/directory', handler: handleDeleteDirectory },
+];
+
+export function createVaultApiCommandHandler({
+  docxExporter = null,
+  vaultFileStore,
+  workspaceMutationCoordinator = null,
+}) {
+  const context = { docxExporter, vaultFileStore, workspaceMutationCoordinator };
+
+  return async function handleVaultApiCommand(req, res, requestUrl) {
+    for (const route of ROUTE_TABLE) {
+      if (requestUrl.pathname === route.path && req.method === route.method) {
+        return route.handler(context, req, res, requestUrl);
+      }
+    }
     return false;
   };
 }