collabmd 0.1.30 → 0.1.32

package/src/server/domain/bases/base-query-service.js

@@ -0,0 +1,204 @@
+import {
+  buildColumns,
+  collectEvaluatedPropertyIds,
+  normalizeBaseDefinition,
+} from './base-definition.js';
+import {
+  compareValues,
+  createEvaluationRootContext,
+  evaluateFilterNode,
+  getPropertyValue,
+} from './base-expression-runtime.js';
+import { BaseIndexSnapshotStore } from './base-index-snapshot-store.js';
+import { buildQueryResultPayload, rowMatchesSearch } from './base-query-results.js';
+
+export { serializeBaseDefinition } from './base-definition.js';
+
+export class BaseQueryService {
+  constructor({
+    vaultFileStore,
+    workspaceStateProvider = null,
+    workspaceStateSynchronizer = null,
+  }) {
+    this.vaultFileStore = vaultFileStore;
+    this.snapshotStore = new BaseIndexSnapshotStore({
+      vaultFileStore,
+      workspaceStateProvider,
+      workspaceStateSynchronizer,
+    });
+  }
+
+  get workspaceStateProvider() {
+    return this.snapshotStore.workspaceStateProvider;
+  }
+
+  set workspaceStateProvider(value) {
+    this.snapshotStore.workspaceStateProvider = value;
+  }
+
+  get workspaceStateSynchronizer() {
+    return this.snapshotStore.workspaceStateSynchronizer;
+  }
+
+  set workspaceStateSynchronizer(value) {
+    this.snapshotStore.workspaceStateSynchronizer = value;
+  }
+
+  get indexSnapshot() {
+    return this.snapshotStore.indexSnapshot;
+  }
+
+  set indexSnapshot(value) {
+    this.snapshotStore.indexSnapshot = value;
+  }
+
+  get lastWorkspaceState() {
+    return this.snapshotStore.lastWorkspaceState;
+  }
+
+  set lastWorkspaceState(value) {
+    this.snapshotStore.lastWorkspaceState = value;
+  }
+
+  async getWorkspaceState() {
+    return this.snapshotStore.getWorkspaceState();
+  }
+
+  createSnapshotRow(...args) {
+    return this.snapshotStore.createSnapshotRow(...args);
+  }
+
+  rebuildBacklinks(...args) {
+    return this.snapshotStore.rebuildBacklinks(...args);
+  }
+
+  async buildIndexSnapshot(...args) {
+    return this.snapshotStore.buildIndexSnapshot(...args);
+  }
+
+  async synchronizeWorkspaceState() {
+    return this.snapshotStore.synchronizeWorkspaceState();
+  }
+
+  removeSnapshotPath(...args) {
+    return this.snapshotStore.removeSnapshotPath(...args);
+  }
+
+  upsertSnapshotPath(...args) {
+    return this.snapshotStore.upsertSnapshotPath(...args);
+  }
+
+  collectImpactedSourcesForMembershipChanges(...args) {
+    return this.snapshotStore.collectImpactedSourcesForMembershipChanges(...args);
+  }
+
+  async refreshSnapshotRows(...args) {
+    return this.snapshotStore.refreshSnapshotRows(...args);
+  }
+
+  async ensureIndexSnapshot(...args) {
+    return this.snapshotStore.ensureIndexSnapshot(...args);
+  }
+
+  async initializeFromWorkspaceState(...args) {
+    return this.snapshotStore.initializeFromWorkspaceState(...args);
+  }
+
+  async applyWorkspaceChange(...args) {
+    return this.snapshotStore.applyWorkspaceChange(...args);
+  }
+
+  async query({
+    activeFilePath = '',
+    basePath = '',
+    search = '',
+    source = null,
+    sourcePath = '',
+    view: requestedView = '',
+  } = {}) {
+    const baseSource = source ?? (basePath ? await this.vaultFileStore.readBaseFile(basePath) : '');
+    if (typeof baseSource !== 'string') {
+      throw new Error('Base source not found');
+    }
+
+    const definition = normalizeBaseDefinition(baseSource);
+    const snapshot = await this.ensureIndexSnapshot({
+      basePath,
+      sourcePath,
+    });
+    const thisFilePath = sourcePath || activeFilePath || basePath || '';
+    const thisFile = snapshot.rowsByPath.get(thisFilePath)?.file ?? null;
+    const activeView = definition.views.find((entry) => entry.name === requestedView || entry.id === requestedView) ?? definition.views[0];
+    const columns = buildColumns(definition, activeView);
+    const evaluatedPropertyIds = collectEvaluatedPropertyIds(columns, activeView);
+
+    let rows = snapshot.filePaths
+      .map((filePath) => snapshot.rowsByPath.get(filePath))
+      .filter(Boolean)
+      .filter((row) => {
+        const globalContext = createEvaluationRootContext({
+          currentRow: row,
+          definition,
+          snapshot,
+          thisFile,
+        });
+        if (!evaluateFilterNode(definition.filters, globalContext)) {
+          return false;
+        }
+
+        const viewContext = createEvaluationRootContext({
+          currentRow: row,
+          definition,
+          snapshot,
+          thisFile,
+        });
+        return evaluateFilterNode(activeView.filters, viewContext);
+      })
+      .map((row) => {
+        const rawCells = {};
+        evaluatedPropertyIds.forEach((propertyId) => {
+          rawCells[propertyId] = getPropertyValue(propertyId, row, definition, snapshot, thisFile);
+        });
+        return {
+          file: row.file,
+          rawCells,
+        };
+      });
+
+    activeView.sort.forEach((sortConfig) => {
+      rows = rows.slice().sort((left, right) => {
+        const delta = compareValues(left.rawCells[sortConfig.property], right.rawCells[sortConfig.property]);
+        return sortConfig.direction === 'desc' ? -delta : delta;
+      });
+    });
+
+    if (activeView.limit != null) {
+      rows = rows.slice(0, activeView.limit);
+    }
+
+    rows = rows.filter((row) => rowMatchesSearch(row, columns, search));
+
+    return {
+      columns,
+      definition,
+      ...buildQueryResultPayload({
+        activeView,
+        columns,
+        definition,
+        rows,
+        snapshot,
+        thisFile,
+      }),
+      view: {
+        ...activeView,
+        supported: activeView.supported,
+      },
+      views: definition.views.map((view) => ({
+        id: view.id,
+        name: view.name,
+        supported: view.supported,
+        type: view.type,
+      })),
+    };
+  }
+}

