collabmd 0.1.31 → 0.1.33

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

@@ -11,7 +11,7 @@
  */
 
 import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
-import { isMarkdownFilePath } from '../../domain/file-kind.js';
+import { getVaultFileExtension, isMarkdownFilePath } from '../../domain/file-kind.js';
 import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
@@ -27,6 +27,39 @@ function createDeferred() {
   return { promise, reject, resolve };
 }
 
+function normalizeWikiTargetKey(target = '') {
+  const normalizedTarget = String(target ?? '').trim();
+  if (!normalizedTarget) {
+    return '';
+  }
+
+  return getVaultFileExtension(normalizedTarget)
+    ? normalizedTarget
+    : `${normalizedTarget}.md`;
+}
+
+function collectWikiTargetKeysForFilePath(filePath = '') {
+  const normalizedPath = String(filePath ?? '').trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const keys = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    keys.push(segments.slice(index).join('/'));
+  }
+
+  if (isMarkdownFilePath(normalizedPath)) {
+    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
+    for (let index = 0; index < rawSegments.length; index += 1) {
+      keys.push(rawSegments.slice(index).join('/'));
+    }
+  }
+
+  return [...new Set(keys)];
+}
+
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -44,6 +77,10 @@ export class BacklinkIndex {
     this.reverse = new Map();
     /** @type {Map<string, Map<string, string[]>>} sourcePath → targetPath → contexts[] */
     this.contextsBySource = new Map();
+    /** @type {Map<string, Set<string>>} sourcePath → normalized raw target keys */
+    this.rawTargetKeysBySource = new Map();
+    /** @type {Map<string, Set<string>>} normalized raw target key → source paths */
+    this.rawTargetSources = new Map();
     /** @type {string[]} cached flat target file list for link resolution */
     this._fileList = [];
     /** @type {string[]} cached markdown source file list for content scans */
@@ -140,13 +177,16 @@ export class BacklinkIndex {
     this.forward.clear();
     this.reverse.clear();
     this.contextsBySource.clear();
+    this.rawTargetKeysBySource.clear();
+    this.rawTargetSources.clear();
 
     const snapshot = workspaceState ?? await this._resolveWorkspaceState();
     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._sourceFileList = Array.from(
+      snapshot?.markdownPaths
+        ?? this._fileList.filter((filePath) => isMarkdownFilePath(filePath)),
+    ).filter((filePath) => this._fileSet.has(filePath));
     this._refreshWikiTargetIndex();
 
     const fileContents = await mapWithConcurrency(
@@ -256,6 +296,21 @@ export class BacklinkIndex {
       this.contextsBySource.set(newPath, sourceContexts);
     }
 
+    if (this.rawTargetKeysBySource.has(oldPath)) {
+      const rawTargetKeys = this.rawTargetKeysBySource.get(oldPath);
+      this.rawTargetKeysBySource.delete(oldPath);
+      this.rawTargetKeysBySource.set(newPath, rawTargetKeys);
+      rawTargetKeys.forEach((rawTargetKey) => {
+        const sources = this.rawTargetSources.get(rawTargetKey);
+        if (!sources) {
+          return;
+        }
+
+        sources.delete(oldPath);
+        sources.add(newPath);
+      });
+    }
+
     // Move forward links
     const oldForward = this.forward.get(oldPath);
     if (oldForward) {
@@ -319,6 +374,25 @@ export class BacklinkIndex {
     let refreshIndex = false;
     const previousEntries = previousState?.entries ?? new Map();
     const nextEntries = nextState?.entries ?? new Map();
+    const changedPaths = Array.from(new Set(workspaceChange.changedPaths ?? []));
+    const createdPaths = changedPaths.filter((pathValue) => (
+      nextEntries.has(pathValue) && !previousEntries.has(pathValue)
+    ));
+    const removedChangedPaths = changedPaths.filter((pathValue) => (
+      !nextEntries.has(pathValue) && previousEntries.has(pathValue)
+    ));
+    const membershipAffectedPaths = [
+      ...(workspaceChange.deletedPaths ?? []),
+      ...removedChangedPaths,
+      ...createdPaths,
+      ...(workspaceChange.renamedPaths ?? []).flatMap((entry) => [entry?.oldPath, entry?.newPath]).filter(Boolean),
+    ];
+    const impactedSources = this._collectImpactedSourcesForMembershipChanges(membershipAffectedPaths);
+    const renameMap = new Map(
+      (workspaceChange.renamedPaths ?? [])
+        .filter((entry) => entry?.oldPath && entry?.newPath)
+        .map((entry) => [entry.oldPath, entry.newPath]),
+    );
 
     for (const pathValue of workspaceChange.deletedPaths ?? []) {
       refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
@@ -331,7 +405,7 @@ export class BacklinkIndex {
       refreshIndex = this.onFileRenamed(entry.oldPath, entry.newPath, { refreshIndex: false }) || refreshIndex;
     }
 
-    for (const pathValue of new Set(workspaceChange.changedPaths ?? [])) {
+    for (const pathValue of changedPaths) {
       const existsNow = nextEntries.has(pathValue);
       const existedBefore = previousEntries.has(pathValue);
       if (!existsNow) {
@@ -361,7 +435,23 @@ export class BacklinkIndex {
     }
 
     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,
+      });
     }
   }
 
@@ -408,6 +498,7 @@ export class BacklinkIndex {
   _indexFile(filePath, content) {
     const resolvedTargets = new Set();
     const contextsByTarget = new Map();
+    const rawTargetKeys = new Set();
     const lines = content.split('\n');
 
     for (const line of lines) {
@@ -419,6 +510,11 @@ export class BacklinkIndex {
           continue;
         }
 
+        const rawTargetKey = normalizeWikiTargetKey(target);
+        if (rawTargetKey) {
+          rawTargetKeys.add(rawTargetKey);
+        }
+
         const resolved = this._resolveTarget(target);
         if (!resolved || resolved === filePath) {
           continue;
@@ -434,6 +530,17 @@ export class BacklinkIndex {
     }
 
     this.contextsBySource.delete(filePath);
+    this._removeRawTargetSourceContributions(filePath);
+
+    if (rawTargetKeys.size > 0) {
+      this.rawTargetKeysBySource.set(filePath, rawTargetKeys);
+      rawTargetKeys.forEach((rawTargetKey) => {
+        if (!this.rawTargetSources.has(rawTargetKey)) {
+          this.rawTargetSources.set(rawTargetKey, new Set());
+        }
+        this.rawTargetSources.get(rawTargetKey).add(filePath);
+      });
+    }
 
     if (resolvedTargets.size > 0) {
       this.contextsBySource.set(filePath, contextsByTarget);
@@ -450,6 +557,7 @@ export class BacklinkIndex {
 
   _removeForwardLinks(filePath) {
     this.contextsBySource.delete(filePath);
+    this._removeRawTargetSourceContributions(filePath);
 
     const oldTargets = this.forward.get(filePath);
     if (!oldTargets) return;
@@ -478,6 +586,70 @@ export class BacklinkIndex {
   _refreshWikiTargetIndex() {
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
   }
+
+  _removeRawTargetSourceContributions(filePath) {
+    const rawTargetKeys = this.rawTargetKeysBySource.get(filePath);
+    if (!rawTargetKeys) {
+      return;
+    }
+
+    rawTargetKeys.forEach((rawTargetKey) => {
+      const sources = this.rawTargetSources.get(rawTargetKey);
+      if (!sources) {
+        return;
+      }
+
+      sources.delete(filePath);
+      if (sources.size === 0) {
+        this.rawTargetSources.delete(rawTargetKey);
+      }
+    });
+    this.rawTargetKeysBySource.delete(filePath);
+  }
+
+  _collectImpactedSourcesForMembershipChanges(pathValues = []) {
+    const affectedTargetKeys = new Set();
+    pathValues.forEach((pathValue) => {
+      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+        affectedTargetKeys.add(targetKey);
+      });
+    });
+
+    const impactedSources = new Set();
+    affectedTargetKeys.forEach((targetKey) => {
+      this.rawTargetSources.get(targetKey)?.forEach((sourcePath) => {
+        impactedSources.add(sourcePath);
+      });
+    });
+    return impactedSources;
+  }
+
+  async _refreshImpactedSources(impactedSources = new Set(), {
+    nextEntries = new Map(),
+    renameMap = new Map(),
+  } = {}) {
+    const refreshedSources = new Set();
+
+    for (const sourcePath of impactedSources) {
+      const livePath = renameMap.get(sourcePath) ?? sourcePath;
+      if (
+        refreshedSources.has(livePath)
+        || !livePath
+        || !isMarkdownFilePath(livePath)
+        || !nextEntries.has(livePath)
+      ) {
+        continue;
+      }
+
+      const content = await this.vaultFileStore.readMarkdownFile(livePath);
+      if (content === null) {
+        continue;
+      }
+
+      refreshedSources.add(livePath);
+      this.updateFile(livePath, content, { refreshIndex: false });
+    }
+  }
 }
 
 /** Flatten a vault tree into an array of file paths. */

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

@@ -0,0 +1,382 @@
+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 normalizeDirection(value, fallback = 'asc') {
+  return String(value ?? fallback).toLowerCase() === 'desc' ? 'desc' : 'asc';
+}
+
+function normalizeFormulaPropertyId(value = '') {
+  const normalized = String(value ?? '').trim();
+  if (!normalized) {
+    return '';
+  }
+
+  return normalized.startsWith('formula.')
+    ? normalized
+    : `formula.${normalized}`;
+}
+
+function bareFormulaName(value = '') {
+  return normalizeFormulaPropertyId(value).replace(/^formula\./u, '');
+}
+
+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: normalizeViewGroupBy(view.groupBy ?? view.group_by),
+    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 normalizeViewGroupBy(value) {
+  if (typeof value === 'string' && value.trim()) {
+    return {
+      direction: 'asc',
+      explicitDirection: false,
+      property: value.trim(),
+    };
+  }
+
+  if (!isPlainObject(value)) {
+    return null;
+  }
+
+  const property = value.property ?? value.id ?? value.name ?? null;
+  if (typeof property !== 'string' || !property.trim()) {
+    return null;
+  }
+
+  return {
+    direction: normalizeDirection(value.direction ?? value.order, 'asc'),
+    explicitDirection: Object.hasOwn(value, 'direction') || Object.hasOwn(value, 'order'),
+    property: property.trim(),
+  };
+}
+
+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 = normalizeDirection(entry.direction ?? entry.order, '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;
+  }
+
+  if (propertyId.startsWith('formula.')) {
+    return bareFormulaName(propertyId);
+  }
+
+  return propertyId.startsWith('file.')
+    ? propertyId.slice(5)
+    : propertyId.replace(/^note\./u, '');
+}
+
+function normalizeFormulaEntries(rawFormulas, rawProperties) {
+  const formulas = {};
+  const appendFormula = (propertyId, formula, { legacy = false } = {}) => {
+    const normalizedId = normalizeFormulaPropertyId(propertyId);
+    if (!normalizedId || typeof formula !== 'string') {
+      return;
+    }
+
+    formulas[normalizedId] = {
+      formula,
+      id: normalizedId,
+      legacy,
+      name: bareFormulaName(normalizedId),
+    };
+  };
+
+  if (isPlainObject(rawFormulas)) {
+    Object.entries(rawFormulas).forEach(([name, formula]) => {
+      appendFormula(name, formula);
+    });
+  }
+
+  Object.entries(rawProperties).forEach(([id, config]) => {
+    if (typeof config?.formula === 'string') {
+      appendFormula(id, config.formula, { legacy: true });
+    }
+  });
+
+  return formulas;
+}
+
+function createFormulaLookup(formulas = {}) {
+  const lookup = new Map();
+
+  Object.keys(formulas).forEach((propertyId) => {
+    const bareName = bareFormulaName(propertyId);
+    if (bareName) {
+      lookup.set(bareName, propertyId);
+    }
+    lookup.set(propertyId, propertyId);
+  });
+
+  return lookup;
+}
+
+export function normalizeBaseDefinition(source = '') {
+  const raw = yaml.load(String(source ?? '')) ?? {};
+  const rawObject = isPlainObject(raw) ? raw : {};
+  const rawProperties = isPlainObject(rawObject.properties) ? rawObject.properties : {};
+  const formulas = normalizeFormulaEntries(rawObject.formulas, rawProperties);
+  const properties = Object.entries(rawProperties).reduce((acc, [id, config]) => {
+    const normalizedConfig = isPlainObject(config) ? { ...config } : {};
+    acc[id] = {
+      displayName: typeof normalizedConfig.displayName === 'string' ? normalizedConfig.displayName : 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,
+    formulas,
+    formulaLookup: createFormulaLookup(formulas),
+    properties,
+    raw: rawObject,
+    views,
+  };
+}
+
+export function buildColumns(definition, view) {
+  const order = view.order.length > 0
+    ? view.order
+    : ['file.name', ...new Set([
+      ...Object.keys(definition.properties),
+      ...Object.keys(definition.formulas),
+    ])];
+  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?.property) {
+    propertyIds.add(view.groupBy.property);
+  }
+
+  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 findView(definition, requestedView = '') {
+  return definition.views.find((entry) => entry.name === requestedView || entry.id === requestedView) ?? definition.views[0];
+}
+
+export function normalizeRawDefinitionForWrite(definition) {
+  const rawDefinition = isPlainObject(definition?.raw)
+    ? structuredClone(definition.raw)
+    : structuredClone(isPlainObject(definition) ? definition : {});
+  const rawProperties = isPlainObject(rawDefinition.properties) ? rawDefinition.properties : {};
+  const formulas = isPlainObject(rawDefinition.formulas)
+    ? { ...rawDefinition.formulas }
+    : {};
+
+  Object.entries(rawProperties).forEach(([propertyId, config]) => {
+    if (!isPlainObject(config) || typeof config.formula !== 'string') {
+      return;
+    }
+
+    formulas[bareFormulaName(propertyId)] = config.formula;
+    delete config.formula;
+  });
+
+  rawDefinition.properties = rawProperties;
+  if (Object.keys(formulas).length > 0) {
+    rawDefinition.formulas = formulas;
+  } else {
+    delete rawDefinition.formulas;
+  }
+
+  return rawDefinition;
+}
+
+export function serializeBaseDefinition(definition) {
+  const raw = normalizeRawDefinitionForWrite(definition);
+  return `${yaml.dump(raw, { lineWidth: -1, noRefs: true }).trim()}\n`;
+}