collabmd 0.1.33 → 0.1.34

package/src/server/domain/backlink-index.js

@@ -371,10 +371,23 @@ export class BacklinkIndex {
     previousState = null,
     nextState = null,
   } = {}) {
-    let refreshIndex = false;
     const previousEntries = previousState?.entries ?? new Map();
     const nextEntries = nextState?.entries ?? new Map();
     const changedPaths = Array.from(new Set(workspaceChange.changedPaths ?? []));
+    const { impactedSources, renameMap } = this._computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries);
+
+    let refreshIndex = this._applyDeletedPaths(workspaceChange.deletedPaths);
+    refreshIndex = this._applyRenamedPaths(workspaceChange.renamedPaths, refreshIndex);
+    refreshIndex = await this._applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex);
+
+    if (refreshIndex) {
+      const sourcesToRefresh = this._collectRefreshSources(impactedSources, changedPaths, workspaceChange.renamedPaths, nextEntries);
+      this._refreshWikiTargetIndex();
+      await this._refreshImpactedSources(sourcesToRefresh, { nextEntries, renameMap });
+    }
+  }
+
+  _computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries) {
     const createdPaths = changedPaths.filter((pathValue) => (
       nextEntries.has(pathValue) && !previousEntries.has(pathValue)
     ));
@@ -393,18 +406,28 @@ export class BacklinkIndex {
         .filter((entry) => entry?.oldPath && entry?.newPath)
         .map((entry) => [entry.oldPath, entry.newPath]),
     );
+    return { impactedSources, renameMap };
+  }
 
