plugin: use sync API for projects/sections/labels

This reduces the number of API calls that we need to do as part of the
metadata refresh

Author: jamiebrynes7

plugin/src/api/domain/label.ts

@@ -4,4 +4,5 @@ export type Label = {
   id: LabelId;
   name: string;
   color: string;
+  isDeleted: boolean;
 };

plugin/src/api/domain/project.ts

@@ -4,7 +4,9 @@ export type Project = {
   id: ProjectId;
   parentId: ProjectId | null;
   name: string;
-  order: number;
+  childOrder: number;
   inboxProject: boolean;
   color: string;
+  isDeleted: boolean;
+  isArchived: boolean;
 };

plugin/src/api/domain/section.ts

@@ -6,5 +6,7 @@ export type Section = {
   id: SectionId;
   projectId: ProjectId;
   name: string;
-  order: number;
+  sectionOrder: number;
+  isDeleted: boolean;
+  isArchived: boolean;
 };

plugin/src/api/domain/sync.ts

@@ -0,0 +1,12 @@
+import type { Label } from "@/api/domain/label";
+import type { Project } from "@/api/domain/project";
+import type { Section } from "@/api/domain/section";
+
+export type SyncResponse = {
+  syncToken: SyncToken;
+  labels: Label[];
+  projects: Project[];
+  sections: Section[];
+};
+
+export type SyncToken = string;

plugin/src/api/index.ts

@@ -1,9 +1,7 @@
 import camelize from "camelize-ts";
 import snakify from "snakify-ts";
 
-import type { Label } from "@/api/domain/label";
-import type { Project } from "@/api/domain/project";
-import type { Section } from "@/api/domain/section";
+import type { SyncResponse, SyncToken } from "@/api/domain/sync";
 import type { CreateTaskParams, Task, TaskId } from "@/api/domain/task";
 import type { UserInfo } from "@/api/domain/user";
 import { type RequestParams, StatusCode, type WebFetcher, type WebResponse } from "@/api/fetcher";
@@ -44,23 +42,20 @@ export class TodoistApiClient {
     await this.do(`/tasks/${id}/close`, "POST", {});
   }
 
-  public async getProjects(): Promise<Project[]> {
-    return await this.doPaginated<Project>("/projects");
-  }
-
-  public async getSections(): Promise<Section[]> {
-    return await this.doPaginated<Section>("/sections");
-  }
-
-  public async getLabels(): Promise<Label[]> {
-    return await this.doPaginated<Label>("/labels");
-  }
-
   public async getUser(): Promise<UserInfo> {
     const response = await this.do("/user", "GET", {});
     return camelize(JSON.parse(response.body)) as UserInfo;
   }
 
