collabmd 0.1.30 → 0.1.32

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

@@ -11,6 +11,7 @@
  */
 
 import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
+import { isMarkdownFilePath } from '../../domain/file-kind.js';
 import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
@@ -43,8 +44,10 @@ export class BacklinkIndex {
     this.reverse = new Map();
     /** @type {Map<string, Map<string, string[]>>} sourcePath → targetPath → contexts[] */
     this.contextsBySource = new Map();
-    /** @type {string[]} cached flat file list for link resolution */
+    /** @type {string[]} cached flat target file list for link resolution */
     this._fileList = [];
+    /** @type {string[]} cached markdown source file list for content scans */
+    this._sourceFileList = [];
     /** @type {Set<string>} file path membership set */
     this._fileSet = new Set();
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
@@ -66,9 +69,11 @@ export class BacklinkIndex {
     return this.flushScheduledBuild();
   }
 
-  scheduleBuild({ delayMs = this.rebuildDelayMs } = {}) {
+  scheduleBuild({ delayMs = this.rebuildDelayMs, workspaceState } = {}) {
     this._requestedBuildVersion += 1;
-    this._latestRequestedWorkspaceState = null;
+    if (workspaceState !== undefined) {
+      this._latestRequestedWorkspaceState = workspaceState;
+    }
     if (!this._scheduledBuildDeferred) {
       this._scheduledBuildDeferred = createDeferred();
     }
@@ -137,12 +142,15 @@ export class BacklinkIndex {
     this.contextsBySource.clear();
 
     const snapshot = workspaceState ?? await this._resolveWorkspaceState();
-    this._fileList = Array.from(snapshot?.markdownPaths ?? []);
+    this._fileList = Array.from(snapshot?.filePaths ?? snapshot?.markdownPaths ?? []);
+    this._sourceFileList = Array.from(
+      snapshot?.markdownPaths ?? this._fileList.filter((filePath) => isMarkdownFilePath(filePath)),
+    ).filter((filePath) => this._fileList.includes(filePath));
     this._fileSet = new Set(this._fileList);
     this._refreshWikiTargetIndex();
 
     const fileContents = await mapWithConcurrency(
-      this._fileList,
+      this._sourceFileList,
       BACKLINK_BUILD_CONCURRENCY,
       async (filePath) => ({
         content: await this.vaultFileStore.readMarkdownFile(filePath),
@@ -157,7 +165,7 @@ export class BacklinkIndex {
     }
 
     this._built = true;
-    console.log(`[backlinks] Index built: ${this._fileList.length} files, ${this.reverse.size} targets with backlinks`);
+    console.log(`[backlinks] Index built: ${this._sourceFileList.length} markdown sources, ${this._fileList.length} targets, ${this.reverse.size} targets with backlinks`);
   }
 
   async _resolveWorkspaceState() {
@@ -166,8 +174,10 @@ export class BacklinkIndex {
     }
 
     const tree = await this.vaultFileStore.tree();
+    const filePaths = flattenTree(tree);
     return {
-      markdownPaths: flattenTree(tree),
+      filePaths,
+      markdownPaths: filePaths.filter((filePath) => isMarkdownFilePath(filePath)),
     };
   }
 
@@ -175,14 +185,20 @@ export class BacklinkIndex {
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.
    */
-  updateFile(filePath, content) {
+  updateFile(filePath, content, { refreshIndex = true } = {}) {
     // Remove old forward links for this file
     this._removeForwardLinks(filePath);
 
     if (!this._fileSet.has(filePath)) {
       this._fileSet.add(filePath);
       this._fileList.push(filePath);
-      this._refreshWikiTargetIndex();
+      if (refreshIndex) {
+        this._refreshWikiTargetIndex();
+      }
+    }
+
+    if (!isMarkdownFilePath(filePath)) {
+      return;
     }
 
     // Re-index with new content
@@ -192,36 +208,47 @@ export class BacklinkIndex {
   /**
    * Handle file creation — add to file list and index its content.
    */
-  onFileCreated(filePath, content = '') {
+  onFileCreated(filePath, content = '', { refreshIndex = true } = {}) {
+    let membershipChanged = false;
     if (!this._fileSet.has(filePath)) {
       this._fileSet.add(filePath);
       this._fileList.push(filePath);
-      this._refreshWikiTargetIndex();
+      membershipChanged = true;
+      if (refreshIndex) {
+        this._refreshWikiTargetIndex();
+      }
     }
 
-    if (content) {
+    if (content && isMarkdownFilePath(filePath)) {
       this._indexFile(filePath, content);
     }
+
+    return membershipChanged;
   }
 
   /**
    * Handle file deletion — remove from file list and all index entries.
    */
-  onFileDeleted(filePath) {
+  onFileDeleted(filePath, { refreshIndex = true } = {}) {
     this._removeForwardLinks(filePath);
+    let membershipChanged = false;
     if (this._fileSet.delete(filePath)) {
       this._fileList = this._fileList.filter((f) => f !== filePath);
-      this._refreshWikiTargetIndex();
+      membershipChanged = true;
+      if (refreshIndex) {
+        this._refreshWikiTargetIndex();
+      }
     }
 
     // Also remove this file as a reverse entry (no one can link to a deleted file)
     this.reverse.delete(filePath);
+    return membershipChanged;
   }
 
   /**
    * Handle file rename — re-map all index entries from oldPath to newPath.
    */
-  onFileRenamed(oldPath, newPath) {
+  onFileRenamed(oldPath, newPath, { refreshIndex = true } = {}) {
     // Move cached contexts for the renamed source file.
     if (this.contextsBySource.has(oldPath)) {
       const sourceContexts = this.contextsBySource.get(oldPath);
@@ -272,9 +299,68 @@ export class BacklinkIndex {
     }
 
     // Update file list
+    let membershipChanged = false;
     if (this._fileSet.delete(oldPath)) {
       this._fileSet.add(newPath);
       this._fileList = this._fileList.map((f) => (f === oldPath ? newPath : f));
+      membershipChanged = true;
+      if (refreshIndex) {
+        this._refreshWikiTargetIndex();
+      }
+    }
+
+    return membershipChanged;
+  }
+
+  async applyWorkspaceChange(workspaceChange = {}, {
+    previousState = null,
+    nextState = null,
+  } = {}) {
+    let refreshIndex = false;
+    const previousEntries = previousState?.entries ?? new Map();
+    const nextEntries = nextState?.entries ?? new Map();
+
+    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+      refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
+    }
+
+    for (const entry of workspaceChange.renamedPaths ?? []) {
+      if (!entry?.oldPath || !entry?.newPath) {
+        continue;
+      }
+      refreshIndex = this.onFileRenamed(entry.oldPath, entry.newPath, { refreshIndex: false }) || refreshIndex;
+    }
+
+    for (const pathValue of new Set(workspaceChange.changedPaths ?? [])) {
+      const existsNow = nextEntries.has(pathValue);
+      const existedBefore = previousEntries.has(pathValue);
+      if (!existsNow) {
+        if (existedBefore) {
+          refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
+        }
+        continue;
+      }
+
+      if (!isMarkdownFilePath(pathValue)) {
+        if (!existedBefore) {
+          refreshIndex = this.onFileCreated(pathValue, '', { refreshIndex: false }) || refreshIndex;
+        }
+        continue;
+      }
+
+      const content = await this.vaultFileStore.readMarkdownFile(pathValue);
+      if (content === null) {
+        continue;
+      }
+
+      if (existedBefore) {
+        this.updateFile(pathValue, content, { refreshIndex: false });
+      } else {
+        refreshIndex = this.onFileCreated(pathValue, content, { refreshIndex: false }) || refreshIndex;
+      }
+    }
+
+    if (refreshIndex) {
       this._refreshWikiTargetIndex();
     }
   }
@@ -398,7 +484,7 @@ export class BacklinkIndex {
 function flattenTree(nodes) {
   const files = [];
   for (const node of nodes) {
-    if (node.type === 'file') {
+    if (node.type && node.type !== 'directory') {
       files.push(node.path);
     } else if (node.children) {
       files.push(...flattenTree(node.children));

package/src/server/domain/bases/base-definition.js

@@ -0,0 +1,255 @@
+import yaml from 'js-yaml';
+
+const SUPPORTED_VIEW_TYPES = new Set(['cards', 'list', 'table']);
+
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+function capitalize(value = '') {
+  const normalized = String(value ?? '').trim();
+  if (!normalized) {
+    return '';
+  }
+
+  return `${normalized.charAt(0).toUpperCase()}${normalized.slice(1)}`;
+}
+
+function normalizeBaseView(rawView, index) {
+  const view = isPlainObject(rawView) ? rawView : {};
+  const type = typeof view.type === 'string' ? view.type : 'table';
+  const name = typeof view.name === 'string' && view.name.trim()
+    ? view.name.trim()
+    : `${capitalize(type)} ${index + 1}`;
+  return {
+    extra: Object.entries(view).reduce((acc, [key, value]) => {
+      if ([
+        'filters',
+        'groupBy',
+        'group_by',
+        'image',
+        'limit',
+        'name',
+        'order',
+        'properties',
+        'sort',
+        'sorts',
+        'summaries',
+        'type',
+      ].includes(key)) {
+        return acc;
+      }
+      acc[key] = value;
+      return acc;
+    }, {}),
+    filters: view.filters ?? null,
+    groupBy: typeof view.groupBy === 'string'
+      ? view.groupBy
+      : (typeof view.group_by === 'string' ? view.group_by : null),
+    id: `view-${index}`,
+    image: typeof view.image === 'string' ? view.image : null,
+    limit: Number.isFinite(Number(view.limit)) ? Math.max(0, Number(view.limit)) : null,
+    name,
+    order: normalizeViewOrder(view.order ?? view.properties),
+    sort: normalizeViewSort(view.sort ?? view.sorts),
+    summaries: normalizeSummaries(view.summaries),
+    supported: SUPPORTED_VIEW_TYPES.has(type),
+    type,
+  };
+}
+
+function normalizeViewOrder(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => {
+        if (typeof entry === 'string') {
+          return entry;
+        }
+        if (isPlainObject(entry)) {
+          return entry.id ?? entry.property ?? entry.name ?? null;
+        }
+        return null;
+      })
+      .filter(Boolean);
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    return [value.trim()];
+  }
+
+  return [];
+}
+
+function normalizeViewSort(value) {
+  if (typeof value === 'string' && value.trim()) {
+    return [{ direction: 'asc', property: value.trim() }];
+  }
+
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((entry) => {
+      if (typeof entry === 'string') {
+        return { direction: 'asc', property: entry };
+      }
+      if (!isPlainObject(entry)) {
+        return null;
+      }
+
+      const property = entry.property ?? entry.id ?? entry.name ?? null;
+      if (typeof property !== 'string' || !property.trim()) {
+        return null;
+      }
+
+      const direction = String(entry.direction ?? entry.order ?? 'asc').toLowerCase() === 'desc'
+        ? 'desc'
+        : 'asc';
+      return { direction, property: property.trim() };
+    })
+    .filter(Boolean);
+}
+
+function normalizeSummaries(value) {
+  if (!value) {
+    return [];
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map((entry, index) => normalizeSummary(entry, index))
+      .filter(Boolean);
+  }
+
+  if (isPlainObject(value)) {
+    const entries = [];
+    Object.entries(value).forEach(([property, propertySummaries]) => {
+      if (Array.isArray(propertySummaries)) {
+        propertySummaries.forEach((entry, index) => {
+          const normalized = normalizeSummary(entry, index, property);
+          if (normalized) {
+            entries.push(normalized);
+          }
+        });
+        return;
+      }
+
+      const normalized = normalizeSummary(propertySummaries, entries.length, property);
+      if (normalized) {
+        entries.push(normalized);
+      }
+    });
+    return entries;
+  }
+
+  return [];
+}
+
+function normalizeSummary(entry, index, property = null) {
+  if (typeof entry === 'string') {
+    return {
+      id: `summary-${index}`,
+      label: capitalize(entry),
+      property,
+      type: entry.toLowerCase(),
+    };
+  }
+
+  if (!isPlainObject(entry)) {
+    return null;
+  }
+
+  const summaryProperty = typeof (entry.property ?? property) === 'string'
+    ? String(entry.property ?? property).trim()
+    : null;
+  const formula = typeof entry.formula === 'string' ? entry.formula : null;
+  const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : (formula ? 'custom' : null);
+  if (!summaryProperty) {
+    return null;
+  }
+
+  return {
+    formula,
+    id: `summary-${index}`,
+    label: typeof entry.name === 'string' ? entry.name : capitalize(type || 'Summary'),
+    property: summaryProperty,
+    type,
+  };
+}
+
+function resolvePropertyLabel(propertyId, definition) {
+  const config = definition.properties[propertyId];
+  if (config?.displayName) {
+    return config.displayName;
+  }
+  return propertyId.startsWith('file.')
+    ? propertyId.slice(5)
+    : propertyId.replace(/^note\./u, '');
+}
+
+export function normalizeBaseDefinition(source = '') {
+  const raw = yaml.load(String(source ?? '')) ?? {};
+  const rawObject = isPlainObject(raw) ? raw : {};
+  const rawProperties = isPlainObject(rawObject.properties) ? rawObject.properties : {};
+  const properties = Object.entries(rawProperties).reduce((acc, [id, config]) => {
+    const normalizedConfig = isPlainObject(config) ? { ...config } : {};
+    acc[id] = {
+      displayName: typeof normalizedConfig.displayName === 'string' ? normalizedConfig.displayName : null,
+      formula: typeof normalizedConfig.formula === 'string' ? normalizedConfig.formula : null,
+      id,
+      raw: normalizedConfig,
+    };
+    return acc;
+  }, {});
+
+  const rawViews = Array.isArray(rawObject.views) ? rawObject.views : [];
+  const views = rawViews.map((rawView, index) => normalizeBaseView(rawView, index));
+  if (views.length === 0) {
+    views.push(normalizeBaseView({ name: 'Table', type: 'table' }, 0));
+  }
+
+  return {
+    filters: rawObject.filters ?? null,
+    properties,
+    raw: rawObject,
+    views,
+  };
+}
+
+export function buildColumns(definition, view) {
+  const order = view.order.length > 0
+    ? view.order
+    : ['file.name', ...Object.keys(definition.properties)];
+  return order.map((propertyId) => ({
+    id: propertyId,
+    label: resolvePropertyLabel(propertyId, definition),
+  }));
+}
+
+export function collectEvaluatedPropertyIds(columns, view) {
+  const propertyIds = new Set(columns.map((column) => column.id));
+
+  if (view.groupBy) {
+    propertyIds.add(view.groupBy);
+  }
+
+  view.sort.forEach((sortConfig) => {
+    if (sortConfig?.property) {
+      propertyIds.add(sortConfig.property);
+    }
+  });
+
+  view.summaries.forEach((summary) => {
+    if (summary?.property) {
+      propertyIds.add(summary.property);
+    }
+  });
+
+  return [...propertyIds];
+}
+
+export function serializeBaseDefinition(definition) {
+  const raw = definition?.raw ?? definition ?? {};
+  return `${yaml.dump(raw, { lineWidth: -1, noRefs: true }).trim()}\n`;
+}