collabmd 0.1.31 → 0.1.33

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

@@ -0,0 +1,215 @@
+import {
+  compareValues,
+  createEvaluationRootContext,
+  evaluateExpression,
+  serializeBaseValue,
+  toDisplayText,
+  valuesEqual,
+} from './base-expression-runtime.js';
+
+function summarizeValues(values = [], summary, definition, snapshot, thisFile) {
+  const meaningfulValues = values.filter((value) => value != null && value !== '');
+  switch (summary.type) {
+    case 'average': {
+      const numbers = meaningfulValues.map(Number).filter(Number.isFinite);
+      return numbers.length > 0 ? numbers.reduce((sum, value) => sum + value, 0) / numbers.length : null;
+    }
+    case 'checked':
+      return values.filter(Boolean).length;
+    case 'custom': {
+      const context = createEvaluationRootContext({
+        astCache: new Map(),
+        currentRow: {
+          file: thisFile,
+          noteProperties: thisFile?.properties ?? {},
+        },
+        definition,
+        identifierResolver: (name) => (name === 'values' ? values : undefined),
+        snapshot,
+        thisFile,
+      });
+      return evaluateExpression(summary.formula, context);
+    }
+    case 'earliest':
+      return meaningfulValues.reduce((acc, value) => (acc == null || compareValues(value, acc) < 0 ? value : acc), null);
+    case 'empty':
+      return values.filter((value) => value == null || value === '').length;
+    case 'filled':
+      return meaningfulValues.length;
+    case 'latest':
+      return meaningfulValues.reduce((acc, value) => (acc == null || compareValues(value, acc) > 0 ? value : acc), null);
+    case 'max':
+      return meaningfulValues.reduce((acc, value) => (acc == null || compareValues(value, acc) > 0 ? value : acc), null);
+    case 'median': {
+      const numbers = meaningfulValues.map(Number).filter(Number.isFinite).sort((left, right) => left - right);
+      if (numbers.length === 0) return null;
+      const middle = Math.floor(numbers.length / 2);
+      return numbers.length % 2 === 0 ? (numbers[middle - 1] + numbers[middle]) / 2 : numbers[middle];
+    }
+    case 'min':
+      return meaningfulValues.reduce((acc, value) => (acc == null || compareValues(value, acc) < 0 ? value : acc), null);
+    case 'range': {
+      const sorted = meaningfulValues.slice().sort(compareValues);
+      if (sorted.length === 0) return null;
+      const first = sorted[0];
+      const last = sorted[sorted.length - 1];
+      if (first instanceof Date && last instanceof Date) {
+        return last.getTime() - first.getTime();
+      }
+      return Number(last ?? 0) - Number(first ?? 0);
+    }
+    case 'stddev': {
+      const numbers = meaningfulValues.map(Number).filter(Number.isFinite);
+      if (numbers.length === 0) return null;
+      const average = numbers.reduce((sum, value) => sum + value, 0) / numbers.length;
+      const variance = numbers.reduce((sum, value) => sum + ((value - average) ** 2), 0) / numbers.length;
+      return Math.sqrt(variance);
+    }
+    case 'sum':
+      return meaningfulValues.map(Number).filter(Number.isFinite).reduce((sum, value) => sum + value, 0);
+    case 'unchecked':
+      return values.filter((value) => value === false || value == null).length;
+    case 'unique': {
+      const uniqueValues = [];
+      meaningfulValues.forEach((value) => {
+        if (!uniqueValues.some((entry) => valuesEqual(entry, value))) {
+          uniqueValues.push(value);
+        }
+      });
+      return uniqueValues.length;
+    }
+    default:
+      return null;
+  }
+}
+
+function createSummaryPayload(columns, rows, summaries, definition, snapshot, thisFile) {
+  return summaries.map((summary) => {
+    const column = columns.find((entry) => entry.id === summary.property);
+    const values = rows.map((row) => row.rawCells[summary.property]);
+    const value = summarizeValues(values, summary, definition, snapshot, thisFile);
+    return {
+      id: summary.id,
+      label: summary.label,
+      property: summary.property,
+      propertyLabel: column?.label ?? summary.property,
+      value: serializeBaseValue(value, {
+        snapshot,
+        sourcePath: thisFile?.path ?? '',
+      }),
+    };
+  });
+}
+
+function createCsv(rows, columns) {
+  const escapeCell = (value) => {
+    const text = String(value ?? '');
+    if (/[,"\n]/u.test(text)) {
+      return `"${text.replace(/"/g, '""')}"`;
+    }
+    return text;
+  };
+
+  const lines = [
+    columns.map((column) => escapeCell(column.label)).join(','),
+    ...rows.map((row) => columns.map((column) => escapeCell(toDisplayText(row.rawCells[column.id]))).join(',')),
+  ];
+  return `${lines.join('\n')}\n`;
+}
+
+export function rowMatchesSearch(row, columns, query) {
+  const normalizedQuery = String(query ?? '').trim().toLowerCase();
+  if (!normalizedQuery) {
+    return true;
+  }
+
+  const haystack = columns
+    .map((column) => toDisplayText(row.rawCells[column.id]))
+    .join('\n')
+    .toLowerCase();
+  return haystack.includes(normalizedQuery);
+}
+
+export function buildQueryResultPayload({
+  activeView,
+  columns,
+  definition,
+  includeCsv = false,
+  rows,
+  snapshot,
+  thisFile,
+}) {
+  const groupsByKey = new Map();
+  if (activeView.groupBy?.property) {
+    rows.forEach((row) => {
+      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,
+          snapshot,
+          sourcePath: thisFile?.path ?? '',
+        }),
+      };
+      entry.rows.push(row);
+      groupsByKey.set(groupKey, entry);
+    });
+  } else {
+    groupsByKey.set('All', {
+      key: 'All',
+      label: 'All',
+      rows,
+      value: serializeBaseValue(null),
+    });
+  }
+
+  const serializedRows = rows.map((row) => ({
+    cells: columns.reduce((acc, column) => {
+      acc[column.id] = serializeBaseValue(row.rawCells[column.id], {
+        rowFilePath: row.file.path,
+        snapshot,
+        sourcePath: thisFile?.path ?? '',
+      });
+      return acc;
+    }, {}),
+    file: serializeBaseValue(row.file, {
+      rowFilePath: row.file.path,
+      snapshot,
+      sourcePath: thisFile?.path ?? '',
+    }),
+    path: row.file.path,
+  }));
+  const rowsByPath = new Map(serializedRows.map((row) => [row.path, row]));
+
+  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),
+    value: group.value,
+    rows: group.rows.map((row) => rowsByPath.get(row.file.path)),
+  }));
+
+  return {
+    ...(includeCsv ? { csv: createCsv(rows, columns) } : {}),
+    groups,
+    rows: serializedRows,
+    summaries: createSummaryPayload(columns, rows, activeView.summaries, definition, snapshot, thisFile),
+    thisFile: serializeBaseValue(thisFile, {
+      snapshot,
+      sourcePath: thisFile?.path ?? '',
+    }),
+    totalRows: rows.length,
+  };
+}