perf: cache dataview lookups to speed up queries

Author: ivan-lednev

src/main.ts

@@ -77,7 +77,10 @@ export default class DayPlanner extends Plugin {
   private store!: AppStore;
 
   async onload() {
-    this.dataviewFacade = new DataviewFacade(() => getAPI(this.app));
+    this.dataviewFacade = new DataviewFacade(
+      () => getAPI(this.app),
+      this.app.vault,
+    );
     const initialPluginData: PluginData = {
       ...defaultSettings,
       ...(await this.loadData()),

src/service/dataview-facade.ts

@@ -1,37 +1,78 @@
+import { partition } from "lodash/fp";
+import type { Vault } from "obsidian";
 import { STask, type DataviewApi } from "obsidian-dataview";
 
 import {
   type Scheduler,
   createBackgroundBatchScheduler,
 } from "../util/scheduler";
+import { isNotVoid } from "typed-assert";
+
+interface STaskCacheEntry {
+  mtime: number;
+  tasks: STask[];
+}
 
 export class DataviewFacade {
   private readonly scheduler: Scheduler<STask[]> =
     createBackgroundBatchScheduler({
       timeRemainingLowerLimit: 5,
     });
+  private readonly taskCache = new Map<string, STaskCacheEntry>();
+
+  constructor(
+    private readonly getDataview: () => DataviewApi | undefined,
+    private readonly vault: Vault,
+  ) {}
+
+  private isCached = (path: string) => {
+    const cacheForPath = this.taskCache.get(path);
+
+    if (!cacheForPath) {
+      return false;
+    }
 
-  constructor(private readonly getDataview: () => DataviewApi | undefined) {}
+    const fileInVault = this.vault.getFileByPath(path);
+
+    isNotVoid(fileInVault);
+
+    return cacheForPath.mtime === fileInVault.stat.mtime;
+  };
 
   getAllTasksFrom = async (source: string) => {
-    return new Promise<STask[]>((resolve) => {
-      const paths: string[] = this.getDataview()?.pagePaths(source).array();
+    const pathsForSource: string[] = this.getDataview()
+      ?.pagePaths(source)
+      .array();
 
-      const pageQueries: Array<() => STask[]> = paths.map(
-        (path) => () =>
-          this.getDataview()?.page(path)?.file.tasks.array() || [],
-      );
+    const [pathsWithValidCache, pathsToBeQueried] = partition(
+      this.isCached,
+      pathsForSource,
+    );
 
+    const cachedTasks = pathsWithValidCache.map(
+      (it) => this.taskCache.get(it)?.tasks || [],
+    );
+
+    const pageQueries: Array<() => STask[]> = pathsToBeQueried.map(
+      (path) => () => {
+        const tasks = this.getDataview()?.page(path)?.file.tasks.array() || [];
+        const mtime = this.vault.getFileByPath(path)?.stat.mtime;
+
+        if (mtime && tasks.length > 0) {
+          this.taskCache.set(path, { mtime, tasks });
+        }
+
+        return tasks;
+      },
+    );
+
+    return new Promise<STask[]>((resolve) => {
       this.scheduler.enqueueTasks(pageQueries, (results) => {
-        resolve(results.flat());
+        resolve(results.concat(cachedTasks).flat());
       });
     });
   };
 
-  getPathsFrom = (source: string) => {
-    return this.getDataview()?.pages(source).file.path.array() || [];
-  };
-
   getAllListsFrom = (source: string) => {
     return this.getDataview()?.pages(source).file.lists.array() || [];
   };

tests/store/redux.test.ts

@@ -10,20 +10,23 @@ import {
 import { makeStore } from "../../src/redux/store";
 import { DataviewFacade } from "../../src/service/dataview-facade";
 import { createSTask } from "../../src/util/dataview";
+import type { Vault } from "obsidian";
 
 export async function getIcalFixture(file: string) {
   return readFile(`fixtures/${file}.txt`, {
     encoding: "utf8",
   });
 }
 
+export class FakeVault {}
+
 export class FakeDataviewFacade extends DataviewFacade {
   private readonly fixtures: Record<string, Array<STask>>;
 
   constructor() {
     super(() => {
       throw new Error("Incorrect usage");
-    });
+    }, new FakeVault() as Vault);
 
     // this.fixtures = readFileSync(`${fixturesPath}/dataview-fixtures.json`);
     this.fixtures = {};
@@ -32,10 +35,6 @@ export class FakeDataviewFacade extends DataviewFacade {
   getTasksFromPath = (path: string) => {
     return this.fixtures[path];
   };
-
-  getPathsFrom = (source: string) => {
-    return Object.keys(this.fixtures);
-  };
 }
 
 describe("Search", () => {