plugin: refactor query schema and parsing

So we are generic over the query schema and we can extend or add new
query schemas

Author: jamiebrynes7

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

@@ -7,7 +7,6 @@ import type { Project } from "@/api/domain/project";
 import type { Section } from "@/api/domain/section";
 import type { Task } from "@/data/task";
 import { type GroupedTasks, groupBy } from "@/data/transformations/grouping";
-import { GroupVariant } from "@/query/query";
 
 vi.mock("../../infra/time.ts", () => {
   return {
@@ -185,7 +184,7 @@ describe("group by priority", () => {
 
   for (const tc of testcases) {
     it(tc.description, () => {
-      const groups = groupBy(tc.input, GroupVariant.Priority);
+      const groups = groupBy(tc.input, "priority");
       expect(groups).toStrictEqual(tc.expected);
     });
   }
@@ -241,7 +240,7 @@ describe("group by project", () => {
 
   for (const tc of testcases) {
     it(tc.description, () => {
-      const groups = groupBy(tc.input, GroupVariant.Project);
+      const groups = groupBy(tc.input, "project");
       expect(groups).toStrictEqual(tc.expected);
     });
   }
@@ -328,7 +327,7 @@ describe("group by section", () => {
 
   for (const tc of testcases) {
     it(tc.description, () => {
-      const groups = groupBy(tc.input, GroupVariant.Section);
+      const groups = groupBy(tc.input, "section");
       expect(groups).toStrictEqual(tc.expected);
     });
   }
@@ -498,7 +497,7 @@ describe("group by date", () => {
 
   for (const tc of testcases) {
     it(tc.description, () => {
-      const groups = groupBy(tc.input, GroupVariant.Date);
+      const groups = groupBy(tc.input, "due");
       expect(groups).toStrictEqual(tc.expected);
     });
   }
@@ -614,7 +613,7 @@ describe("group by label", () => {
 
   for (const tc of testcases) {
     it(tc.description, () => {
-      const groups = groupBy(tc.input, GroupVariant.Label);
+      const groups = groupBy(tc.input, "label");
       expect(groups).toStrictEqual(tc.expected);
     });
   }

plugin/src/data/transformations/grouping.ts

@@ -4,24 +4,24 @@ import type { Priority } from "@/api/domain/task";
 import { DueDate } from "@/data/dueDate";
 import type { Task } from "@/data/task";
 import { t } from "@/i18n";
-import { GroupVariant } from "@/query/query";
+import type { GroupingKey } from "@/query/schema/grouping";
 
 export type GroupedTasks = {
   header: string;
   tasks: Task[];
 };
 
-export function groupBy(tasks: Task[], groupBy: GroupVariant): GroupedTasks[] {
+export function groupBy(tasks: Task[], groupBy: GroupingKey): GroupedTasks[] {
   switch (groupBy) {
-    case GroupVariant.Priority:
+    case "priority":
       return groupByPriority(tasks);
-    case GroupVariant.Project:
+    case "project":
       return groupByProject(tasks);
-    case GroupVariant.Section:
+    case "section":
       return groupBySection(tasks);
-    case GroupVariant.Date:
+    case "due":
       return groupByDate(tasks);
-    case GroupVariant.Label:
+    case "label":
       return groupByLabel(tasks);
     default:
       throw new Error(`Cannot group by ${groupBy}`);

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

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 
 import type { Task } from "@/data/task";
 import { sortTasks } from "@/data/transformations/sorting";
-import { SortingVariant } from "@/query/query";
+import type { SortingKey } from "@/query/schema/sorting";
 
 function makeTask(id: string, opts?: Partial<Task>): Task {
   return {
@@ -35,15 +35,15 @@ describe("sortTasks", () => {
   type Testcase = {
     description: string;
     input: Task[];
-    sortingOpts: SortingVariant[];
+    sortingOpts: SortingKey[];
     expectedOutput: Task[];
   };
 
   const testcases: Testcase[] = [
     {
       description: "should not error for empty input",
       input: [],
-      sortingOpts: [SortingVariant.Priority],
+      sortingOpts: ["priority"],
       expectedOutput: [],
     },
     {
@@ -59,7 +59,7 @@ describe("sortTasks", () => {
           priority: 4,
         }),
       ],
-      sortingOpts: [SortingVariant.Priority],
+      sortingOpts: ["priority"],
       expectedOutput: [
         makeTask("c", {
           priority: 4,
@@ -85,7 +85,7 @@ describe("sortTasks", () => {
           priority: 4,
         }),
       ],
-      sortingOpts: [SortingVariant.PriorityAscending],
+      sortingOpts: ["priorityAscending"],
       expectedOutput: [
         makeTask("b", {
           priority: 1,
@@ -111,7 +111,7 @@ describe("sortTasks", () => {
           order: 1,
         }),
       ],
-      sortingOpts: [SortingVariant.Order],
+      sortingOpts: ["order"],
       expectedOutput: [
         makeTask("c", {
           order: 1,
@@ -153,7 +153,7 @@ describe("sortTasks", () => {
           },
         }),
       ],
-      sortingOpts: [SortingVariant.Date],
+      sortingOpts: ["dateAscending"],
       expectedOutput: [
         makeTask("e", {
           due: {
@@ -211,7 +211,7 @@ describe("sortTasks", () => {
         }),
         makeTask("a"),
       ],
-      sortingOpts: [SortingVariant.DateDescending],
+      sortingOpts: ["dateDescending"],
       expectedOutput: [
         makeTask("a"),
         makeTask("b", {
@@ -253,7 +253,7 @@ describe("sortTasks", () => {
           createdAt: "2020-03-02T12:00:00Z",
         }),
       ],
-      sortingOpts: [SortingVariant.DateAdded],
+      sortingOpts: ["dateAddedAscending"],
       expectedOutput: [
         makeTask("b", {
           createdAt: "2020-03-02T11:00:00Z",
@@ -279,7 +279,7 @@ describe("sortTasks", () => {
           createdAt: "2020-03-02T12:00:00Z",
         }),
       ],
-      sortingOpts: [SortingVariant.DateAddedDescending],
+      sortingOpts: ["dateAddedDescending"],
       expectedOutput: [
         makeTask("b", {
           createdAt: "2020-03-03T13:00:00Z",
@@ -317,7 +317,7 @@ describe("sortTasks", () => {
           },
         }),
       ],
-      sortingOpts: [SortingVariant.Priority, SortingVariant.Date],
+      sortingOpts: ["priority", "dateAscending"],
       expectedOutput: [
         makeTask("c", {
           priority: 3,
@@ -350,7 +350,7 @@ describe("sortTasks", () => {
         makeTask("c", { content: "Banana" }),
         makeTask("d", { content: "cherry" }),
       ],
-      sortingOpts: [SortingVariant.Alphabetical],
+      sortingOpts: ["alphabeticalAscending"],
       expectedOutput: [
         makeTask("b", { content: "apple" }),
         makeTask("c", { content: "Banana" }),
@@ -365,7 +365,7 @@ describe("sortTasks", () => {
         makeTask("b", { content: "Banana" }),
         makeTask("c", { content: "zebra" }),
       ],
-      sortingOpts: [SortingVariant.AlphabeticalDescending],
+      sortingOpts: ["alphabeticalDescending"],
       expectedOutput: [
         makeTask("c", { content: "zebra" }),
         makeTask("b", { content: "Banana" }),
@@ -380,7 +380,7 @@ describe("sortTasks", () => {
         makeTask("c", { content: "Apple" }),
         makeTask("d", { content: "BANANA" }),
       ],
-      sortingOpts: [SortingVariant.Alphabetical],
+      sortingOpts: ["alphabeticalAscending"],
       expectedOutput: [
         makeTask("a", { content: "APPLE" }),
         makeTask("c", { content: "Apple" }),
@@ -396,7 +396,7 @@ describe("sortTasks", () => {
         makeTask("c", { content: "@mention task" }),
         makeTask("d", { content: "#hashtag task" }),
       ],
-      sortingOpts: [SortingVariant.Alphabetical],
+      sortingOpts: ["alphabeticalAscending"],
       expectedOutput: [
         makeTask("c", { content: "@mention task" }),
         makeTask("d", { content: "#hashtag task" }),
@@ -411,7 +411,7 @@ describe("sortTasks", () => {
         makeTask("b", { content: "apple" }),
         makeTask("c", { content: "" }),
       ],
-      sortingOpts: [SortingVariant.Alphabetical],
+      sortingOpts: ["alphabeticalAscending"],
       expectedOutput: [
         makeTask("a", { content: "" }),
         makeTask("c", { content: "" }),
@@ -425,7 +425,7 @@ describe("sortTasks", () => {
         makeTask("b", { content: "Task A", priority: 2 }),
         makeTask("c", { content: "Task C", priority: 3 }),
       ],
-      sortingOpts: [SortingVariant.Priority, SortingVariant.Alphabetical],
+      sortingOpts: ["priority", "alphabeticalAscending"],
       expectedOutput: [
         makeTask("c", { content: "Task C", priority: 3 }),
         makeTask("b", { content: "Task A", priority: 2 }),

plugin/src/data/transformations/sorting.ts

@@ -2,9 +2,9 @@ import { parseAbsoluteToLocal } from "@internationalized/date";
 
 import type { Task } from "@/data//task";
 import { DueDate } from "@/data/dueDate";
-import { SortingVariant } from "@/query/query";
+import type { SortingKey } from "@/query/schema/sorting";
 
-export function sortTasks<T extends Task>(tasks: T[], sort: SortingVariant[]) {
+export function sortTasks<T extends Task>(tasks: T[], sort: SortingKey[]) {
   tasks.sort((first, second) => {
     for (const sorting of sort) {
       const cmp = compareTask(first, second, sorting);
@@ -22,26 +22,26 @@ export function sortTasks<T extends Task>(tasks: T[], sort: SortingVariant[]) {
 // Result of "LT zero" means that self is before other,
 // Result of '0' means that they are equal
 // Result of "GT zero" means that self is after other
-function compareTask<T extends Task>(self: T, other: T, sorting: SortingVariant): number {
+function compareTask<T extends Task>(self: T, other: T, sorting: SortingKey): number {
   switch (sorting) {
-    case SortingVariant.Priority:
+    case "priority":
       // Note that priority in the API is reversed to that of in the app.
       return other.priority - self.priority;
-    case SortingVariant.PriorityAscending:
+    case "priorityAscending":
       return self.priority - other.priority;
-    case SortingVariant.Date:
+    case "dateAscending":
       return compareTaskDate(self, other);
-    case SortingVariant.DateDescending:
+    case "dateDescending":
       return -compareTaskDate(self, other);
-    case SortingVariant.Order:
+    case "order":
       return self.order - other.order;
-    case SortingVariant.DateAdded:
+    case "dateAddedAscending":
       return compareTaskDateAdded(self, other);
-    case SortingVariant.DateAddedDescending:
+    case "dateAddedDescending":
       return -compareTaskDateAdded(self, other);
-    case SortingVariant.Alphabetical:
+    case "alphabeticalAscending":
       return compareTaskAlphabetical(self, other);
-    case SortingVariant.AlphabeticalDescending:
+    case "alphabeticalDescending":
       return -compareTaskAlphabetical(self, other);
     default:
       throw new Error(`Unexpected sorting type: '${sorting}'`);

plugin/src/query/injector.tsx

@@ -8,6 +8,7 @@ import type TodoistPlugin from "@/index";
 import { debug } from "@/log";
 import { parseQuery } from "@/query/parser";
 import { applyReplacements } from "@/query/replacements";
+import { taskQueryDefinition } from "@/query/schema/tasks";
 import {
   type MarkdownEditButton,
   MarkdownEditButtonContext,
@@ -27,7 +28,7 @@ export class QueryInjector {
     let child: MarkdownRenderChild;
 
     try {
-      const [query, warnings] = parseQuery(source);
+      const [query, warnings] = parseQuery(source, taskQueryDefinition);
       applyReplacements(query, ctx);
 
       debug({