-    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+  _applyDeletedPaths(deletedPaths) {
+    let refreshIndex = false;
+    for (const pathValue of deletedPaths ?? []) {
       refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
-    for (const entry of workspaceChange.renamedPaths ?? []) {
+  _applyRenamedPaths(renamedPaths, refreshIndex) {
+    for (const entry of renamedPaths ?? []) {
       if (!entry?.oldPath || !entry?.newPath) {
         continue;
       }
       refreshIndex = this.onFileRenamed(entry.oldPath, entry.newPath, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
+  async _applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex) {
     for (const pathValue of changedPaths) {
       const existsNow = nextEntries.has(pathValue);
       const existedBefore = previousEntries.has(pathValue);
@@ -433,26 +456,22 @@ export class BacklinkIndex {
         refreshIndex = this.onFileCreated(pathValue, content, { refreshIndex: false }) || refreshIndex;
       }
     }
+    return refreshIndex;
+  }
 
-    if (refreshIndex) {
-      const sourcesToRefresh = new Set(impactedSources);
-      changedPaths.forEach((pathValue) => {
-        if (nextEntries.has(pathValue) && isMarkdownFilePath(pathValue)) {
-          sourcesToRefresh.add(pathValue);
-        }
-      });
-      (workspaceChange.renamedPaths ?? []).forEach((entry) => {
-        if (entry?.newPath && isMarkdownFilePath(entry.newPath)) {
-          sourcesToRefresh.add(entry.newPath);
-        }
-      });
-
-      this._refreshWikiTargetIndex();
-      await this._refreshImpactedSources(sourcesToRefresh, {
-        nextEntries,
-        renameMap,
-      });
-    }
+  _collectRefreshSources(impactedSources, changedPaths, renamedPaths, nextEntries) {
+    const sourcesToRefresh = new Set(impactedSources);
+    changedPaths.forEach((pathValue) => {
+      if (nextEntries.has(pathValue) && isMarkdownFilePath(pathValue)) {
+        sourcesToRefresh.add(pathValue);
+      }
+    });
+    (renamedPaths ?? []).forEach((entry) => {
+      if (entry?.newPath && isMarkdownFilePath(entry.newPath)) {
+        sourcesToRefresh.add(entry.newPath);
+      }
+    });
+    return sourcesToRefresh;
   }
 
   /**

package/src/server/infrastructure/http/create-request-handler.js

@@ -70,8 +70,7 @@ export function createRequestHandler(
     workspaceMutationCoordinator,
   });
 
-  return async function handleRequest(req, res) {
-    const originalRequestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+  function handleBasePathRedirect(req, res, originalRequestUrl) {
     if (
       config.basePath
       && (req.method === 'GET' || req.method === 'HEAD')
@@ -80,50 +79,56 @@ export function createRequestHandler(
       const location = `${config.basePath}/${originalRequestUrl.search}`;
       res.writeHead(308, { Location: location });
       res.end();
-      return;
+      return true;
     }
+    return false;
+  }
 
-    const requestUrl = createRequestUrlWithPathname(
-      originalRequestUrl,
-      stripBasePath(originalRequestUrl.pathname, config.basePath),
-    );
-    const isSameOriginWrite = isSameOriginWriteRequest(req, requestUrl);
-
-    setHeaders(res, SECURITY_HEADERS);
-
-    if (req.method === 'OPTIONS') {
-      const requestedMethod = String(req.headers['access-control-request-method'] || '').toUpperCase();
-      const preflightTargetsWrite = WRITE_METHODS.has(requestedMethod);
-      if (preflightTargetsWrite && !isSameOriginWrite) {
-        jsonResponse(req, res, 403, { error: 'Cross-origin write requests are not allowed' });
-        return;
-      }
+  function handleCorsPreflight(req, res, isSameOriginWrite) {
+    if (req.method !== 'OPTIONS') {
+      return false;
+    }
 
-      if (isSameOriginWrite) {
-        applyCorsHeaders(res, req.headers.origin);
-      }
+    const requestedMethod = String(req.headers['access-control-request-method'] || '').toUpperCase();
+    const preflightTargetsWrite = WRITE_METHODS.has(requestedMethod);
+    if (preflightTargetsWrite && !isSameOriginWrite) {
+      jsonResponse(req, res, 403, { error: 'Cross-origin write requests are not allowed' });
+      return true;
+    }
 
-      res.writeHead(204);
-      res.end();
-      return;
+    if (isSameOriginWrite) {
+      applyCorsHeaders(res, req.headers.origin);
     }
 
+    res.writeHead(204);
+    res.end();
+    return true;
+  }
+
+  function handleCorsWriteGuard(req, res, isSameOriginWrite) {
     if (WRITE_METHODS.has(req.method) && !isSameOriginWrite) {
       jsonResponse(req, res, 403, { error: 'Cross-origin write requests are not allowed' });
-      return;
+      return true;
+    }
+    return false;
+  }
+
+  async function handleTestEndpoints(req, res, requestUrl) {
+    if (config.nodeEnv !== 'test') {
+      return false;
     }
 
-    if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
+    if (requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
       await fileSystemSyncService?.resetForExternalStateChange?.();
       await roomRegistry?.reset?.();
       await backlinkIndex?.build?.();
       await workspaceMutationCoordinator?.initialize?.();
       await fileSystemSyncService?.resetForExternalStateChange?.();
       jsonResponse(req, res, 200, { ok: true });
-      return;
+      return true;
     }
 
-    if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/hydrate-delay' && req.method === 'POST') {
+    if (requestUrl.pathname === '/api/test/hydrate-delay' && req.method === 'POST') {
       const body = await parseJsonBody(req).catch(() => ({}));
       testControls.wsRoomHydrateDelayMs = Math.max(0, Number(body?.delayMs) || 0);
       await fileSystemSyncService?.resetForExternalStateChange?.();
@@ -132,6 +137,36 @@ export function createRequestHandler(
       await workspaceMutationCoordinator?.initialize?.();
       await fileSystemSyncService?.resetForExternalStateChange?.();
       jsonResponse(req, res, 200, { delayMs: testControls.wsRoomHydrateDelayMs, ok: true });
+      return true;
+    }
+
+    return false;
+  }
+
+  return async function handleRequest(req, res) {
+    const originalRequestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+
+    if (handleBasePathRedirect(req, res, originalRequestUrl)) {
+      return;
+    }
+
+    const requestUrl = createRequestUrlWithPathname(
+      originalRequestUrl,
+      stripBasePath(originalRequestUrl.pathname, config.basePath),
+    );
+    const isSameOriginWrite = isSameOriginWriteRequest(req, requestUrl);
+
+    setHeaders(res, SECURITY_HEADERS);
+
+    if (handleCorsPreflight(req, res, isSameOriginWrite)) {
+      return;
+    }
+
+    if (handleCorsWriteGuard(req, res, isSameOriginWrite)) {
+      return;
+    }
+
+    if (await handleTestEndpoints(req, res, requestUrl)) {
       return;
     }