collabmd 0.1.32 → 0.1.34

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -66,8 +66,8 @@ function extractReferences(markdownText = '', wikiTargetIndex) {
   return { embeds, links };
 }
 
-function isWorkspaceFileEntry(entry = {}) {
-  return entry?.nodeType === 'file' || entry?.type !== 'directory';
+function isWorkspaceFileEntry(entry = null) {
+  return Boolean(entry) && (entry.nodeType === 'file' || entry.type !== 'directory');
 }
 
 function listWorkspaceFilePaths(workspaceState = {}) {
@@ -114,6 +114,23 @@ function collectWikiTargetKeysForFilePath(filePath = '') {
   return [...new Set(keys)];
 }
 
+function createBacklinkEntry(sourcePath = '') {
+  return createLinkValue(sourcePath, {
+    display: basename(sourcePath),
+    exists: true,
+  });
+}
+
+function addRawTargetSourceContribution(snapshot, sourcePath, rawTargetKey) {
+  if (!rawTargetKey) {
+    return;
+  }
+
+  const sources = snapshot.rawTargetSourcesByKey.get(rawTargetKey) ?? new Set();
+  sources.add(sourcePath);
+  snapshot.rawTargetSourcesByKey.set(rawTargetKey, sources);
+}
+
 export class BaseIndexSnapshotStore {
   constructor({
     vaultFileStore,
@@ -176,6 +193,11 @@ export class BaseIndexSnapshotStore {
           .map((link) => link?.path)
           .filter((targetPath) => targetPath && targetPath !== filePath),
       ),
+      rawTargetKeys: new Set(
+        references.links
+          .map((link) => normalizeWikiTargetKey(link?.rawTarget))
+          .filter(Boolean),
+      ),
       row: {
         file: fileValue,
         noteProperties,
@@ -185,25 +207,99 @@ export class BaseIndexSnapshotStore {
   }
 
   rebuildBacklinks(snapshot) {
-    const backlinksByTarget = new Map(snapshot.filePaths.map((filePath) => [filePath, []]));
+    snapshot.backlinkSourcesByTarget = new Map();
+    snapshot.backlinksByPath = new Map(snapshot.filePaths.map((filePath) => [filePath, []]));
 
     snapshot.rowsByPath.forEach((row, filePath) => {
       const forwardLinks = snapshot.forwardLinksByPath.get(filePath) ?? new Set();
       forwardLinks.forEach((targetPath) => {
-        if (!backlinksByTarget.has(targetPath) || targetPath === row.file.path) {
+        if (!snapshot.rowsByPath.has(targetPath) || targetPath === row.file.path) {
           return;
         }
 
-        backlinksByTarget.get(targetPath).push(createLinkValue(row.file.path, {
-          display: basename(row.file.path),
-          exists: true,
-        }));
+        const sources = snapshot.backlinkSourcesByTarget.get(targetPath) ?? new Set();
+        sources.add(filePath);
+        snapshot.backlinkSourcesByTarget.set(targetPath, sources);
       });
     });
 
-    snapshot.backlinksByPath = backlinksByTarget;
-    snapshot.rowsByPath.forEach((row, filePath) => {
-      row.file.backlinks = dedupeLinkValues(backlinksByTarget.get(filePath) ?? []);
+    this.refreshSerializedBacklinks(snapshot, snapshot.filePaths);
+  }
+
+  removeSourceBacklinkContributions(snapshot, sourcePath, affectedTargetPaths = new Set()) {
+    const forwardLinks = snapshot.forwardLinksByPath.get(sourcePath) ?? new Set();
+    forwardLinks.forEach((targetPath) => {
+      const sources = snapshot.backlinkSourcesByTarget.get(targetPath);
+      if (!sources) {
+        return;
+      }
+
+      sources.delete(sourcePath);
+      if (sources.size === 0) {
+        snapshot.backlinkSourcesByTarget.delete(targetPath);
+      }
+      affectedTargetPaths.add(targetPath);
+    });
+  }
+
+  removeRawTargetSourceContributions(snapshot, sourcePath) {
+    const rawTargetKeys = snapshot.rawTargetKeysBySourcePath.get(sourcePath) ?? new Set();
+    rawTargetKeys.forEach((rawTargetKey) => {
+      const sources = snapshot.rawTargetSourcesByKey.get(rawTargetKey);
+      if (!sources) {
+        return;
+      }
+
+      sources.delete(sourcePath);
+      if (sources.size === 0) {
+        snapshot.rawTargetSourcesByKey.delete(rawTargetKey);
+      }
+    });
+    snapshot.rawTargetKeysBySourcePath.delete(sourcePath);
+  }
+
+  addRawTargetSourceContributions(snapshot, sourcePath, rawTargetKeys = new Set()) {
+    snapshot.rawTargetKeysBySourcePath.set(sourcePath, rawTargetKeys);
+    rawTargetKeys.forEach((rawTargetKey) => {
+      addRawTargetSourceContribution(snapshot, sourcePath, rawTargetKey);
+    });
+  }
+
+  addSourceBacklinkContributions(snapshot, sourcePath, affectedTargetPaths = new Set()) {
+    if (!snapshot.rowsByPath.has(sourcePath)) {
+      return;
+    }
+
+    const forwardLinks = snapshot.forwardLinksByPath.get(sourcePath) ?? new Set();
+    forwardLinks.forEach((targetPath) => {
+      if (!snapshot.rowsByPath.has(targetPath) || targetPath === sourcePath) {
+        return;
+      }
+
+      const sources = snapshot.backlinkSourcesByTarget.get(targetPath) ?? new Set();
+      sources.add(sourcePath);
+      snapshot.backlinkSourcesByTarget.set(targetPath, sources);
+      affectedTargetPaths.add(targetPath);
+    });
+  }
+
+  refreshSerializedBacklinks(snapshot, targetPaths = []) {
+    Array.from(new Set(targetPaths)).forEach((targetPath) => {
+      if (!snapshot.rowsByPath.has(targetPath)) {
+        snapshot.backlinkSourcesByTarget.delete(targetPath);
+        snapshot.backlinksByPath.delete(targetPath);
+        return;
+      }
+
+      const sources = snapshot.backlinkSourcesByTarget.get(targetPath) ?? new Set();
+      const backlinks = dedupeLinkValues(
+        Array.from(sources, (sourcePath) => createBacklinkEntry(sourcePath)),
+      );
+      snapshot.backlinksByPath.set(targetPath, backlinks);
+      const row = snapshot.rowsByPath.get(targetPath);
+      if (row?.file) {
+        row.file.backlinks = backlinks;
+      }
     });
   }
 
@@ -219,17 +315,28 @@ export class BaseIndexSnapshotStore {
 
     const rowsByPath = new Map();
     const forwardLinksByPath = new Map();
+    const rawTargetKeysBySourcePath = new Map();
+    const rawTargetSourcesByKey = new Map();
     fileEntries.forEach((filePath) => {
       const markdownContent = markdownContents.get(filePath) ?? null;
       const rowRecord = this.createSnapshotRow(filePath, resolvedWorkspaceState, wikiTargetIndex, markdownContent);
       rowsByPath.set(filePath, rowRecord.row);
       forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
+      rawTargetKeysBySourcePath.set(filePath, rowRecord.rawTargetKeys);
+      rowRecord.rawTargetKeys.forEach((rawTargetKey) => {
+        addRawTargetSourceContribution({
+          rawTargetSourcesByKey,
+        }, filePath, rawTargetKey);
+      });
     });
 
     const snapshot = {
+      backlinkSourcesByTarget: new Map(),
       backlinksByPath: new Map(),
       filePaths: fileEntries,
       forwardLinksByPath,
+      rawTargetKeysBySourcePath,
+      rawTargetSourcesByKey,
       rowsByPath,
       scannedAt: resolvedWorkspaceState.scannedAt,
       wikiTargetIndex,
@@ -246,8 +353,10 @@ export class BaseIndexSnapshotStore {
   }
 
   removeSnapshotPath(snapshot, filePath) {
+    this.removeRawTargetSourceContributions(snapshot, filePath);
     snapshot.rowsByPath.delete(filePath);
     snapshot.forwardLinksByPath.delete(filePath);
+    snapshot.backlinkSourcesByTarget.delete(filePath);
     snapshot.backlinksByPath.delete(filePath);
     snapshot.filePaths = snapshot.filePaths.filter((candidatePath) => candidatePath !== filePath);
   }
@@ -274,13 +383,12 @@ export class BaseIndexSnapshotStore {
     }
 
     const impactedPaths = new Set();
-    snapshot.rowsByPath.forEach((row, filePath) => {
-      const links = row?.file?.links ?? [];
-      if (links.some((link) => affectedTargetKeys.has(normalizeWikiTargetKey(link?.rawTarget)))) {
+    affectedTargetKeys.forEach((targetKey) => {
+      const sourcePaths = snapshot.rawTargetSourcesByKey.get(targetKey);
+      sourcePaths?.forEach((filePath) => {
         impactedPaths.add(filePath);
-      }
+      });
     });
-
     return impactedPaths;
   }
 
@@ -296,8 +404,10 @@ export class BaseIndexSnapshotStore {
         ? await this.vaultFileStore.readMarkdownFile(filePath)
         : null;
       const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent);
+      this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
+      this.addRawTargetSourceContributions(snapshot, filePath, rowRecord.rawTargetKeys);
     });
   }
 
@@ -377,6 +487,8 @@ export class BaseIndexSnapshotStore {
     }
 
     const snapshot = this.indexSnapshot;
+    const affectedTargetPaths = new Set();
+    const affectedSourcePaths = new Set(markdownPathsToRefresh);
     if (membershipChanged) {
       const membershipAffectedPaths = [
         ...deletedFilePaths,
@@ -385,6 +497,33 @@ export class BaseIndexSnapshotStore {
         ...renamedFileEntries.flatMap((entry) => [entry.oldPath, entry.newPath]),
       ];
       const impactedSourcePaths = this.collectImpactedSourcesForMembershipChanges(snapshot, membershipAffectedPaths);
+      impactedSourcePaths.forEach((pathValue) => affectedSourcePaths.add(pathValue));
+      [...deletedFilePaths, ...removedChangedFilePaths].forEach((pathValue) => {
+        if (isMarkdownFilePath(pathValue)) {
+          affectedSourcePaths.add(pathValue);
+        }
+        affectedTargetPaths.add(pathValue);
+      });
+      renamedFileEntries.forEach((entry) => {
+        if (isMarkdownFilePath(entry.oldPath)) {
+          affectedSourcePaths.add(entry.oldPath);
+        }
+        if (isMarkdownFilePath(entry.newPath)) {
+          affectedSourcePaths.add(entry.newPath);
+        }
+        affectedTargetPaths.add(entry.oldPath);
+        affectedTargetPaths.add(entry.newPath);
+      });
+      createdFilePaths.forEach((pathValue) => {
+        if (isMarkdownFilePath(pathValue)) {
+          affectedSourcePaths.add(pathValue);
+        }
+        affectedTargetPaths.add(pathValue);
+      });
+
+      affectedSourcePaths.forEach((pathValue) => {
+        this.removeSourceBacklinkContributions(snapshot, pathValue, affectedTargetPaths);
+      });
 
       [...deletedFilePaths, ...removedChangedFilePaths].forEach((pathValue) => {
         this.removeSnapshotPath(snapshot, pathValue);
@@ -401,18 +540,26 @@ export class BaseIndexSnapshotStore {
 
       snapshot.wikiTargetIndex = createWikiTargetIndex(snapshot.filePaths);
       await this.refreshSnapshotRows(snapshot, nextState, [
-        ...markdownPathsToRefresh,
         ...createdFilePaths,
         ...renamedFileEntries.map((entry) => entry.newPath),
-        ...impactedSourcePaths,
+        ...affectedSourcePaths,
       ]);
     } else {
-      await this.refreshSnapshotRows(snapshot, nextState, markdownPathsToRefresh);
+      affectedSourcePaths.forEach((pathValue) => {
+        this.removeSourceBacklinkContributions(snapshot, pathValue, affectedTargetPaths);
+      });
+      await this.refreshSnapshotRows(snapshot, nextState, [...affectedSourcePaths]);
     }
 
+    affectedSourcePaths.forEach((pathValue) => {
+      this.addSourceBacklinkContributions(snapshot, pathValue, affectedTargetPaths);
+    });
     snapshot.workspaceState = nextState;
     snapshot.scannedAt = nextState?.scannedAt ?? snapshot.scannedAt;
-    this.rebuildBacklinks(snapshot);
+    this.refreshSerializedBacklinks(snapshot, [
+      ...snapshot.filePaths.filter((filePath) => !snapshot.backlinksByPath.has(filePath)),
+      ...affectedTargetPaths,
+    ]);
     return snapshot;
   }
 }

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

@@ -0,0 +1,242 @@
+import { isImageAttachmentFilePath } from '../../../domain/file-kind.js';
+import { parseDateValue, toDisplayText } from './base-expression-runtime.js';
+
+const FILE_PROPERTY_DEFINITIONS = [
+  { id: 'file.name', kind: 'file', label: 'file name', valueType: 'text' },
+  { id: 'file.basename', kind: 'file', label: 'file base name', valueType: 'text' },
+  { id: 'file.backlinks', kind: 'file', label: 'file backlinks', valueType: 'list' },
+  { id: 'file.ctime', kind: 'file', label: 'created time', valueType: 'date' },
+  { id: 'file.embeds', kind: 'file', label: 'file embeds', valueType: 'list' },
+  { id: 'file.ext', kind: 'file', label: 'file extension', valueType: 'text' },
+  { id: 'file.folder', kind: 'file', label: 'folder', valueType: 'text' },
+  { id: 'file.links', kind: 'file', label: 'file links', valueType: 'list' },
+  { id: 'file.mtime', kind: 'file', label: 'modified time', valueType: 'date' },
+  { id: 'file.path', kind: 'file', label: 'file path', valueType: 'text' },
+  { id: 'file.size', kind: 'file', label: 'file size', valueType: 'number' },
+  { id: 'file.tags', kind: 'file', label: 'file tags', valueType: 'list' },
+];
+
+function simplifyType(type) {
+  if (!type || type === 'unknown') {
+    return 'unknown';
+  }
+
+  return type;
+}
+
+function mergeTypes(left = 'unknown', right = 'unknown') {
+  if (left === 'unknown') {
+    return right;
+  }
+  if (right === 'unknown' || left === right) {
+    return left;
+  }
+
+  const scalarTypes = new Set(['boolean', 'date', 'number', 'text', 'image', 'link']);
+  if (scalarTypes.has(left) && scalarTypes.has(right)) {
+    if ((left === 'image' && right === 'text') || (left === 'text' && right === 'image')) {
+      return 'image';
+    }
+    if ((left === 'link' && right === 'text') || (left === 'text' && right === 'link')) {
+      return 'link';
+    }
+    return 'text';
+  }
+
+  if (left === 'list' || right === 'list') {
+    return 'list';
+  }
+
+  return 'unknown';
+}
+
+export function inferValueType(value) {
+  if (value == null || value === '') {
+    return 'unknown';
+  }
+
+  if (Array.isArray(value)) {
+    return 'list';
+  }
+
+  if (value instanceof Date) {
+    return 'date';
+  }
+
+  if (value?.__baseType === 'link') {
+    return 'link';
+  }
+
+  if (value?.__baseType === 'file') {
+    return 'link';
+  }
+
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+
+  if (typeof value === 'number') {
+    return 'number';
+  }
+
+  if (typeof value === 'string') {
+    if (isImageAttachmentFilePath(value)) {
+      return 'image';
+    }
+
+    if (parseDateValue(value)) {
+      return 'date';
+    }
+
+    return 'text';
+  }
+
+  return 'unknown';
+}
+
+function createSortDirections(valueType = 'text') {
+  switch (valueType) {
+    case 'date':
+      return [
+        { id: 'asc', label: 'Old to new' },
+        { id: 'desc', label: 'New to old' },
+      ];
+    case 'number':
+      return [
+        { id: 'asc', label: '0 → 1' },
+        { id: 'desc', label: '1 → 0' },
+      ];
+    default:
+      return [
+        { id: 'asc', label: 'A → Z' },
+        { id: 'desc', label: 'Z → A' },
+      ];
+  }
+}
+
+function createFilterOperators(valueType = 'text') {
+  if (valueType === 'boolean') {
+    return ['is', 'is not', 'is empty', 'is not empty'];
+  }
+
+  if (valueType === 'number' || valueType === 'date') {
+    return ['is', 'is not', '>', '>=', '<', '<=', 'is empty', 'is not empty'];
+  }
+
+  if (valueType === 'list') {
+    return ['contains', 'does not contain', 'is empty', 'is not empty'];
+  }
+
+  return ['is', 'is not', 'contains', 'does not contain', 'starts with', 'ends with', 'is empty', 'is not empty'];
+}
+
+export function createPropertyCatalogSnapshot(snapshot) {
+  const noteProperties = new Map();
+
+  snapshot?.rowsByPath?.forEach((row) => {
+    Object.entries(row?.noteProperties ?? {}).forEach(([propertyName, value]) => {
+      const propertyId = `note.${propertyName}`;
+      const current = noteProperties.get(propertyId) ?? {
+        id: propertyId,
+        kind: 'note',
+        label: propertyName,
+        valueType: 'unknown',
+      };
+      current.valueType = mergeTypes(current.valueType, inferValueType(value));
+      noteProperties.set(propertyId, current);
+    });
+  });
+
+  return {
+    fileProperties: FILE_PROPERTY_DEFINITIONS.map((entry) => ({ ...entry })),
+    noteProperties: Array.from(noteProperties.values()).sort((left, right) => left.label.localeCompare(right.label)),
+    scannedAt: snapshot?.scannedAt ?? '',
+  };
+}
+
+export function buildAvailableProperties({
+  activeView,
+  columns = [],
+  definition,
+  formulaValueTypes = {},
+  propertyCatalog,
+}) {
+  const visibleIds = new Set(
+    Array.isArray(activeView?.order) && activeView.order.length > 0
+      ? activeView.order
+      : columns.map((column) => column.id),
+  );
+  const baseProperties = [
+    ...(propertyCatalog?.fileProperties ?? []),
+    ...(propertyCatalog?.noteProperties ?? []),
+  ];
+
+  const formulaProperties = Object.values(definition?.formulas ?? {}).map((formula) => ({
+    id: formula.id,
+    kind: 'formula',
+    label: definition?.properties?.[formula.id]?.displayName ?? formula.name,
+    valueType: simplifyType(formulaValueTypes[formula.id] ?? 'unknown'),
+  }));
+
+  return [...baseProperties, ...formulaProperties]
+    .map((property) => {
+      const valueType = simplifyType(property.valueType);
+      return {
+        filterOperators: createFilterOperators(valueType),
+        groupable: true,
+        id: property.id,
+        kind: property.kind,
+        label: property.label,
+        sortable: true,
+        sortDirections: createSortDirections(valueType),
+        valueType,
+        visible: visibleIds.has(property.id),
+      };
+    })
+    .sort((left, right) => left.label.localeCompare(right.label));
+}
+
+function flattenValues(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => flattenValues(entry));
+  }
+
+  if (value == null || value === '') {
+    return [];
+  }
+
+  return [value];
+}
+
+export function collectDistinctPropertyValues(rows = [], propertyId = '', query = '') {
+  const counts = new Map();
+  const normalizedQuery = String(query ?? '').trim().toLowerCase();
+
+  rows.forEach((row) => {
+    flattenValues(row?.rawCells?.[propertyId]).forEach((value) => {
+      const text = toDisplayText(value);
+      if (!text) {
+        return;
+      }
+
+      if (normalizedQuery && !text.toLowerCase().includes(normalizedQuery)) {
+        return;
+      }
+
+      const entry = counts.get(text) ?? {
+        count: 0,
+        text,
+        value,
+      };
+      entry.count += 1;
+      counts.set(text, entry);
+    });
+  });
+
+  return Array.from(counts.values())
+    .sort((left, right) => (
+      right.count - left.count
+      || left.text.localeCompare(right.text)
+    ))
+    .slice(0, 100);
+}

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

@@ -123,10 +123,10 @@ export function rowMatchesSearch(row, columns, query) {
     return true;
   }
 
-  const haystack = [
-    row.file.path,
-    ...columns.map((column) => toDisplayText(row.rawCells[column.id])),
-  ].join('\n').toLowerCase();
+  const haystack = columns
+    .map((column) => toDisplayText(row.rawCells[column.id]))
+    .join('\n')
+    .toLowerCase();
   return haystack.includes(normalizedQuery);
 }
 
@@ -134,18 +134,20 @@ export function buildQueryResultPayload({
   activeView,
   columns,
   definition,
+  includeCsv = false,
   rows,
   snapshot,
   thisFile,
 }) {
   const groupsByKey = new Map();
-  if (activeView.groupBy) {
+  if (activeView.groupBy?.property) {
     rows.forEach((row) => {
-      const groupValue = row.rawCells[activeView.groupBy];
+      const groupValue = row.rawCells[activeView.groupBy.property];
       const groupKey = toDisplayText(groupValue) || 'Empty';
       const entry = groupsByKey.get(groupKey) ?? {
         key: groupKey,
         label: groupKey,
+        rawValue: groupValue,
         rows: [],
         value: serializeBaseValue(groupValue, {
           rowFilePath: row.file.path,
@@ -183,7 +185,15 @@ export function buildQueryResultPayload({
   }));
   const rowsByPath = new Map(serializedRows.map((row) => [row.path, row]));
 
-  const groups = Array.from(groupsByKey.values()).map((group) => ({
+  let groups = Array.from(groupsByKey.values());
+  if (activeView.groupBy?.explicitDirection) {
+    groups = groups.sort((left, right) => {
+      const delta = compareValues(left.rawValue, right.rawValue);
+      return activeView.groupBy.direction === 'desc' ? -delta : delta;
+    });
+  }
+
+  groups = groups.map((group) => ({
     key: group.key,
     label: group.label,
     summaries: createSummaryPayload(columns, group.rows, activeView.summaries, definition, snapshot, thisFile),
@@ -192,7 +202,7 @@ export function buildQueryResultPayload({
   }));
 
   return {
-    csv: createCsv(rows, columns),
+    ...(includeCsv ? { csv: createCsv(rows, columns) } : {}),
     groups,
     rows: serializedRows,
     summaries: createSummaryPayload(columns, rows, activeView.summaries, definition, snapshot, thisFile),