Function executeQuery

packages/foam-core/src/query/index.ts:661–727

(
  query: QueryDescriptor,
  workspace: FoamWorkspace,
  graph: FoamGraph,
  options: { trusted: boolean; readSource?: SourceReader }
)

// --- executeQuery ---

export function executeQuery(
  query: QueryDescriptor,
  workspace: FoamWorkspace,
  graph: FoamGraph,
  options: { trusted: boolean; readSource?: SourceReader }
): QueryExecutionResult {
  const { predicate, warnings } = parseFilter(
    query.filter,
    workspace,
    graph,
    options.trusted
  );
  const fields = (query.select ?? DEFAULT_SELECT)
    .map(normalizeSelectEntry)
    .map(e => e.field);

  // Sort + offset + limit before reading source — otherwise a query with
  // `select: [body]` over a broad filter would synchronously read every
  // matched note. Sort keys can't be source-derived so this is safe.
  const cheapFields = fields.filter(f => !requiresSource(f));
  const matched = workspace.list().filter(predicate);

  let slice = matched.map(r =>
    projectResource(r, graph, cheapFields, undefined)
  );

  if (query.sort) {
    const { field, direction } = parseSortDescriptor(query.sort);
    slice = [...slice].sort((a, b) => {
      const cmp = compareValues(a[field], b[field]);
      return direction === 'desc' ? -cmp : cmp;
    });
  }

  const offset = query.offset ?? 0;
  if (offset > 0) {
    slice = slice.slice(offset);
  }
  if (query.limit !== undefined) {
    slice = slice.slice(0, query.limit);
  }

  const sourceFields = fields.filter(requiresSource);
  if (sourceFields.length === 0) {
    return { results: slice, warnings };
  }

  // Map keeps the row→Resource lookup at O(1) per surviving row.
  const byPath = new Map<string, Resource>();
  for (const r of matched) byPath.set(r.uri.path, r);

  const results = slice.map(row => {
    const resource = byPath.get(row.uri.path);
    if (!resource) return row;
    const sourceProjection = projectResource(
      resource,
      graph,
      sourceFields,