package/src/server/domain/collaboration/collaboration-document-store.js

@@ -1,9 +1,10 @@
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
+  isMarkdownFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
-  supportsBacklinksForFilePath,
 } from '../../../domain/file-kind.js';
 
 function assertWriteSucceeded(result, operation, filePath) {
@@ -54,6 +55,10 @@ export class CollaborationDocumentStore {
       return this.vaultFileStore.readExcalidrawFile(this.name);
     }
 
+    if (isBaseFilePath(this.name) && typeof this.vaultFileStore.readBaseFile === 'function') {
+      return this.vaultFileStore.readBaseFile(this.name);
+    }
+
     if (isDrawioFilePath(this.name) && typeof this.vaultFileStore.readDrawioFile === 'function') {
       return this.vaultFileStore.readDrawioFile(this.name);
     }
@@ -99,7 +104,7 @@ export class CollaborationDocumentStore {
       await this.writeSnapshot(snapshot);
     }
 
-    if (this.backlinkIndex && supportsBacklinksForFilePath(this.name)) {
+    if (this.backlinkIndex && isMarkdownFilePath(this.name)) {
       this.backlinkIndex.updateFile(this.name, content);
     }
   }
@@ -122,6 +127,12 @@ export class CollaborationDocumentStore {
       return;
     }
 
+    if (isBaseFilePath(this.name) && typeof this.vaultFileStore.writeBaseFile === 'function') {
+      const result = await this.vaultFileStore.writeBaseFile(this.name, content, options);
+      assertWriteSucceeded(result, 'write content', this.name);
+      return;
+    }
+
     if (isMermaidFilePath(this.name) && typeof this.vaultFileStore.writeMermaidFile === 'function') {
       const result = await this.vaultFileStore.writeMermaidFile(this.name, content, options);
       assertWriteSucceeded(result, 'write content', this.name);

package/src/server/domain/collaboration/collaboration-room.js

@@ -45,10 +45,39 @@ function closeSlowClient(ws, clientState, { maxBufferedAmountBytes, name }) {
   return false;
 }
 
+function isExpectedSocketSendError(error) {
+  const code = String(error?.code || '').toUpperCase();
+  const message = String(error?.message || '');
+
+  return code === 'EPIPE'
+    || code === 'ECONNRESET'
+    || /EPIPE|ECONNRESET|WebSocket is not open|readyState/i.test(message);
+}
+
+function cleanupDisconnectedClient(room, ws, clientState) {
+  if (clientState?.transportCloseIssued) {
+    return false;
+  }
+
+  if (clientState) {
+    clientState.transportCloseIssued = true;
+  }
+
+  room?.removeClient?.(ws);
+
+  try {
+    ws.terminate?.();
+  } catch {
+    // Ignore termination errors while cleaning up disconnected clients.
+  }
+
+  return false;
+}
+
 function sendMessage(ws, payload, { maxBufferedAmountBytes, name }) {
   const clientState = this?.getClientState?.(ws) ?? null;
   if (ws.readyState !== ws.OPEN) {
-    return false;
+    return cleanupDisconnectedClient(this, ws, clientState);
   }
 
   const bufferedAmountBeforeSend = ws.bufferedAmount;
@@ -59,6 +88,11 @@ function sendMessage(ws, payload, { maxBufferedAmountBytes, name }) {
 
   ws.send(payload, (error) => {
     if (error) {
+      if (isExpectedSocketSendError(error)) {
+        cleanupDisconnectedClient(this, ws, clientState);
+        return;
+      }
+
       console.error(`[room:${name}] Failed to send websocket frame:`, error.message);
     }
   });
@@ -343,6 +377,7 @@ export class CollaborationRoom {
     const existingState = this.getClientState(ws);
     if (existingState) {
       existingState.backpressureCloseIssued = false;
+      existingState.transportCloseIssued = false;
       return existingState;
     }
 

package/src/server/domain/collaboration/room-client-state-store.js

@@ -2,6 +2,7 @@ function createClientState() {
   return {
     backpressureCloseIssued: false,
     controlledClientIds: new Set(),
+    transportCloseIssued: false,
   };
 }
 

package/src/server/domain/collaboration/room-persistence-controller.js

@@ -46,10 +46,10 @@ export class RoomPersistenceController {
       return;
     }
 
-    const generation = ++this.shutdownGeneration;
     if (this.finalizePromise) {
       return;
     }
+    const generation = ++this.shutdownGeneration;
 
     this.finalizePromise = (async () => {
       clearTimeout(this.persistTimer);

package/src/server/domain/workspace-state.js

@@ -0,0 +1,52 @@
+import { isMarkdownFilePath, isVaultFilePath } from '../../domain/file-kind.js';
+
+function compareWorkspacePaths(left = '', right = '') {
+  return String(left).localeCompare(String(right), undefined, { sensitivity: 'base' });
+}
+
+export function collectWorkspaceStateStats(entries = new Map(), metadata = new Map()) {
+  const filePaths = [];
+  const markdownPaths = [];
+  let vaultFileCount = 0;
+
+  entries.forEach((entry, pathValue) => {
+    const entryType = entry?.type ?? entry?.nodeType ?? metadata.get(pathValue)?.type ?? '';
+    if (entryType === 'directory') {
+      return;
+    }
+
+    vaultFileCount += 1;
+    if (isVaultFilePath(pathValue)) {
+      filePaths.push(pathValue);
+    }
+    if (isMarkdownFilePath(pathValue)) {
+      markdownPaths.push(pathValue);
+    }
+  });
+
+  filePaths.sort(compareWorkspacePaths);
+  markdownPaths.sort(compareWorkspacePaths);
+
+  return {
+    filePaths,
+    markdownPaths,
+    vaultFileCount,
+  };
+}
+
+export function createWorkspaceStateSnapshot(entries = new Map(), metadata = new Map(), {
+  scannedAt = Date.now(),
+} = {}) {
+  const normalizedEntries = entries instanceof Map ? entries : new Map(entries ?? []);
+  const normalizedMetadata = metadata instanceof Map ? metadata : new Map(metadata ?? []);
+  const stats = collectWorkspaceStateStats(normalizedEntries, normalizedMetadata);
+
+  return {
+    entries: normalizedEntries,
+    filePaths: stats.filePaths,
+    markdownPaths: stats.markdownPaths,
+    metadata: normalizedMetadata,
+    scannedAt,
+    vaultFileCount: stats.vaultFileCount,
+  };
+}

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

@@ -40,6 +40,7 @@ export function createRequestHandler(
   authService,
   vaultFileStore,
   backlinkIndex,
+  baseQueryService = null,
   docxExporter = null,
   roomRegistry = null,
   plantUmlRenderer = null,
@@ -60,6 +61,7 @@ export function createRequestHandler(
     workspaceMutationCoordinator,
   });
   const handleVaultApi = createVaultApiHandler({
+    baseQueryService,
     backlinkIndex,
     docxExporter,
     plantUmlRenderer,

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

@@ -1,4 +1,5 @@
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
   isMermaidFilePath,
@@ -55,6 +56,10 @@ function selectWriteOperation(vaultFileStore, filePath, content) {
     return vaultFileStore.writeExcalidrawFile(filePath, content);
   }
 
+  if (isBaseFilePath(filePath)) {
+    return vaultFileStore.writeBaseFile(filePath, content);
+  }
+
   if (isDrawioFilePath(filePath)) {
     return vaultFileStore.writeDrawioFile(filePath, content);
   }

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

@@ -3,6 +3,7 @@ import { createVaultApiCommandHandler } from './create-vault-api-command-handler
 import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js';
 
 export function createVaultApiHandler({
+  baseQueryService = null,
   backlinkIndex,
   docxExporter = null,
   plantUmlRenderer = null,
@@ -11,6 +12,7 @@ export function createVaultApiHandler({
   workspaceMutationCoordinator = null,
 }) {
   const handleVaultApiQuery = createVaultApiQueryHandler({
+    baseQueryService,
     backlinkIndex,
     vaultFileStore,
     workspaceMutationCoordinator,

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

@@ -1,13 +1,16 @@
+import archiver from 'archiver';
 import { basename } from 'node:path';
 
 import {
+  isBaseFilePath,
   isDrawioFilePath,
   isExcalidrawFilePath,
   isImageAttachmentFilePath,
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
-import { jsonResponse, sendResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+import { jsonResponse, sendResponse, sendStreamResponse } from './http-response.js';
 
 const SVG_MIME_TYPE = 'image/svg+xml';
 const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; style-src 'unsafe-inline'; sandbox";
@@ -41,11 +44,24 @@ function createAttachmentHeaders(attachment) {
   return headers;
 }
 
+function createDownloadHeaders(fileName, contentType) {
+  return {
+    'Cache-Control': 'no-store',
+    'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
+    'Content-Type': contentType,
+    'X-Content-Type-Options': 'nosniff',
+  };
+}
+
 function selectReadOperation(vaultFileStore, filePath) {
   if (isExcalidrawFilePath(filePath)) {
     return vaultFileStore.readExcalidrawFile(filePath);
   }
 
+  if (isBaseFilePath(filePath)) {
+    return vaultFileStore.readBaseFile(filePath);
+  }
+
   if (isDrawioFilePath(filePath)) {
     return vaultFileStore.readDrawioFile(filePath);
   }
@@ -61,12 +77,112 @@ function selectReadOperation(vaultFileStore, filePath) {
   return vaultFileStore.readMarkdownFile(filePath);
 }
 
+async function streamDirectoryArchive(req, res, {
+  entries = [],
+  rootName = 'archive',
+} = {}) {
+  const archive = archiver('zip', {
+    zlib: {
+      level: 6,
+    },
+  });
+
+  archive.on('warning', (error) => {
+    if (error?.code !== 'ENOENT') {
+      archive.emit('error', error);
+    }
+  });
+
+  const responsePromise = sendStreamResponse(req, res, {
+    headers: createDownloadHeaders(`${rootName}.zip`, 'application/zip'),
+    statusCode: 200,
+    stream: archive,
+  });
+
+  for (const entry of entries) {
+    if (entry.type === 'directory') {
+      const directoryName = entry.path
+        ? `${rootName}/${entry.path}/`
+        : `${rootName}/`;
+      archive.append('', { name: directoryName });
+      continue;
+    }
+
+    archive.file(entry.absolutePath, {
+      name: `${rootName}/${entry.path}`,
+    });
+  }
+
+  await archive.finalize();
+  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;
+    }
+
+    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 ?? '',
+          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;
+    }
+
     if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
       try {
         const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();
@@ -100,6 +216,64 @@ export function createVaultApiQueryHandler({
       return true;
     }
 
+    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;
+      }
+
+      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;
+    }
+
+    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;
+      }
+
+      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;
+    }
+
     if (requestUrl.pathname === '/api/attachment' && req.method === 'GET') {
       const filePath = requestUrl.searchParams.get('path');
       if (!filePath) {