+  public async sync(token: SyncToken): Promise<SyncResponse> {
+    const queryParams = snakify({
+      syncToken: token,
+      resourceTypes: JSON.stringify(["projects", "labels", "sections"]),
+    });
+    const response = await this.do("/sync", "POST", { queryParams });
+    return camelize(JSON.parse(response.body)) as SyncResponse;
+  }
+
   private async doPaginated<T>(path: string, params?: Record<string, string>): Promise<T[]> {
     const allResults: T[] = [];
     let cursor: string | null = null;

plugin/src/data/index.ts

@@ -2,6 +2,7 @@ import { type TodoistApiClient, TodoistApiError } from "@/api";
 import type { Label, LabelId } from "@/api/domain/label";
 import type { Project, ProjectId } from "@/api/domain/project";
 import type { Section, SectionId } from "@/api/domain/section";
+import type { SyncToken } from "@/api/domain/sync";
 import type { Task as ApiTask, CreateTaskParams, TaskId } from "@/api/domain/task";
 import type { UserInfo } from "@/api/domain/user";
 import { StatusCode, StatusCodes } from "@/api/fetcher";
@@ -31,12 +32,6 @@ type DataAccessor = {
   labels: RepositoryReader<LabelId, Label>;
 };
 
-class LabelsRepository extends Repository<LabelId, Label> {
-  byName(name: string): Label | undefined {
-    return [...this.iter()].find((label) => label.name === name);
-  }
-}
-
 export class TodoistAdapter {
   public actions = {
     closeTask: async (id: TaskId) => await this.closeTask(id),
@@ -47,18 +42,19 @@ export class TodoistAdapter {
   private readonly api: Maybe<TodoistApiClient> = Maybe.Empty();
   private readonly projects: Repository<ProjectId, Project>;
   private readonly sections: Repository<SectionId, Section>;
-  private readonly labels: LabelsRepository;
+  private readonly labels: Repository<LabelId, Label>;
   private readonly subscriptions: SubscriptionManager<Subscription>;
 
   private readonly tasksPendingClose: TaskId[];
   private userInfo: UserInfo | undefined;
 
   private hasSynced = false;
+  private syncToken: SyncToken = "*";
 
   constructor() {
-    this.projects = new Repository(() => this.api.withInner((api) => api.getProjects()));
-    this.sections = new Repository(() => this.api.withInner((api) => api.getSections()));
-    this.labels = new LabelsRepository(() => this.api.withInner((api) => api.getLabels()));
+    this.projects = new Repository<ProjectId, Project>();
+    this.sections = new Repository<SectionId, Section>();
+    this.labels = new Repository<LabelId, Label>();
     this.subscriptions = new SubscriptionManager<Subscription>();
     this.tasksPendingClose = [];
   }
@@ -81,12 +77,7 @@ export class TodoistAdapter {
       return;
     }
 
-    await Promise.all([
-      this.syncUserInfo(),
-      this.projects.sync(),
-      this.sections.sync(),
-      this.labels.sync(),
-    ]);
+    await Promise.all([this.syncUserInfo(), this.syncMetadata()]);
 
     for (const subscription of this.subscriptions.list()) {
       await subscription.update();
@@ -106,6 +97,23 @@ export class TodoistAdapter {
     }
   }
 
+  private async syncMetadata(): Promise<void> {
+    try {
+      if (!this.api.hasValue()) {
+        return;
+      }
+
+      const response = await this.api.withInner((api) => api.sync(this.syncToken));
+
+      this.projects.applyDiff(response.projects);
+      this.sections.applyDiff(response.sections);
+      this.labels.applyDiff(response.labels);
+      this.syncToken = response.syncToken;
+    } catch (error) {
+      console.error("Failed to sync metadata:", error);
+    }
+  }
+
   public data(): DataAccessor {
     return {
       projects: this.projects,
@@ -191,9 +199,11 @@ const makeUnknownProject = (id: string): Project => {
     id,
     parentId: null,
     name: "Unknown Project",
-    order: Number.MAX_SAFE_INTEGER,
+    childOrder: Number.MAX_SAFE_INTEGER,
     inboxProject: false,
     color: "grey",
+    isDeleted: false,
+    isArchived: false,
   };
 };
 
@@ -202,7 +212,9 @@ const makeUnknownSection = (id: string): Section => {
     id,
     projectId: "unknown-project",
     name: "Unknown Section",
-    order: Number.MAX_SAFE_INTEGER,
+    sectionOrder: Number.MAX_SAFE_INTEGER,
+    isDeleted: false,
+    isArchived: false,
   };
 };
 
@@ -211,6 +223,7 @@ const makeUnknownLabel = (): Label => {
     id: "unknown-label",
     name: "Unknown Label",
     color: "grey",
+    isDeleted: false,
   };
 };
 

plugin/src/data/repository.ts

@@ -1,34 +1,66 @@
-export interface RepositoryReader<T, U extends { id: T }> {
+interface RepositoryItem<Id> {
+  id: Id;
+  name: string;
+  isDeleted: boolean;
+  isArchived?: boolean;
+}
+
+export interface RepositoryReader<T, U> {
   byId(id: T): U | undefined;
+  byName(name: string): U | undefined;
   iter(): IterableIterator<U>;
-}
 
-export class Repository<T, U extends { id: T }> implements RepositoryReader<T, U> {
-  private readonly data: Map<T, U> = new Map();
-  private readonly fetchData: () => Promise<U[]>;
+  iterActive(): IterableIterator<U>;
+}
 
-  constructor(refreshData: () => Promise<U[]>) {
-    this.fetchData = refreshData;
-  }
+export interface RepositoryWriter<U> {
+  applyDiff(changed: U[]): void;
+}
 
-  public async sync(): Promise<void> {
-    try {
-      const items = await this.fetchData();
+export class Repository<T, U extends RepositoryItem<T>>
+  implements RepositoryReader<T, U>, RepositoryWriter<U>
+{
+  private readonly data: Map<T, U> = new Map();
 
-      this.data.clear();
-      for (const elem of items) {
-        this.data.set(elem.id, elem);
+  public applyDiff(changed: U[]): void {
+    for (const item of changed) {
+      if (item.isDeleted) {
+        this.data.delete(item.id);
+        continue;
       }
-    } catch (error: unknown) {
-      console.error(`Failed to update repository: ${error}`);
+      this.data.set(item.id, item);
     }
   }
 
   public byId(id: T): U | undefined {
     return this.data.get(id);
   }
 
+  public byName(name: string): U | undefined {
+    for (const item of this.iter()) {
+      if (item.name === name) {
+        return item;
+      }
+    }
+
+    return undefined;
+  }
+
   public iter(): IterableIterator<U> {
     return this.data.values();
   }
+
+  public *iterActive(): IterableIterator<U> {
+    for (const item of this.iter()) {
+      if (item.isDeleted) {
+        continue;
+      }
+
+      if (item.isArchived ?? false) {
+        continue;
+      }
+
+      yield item;
+    }
+  }
 }

plugin/src/data/transformations/grouping.test.ts

@@ -46,9 +46,11 @@ function makeProject(id: string, opts?: Partial<Project>): Project {
     id,
     parentId: opts?.parentId ?? null,
     name: opts?.name ?? "Project",
-    order: opts?.order ?? 1,
+    childOrder: opts?.childOrder ?? 1,
     inboxProject: false,
     color: "grey",
+    isDeleted: false,
+    isArchived: false,
   };
 }
 
@@ -57,7 +59,9 @@ function makeSection(id: string, projectId: string, opts?: Partial<Section>): Se
     id,
     projectId,
     name: opts?.name ?? "Section",
-    order: opts?.order ?? 1,
+    sectionOrder: opts?.sectionOrder ?? 1,
+    isDeleted: false,
+    isArchived: false,
   };
 }
 
@@ -73,6 +77,7 @@ function makeLabel(name: string): Label {
     id: name,
     name,
     color: "grey",
+    isDeleted: false,
   };
 }
 
@@ -187,8 +192,8 @@ describe("group by priority", () => {
 });
 
 describe("group by project", () => {
-  const projectOne = makeProject("1", { name: "Project One", order: 1 });
-  const projectTwo = makeProject("2", { name: "Project Two", order: 2 });
+  const projectOne = makeProject("1", { name: "Project One", childOrder: 1 });
+  const projectTwo = makeProject("2", { name: "Project Two", childOrder: 2 });
 
   const testcases: TestCase[] = [
     {
@@ -243,14 +248,14 @@ describe("group by project", () => {
 });
 
 describe("group by section", () => {
-  const projectOne = makeProject("1", { name: "Project One", order: 1 });
-  const projectTwo = makeProject("2", { name: "Project Two", order: 2 });
+  const projectOne = makeProject("1", { name: "Project One", childOrder: 1 });
+  const projectTwo = makeProject("2", { name: "Project Two", childOrder: 2 });
 
-  const sectionOne = makeSection("1", "1", { name: "Section One", order: 1 });
-  const sectionTwo = makeSection("1", "2", { name: "Section Two", order: 2 });
+  const sectionOne = makeSection("1", "1", { name: "Section One", sectionOrder: 1 });
+  const sectionTwo = makeSection("1", "2", { name: "Section Two", sectionOrder: 2 });
   const sectionThree = makeSection("2", "3", {
     name: "Section Three",
-    order: 2,
+    sectionOrder: 2,
   });
 
   const testcases: TestCase[] = [

plugin/src/data/transformations/grouping.ts

@@ -56,7 +56,7 @@ function groupByProject(tasks: Task[]): GroupedTasks[] {
   groups.sort((a, b) => {
     const aProject = a[0];
     const bProject = b[0];
-    return aProject.order - bProject.order;
+    return aProject.childOrder - bProject.childOrder;
   });
 
   return groups.map(([project, tasks]) => {
@@ -97,7 +97,7 @@ function groupBySection(tasks: Task[]): GroupedTasks[] {
     const bKey: SectionPartitionKey = JSON.parse(b[0]);
 
     // First compare by project
-    const projectOrderDiff = aKey.project.order - bKey.project.order;
+    const projectOrderDiff = aKey.project.childOrder - bKey.project.childOrder;
     if (projectOrderDiff !== 0) {
       return projectOrderDiff;
     }
@@ -115,7 +115,7 @@ function groupBySection(tasks: Task[]): GroupedTasks[] {
       return 1;
     }
 
-    return aKey.section.order - bKey.section.order;
+    return aKey.section.sectionOrder - bKey.section.sectionOrder;
   });
 
   return groups.map(([key, tasks]) => {

plugin/src/data/transformations/relationships.test.ts

@@ -17,10 +17,12 @@ function makeTask(id: string, opts?: Partial<Task>): Task {
     project: opts?.project ?? {
       id: "foobar",
       name: "Foobar",
-      order: 1,
+      childOrder: 1,
       parentId: null,
       inboxProject: false,
       color: "grey",
+      isDeleted: false,
+      isArchived: false,
     },
     section: opts?.section,