test(roam): use tilde imports in utils tests

Author: mdroidian

apps/roam/package.json

@@ -9,7 +9,9 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "publish": "tsx scripts/publish.ts",
-    "check-types": "tsc --noEmit --skipLibCheck"
+    "check-types": "tsc --noEmit --skipLibCheck",
+    "test": "vitest run src/utils/__tests__",
+    "test:watch": "vitest src/utils/__tests__"
   },
   "license": "Apache-2.0",
   "devDependencies": {
@@ -26,7 +28,8 @@
     "dotenv": "^16.0.3",
     "esbuild": "0.17.14",
     "tailwindcss": "^3.4.17",
-    "tsx": "^4.19.2"
+    "tsx": "^4.19.2",
+    "vitest": "^4.0.0"
   },
   "//": "axios dep temporary - need to fix the dep in underlying libraries",
   "tags": [

apps/roam/src/utils/__tests__/datalogUtils.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import compileDatalog, { toVar } from "~/utils/compileDatalog";
+import gatherDatalogVariablesFromClause from "~/utils/gatherDatalogVariablesFromClause";
+import replaceDatalogVariables from "~/utils/replaceDatalogVariables";
+
+describe("compileDatalog", () => {
+  it("sanitizes variable names", () => {
+    expect(toVar('a b"(c)')).toBe("abc");
+  });
+
+  it("compiles nested and-clauses", () => {
+    const query = compileDatalog({
+      type: "and-clause",
+      clauses: [
+        {
+          type: "data-pattern",
+          arguments: [
+            { type: "variable", value: "node" },
+            { type: "constant", value: ":node/title" },
+            { type: "constant", value: '"Hello"' },
+          ],
+        },
+        {
+          type: "pred-expr",
+          pred: "=",
+          arguments: [
+            { type: "variable", value: "node" },
+            { type: "variable", value: "match" },
+          ],
+        },
+      ],
+    });
+
+    expect(query).toContain("(and");
+    expect(query).toContain('[?node :node/title "Hello"]');
+    expect(query).toContain("[(= ?node ?match)]");
+  });
+});
+
+describe("gatherDatalogVariablesFromClause", () => {
+  it("collects variables from nested clauses", () => {
+    const variables = gatherDatalogVariablesFromClause({
+      type: "and-clause",
+      clauses: [
+        {
+          type: "data-pattern",
+          arguments: [
+            { type: "variable", value: "a" },
+            { type: "constant", value: ":rel" },
+            { type: "variable", value: "b" },
+          ],
+        },
+        {
+          type: "or-join-clause",
+          variables: [
+            { type: "variable", value: "c" },
+            { type: "variable", value: "d" },
+          ],
+          clauses: [],
+        },
+      ],
+    });
+
+    expect(Array.from(variables).sort()).toEqual(["a", "b", "c", "d"]);
+  });
+});
+
+describe("replaceDatalogVariables", () => {
+  it("replaces explicit variable names and function bindings", () => {
+    const [clause] = replaceDatalogVariables(
+      [{ from: "node", to: "page" }],
+      [
+        {
+          type: "fn-expr",
+          fn: "identity",
+          arguments: [{ type: "variable", value: "node" }],
+          binding: {
+            type: "bind-scalar",
+            variable: { type: "variable", value: "node" },
+          },
+        },
+      ],
+    );
+
+    expect(clause.type).toBe("fn-expr");
+    if (clause.type !== "fn-expr") return;
+    expect(clause.arguments[0]).toMatchObject({ value: "page" });
+    expect(clause.binding).toMatchObject({
+      variable: { value: "page" },
+    });
+  });
+
+  it("supports transform replacement for all variables", () => {
+    const [clause] = replaceDatalogVariables(
+      [{ from: true, to: (v) => `${v}-v2` }],
+      [
+        {
+          type: "not-join-clause",
+          variables: [{ type: "variable", value: "a" }],
+          clauses: [
+            {
+              type: "data-pattern",
+              arguments: [
+                { type: "variable", value: "a" },
+                { type: "constant", value: ":x" },
+                { type: "variable", value: "b" },
+              ],
+            },
+          ],
+        },
+      ],
+    );
+
+    expect(clause.type).toBe("not-join-clause");
+    if (clause.type !== "not-join-clause") return;
+    expect(clause.variables[0].value).toBe("a-v2");
+    expect(clause.clauses[0]).toMatchObject({
+      arguments: [{ value: "a-v2" }, { value: ":x" }, { value: "b-v2" }],
+    });
+  });
+});

apps/roam/src/utils/__tests__/fireQuery.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("~/utils/conditionToDatalog", () => ({
+  default: vi.fn(({ source, target }) => [
+    {
+      type: "data-pattern",
+      arguments: [
+        { type: "variable", value: source },
+        { type: "constant", value: ":rel" },
+        /^:in /.test(target)
+          ? { type: "variable", value: target.substring(4) }
+          : { type: "constant", value: '"value"' },
+      ],
+    },
+  ]),
+}));
+vi.mock("~/utils/predefinedSelections", () => ({
+  default: [
+    {
+      test: /^created$/,
+      pull: () => "(pull ?node [:create/time])",
+      mapper: (r: Record<string, string>) => r[":create/time"] || "",
+    },
+  ],
+}));
+vi.mock("roamjs-components/util/env", () => ({ getNodeEnv: () => "test" }));
+
+import fireQuery, { fireQuerySync, getDatalogQuery } from "~/utils/fireQuery";
+
+describe("getDatalogQuery", () => {
+  it("includes :in variables and de-duplicates expected inputs", async () => {
+    const built = getDatalogQuery({
+      conditions: [
+        {
+          type: "clause",
+          relation: "r",
+          source: "node",
+          target: ":in title",
+          uid: "1",
+          not: false,
+        },
+        {
+          type: "clause",
+          relation: "r",
+          source: "node",
+          target: ":in title",
+          uid: "2",
+          not: false,
+        },
+      ],
+      selections: [{ uid: "s1", text: "created", label: "Created" }],
+      inputs: { title: "Graph" },
+    });
+
+    expect(built.query).toContain(":in $ ?title");
+    expect(built.inputs).toEqual(["Graph"]);
+    const formatted = await built.formatResult([
+      { ":node/title": "A", ":block/uid": "u1" },
+      { ":block/uid": "u1" },
+      { ":create/time": "123" },
+    ]);
+    expect(formatted).toMatchObject({ text: "A", uid: "u1", Created: "123" });
+  });
+});
+
+describe("fireQuery", () => {
+  beforeEach(() => {
+    (globalThis as { window: unknown }).window = {
+      roamAlphaAPI: {
+        data: {
+          async: {
+            fast: {
+              q: vi
+                .fn()
+                .mockResolvedValue([
+                  [{ ":node/title": "Local", ":block/uid": "l1" }],
+                ]),
+            },
+          },
+          backend: {
+            q: vi
+              .fn()
+              .mockResolvedValue([
+                [{ ":node/title": "Remote", ":block/uid": "r1" }],
+              ]),
+          },
+          fast: {
+            q: vi
+              .fn()
+              .mockReturnValue([
+                [{ ":node/title": "Sync", ":block/uid": "s1" }],
+              ]),
+          },
+        },
+      },
+    };
+  });
+
+  it("uses backend queries by default and maps output", async () => {
+    const results = await fireQuery({ conditions: [], selections: [] });
+    expect(results[0]).toMatchObject({ text: "Remote", uid: "r1" });
+  });
+
+  it("uses async fast query when local=true", async () => {
+    const results = await fireQuery({
+      conditions: [],
+      selections: [],
+      local: true,
+    });
+    expect(results[0]).toMatchObject({ text: "Local", uid: "l1" });
+  });
+
+  it("returns sync mapped results", () => {
+    const results = fireQuerySync({ conditions: [], selections: [] });
+    expect(results).toEqual([{ text: "Sync", uid: "s1" }]);
+  });
+});

apps/roam/src/utils/__tests__/queryParsing.test.ts

@@ -0,0 +1,104 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("roamjs-components/util/getSubTree", () => ({
+  default: vi.fn(),
+}));
+vi.mock("roamjs-components/util/getSettingValueFromTree", () => ({
+  default: vi.fn(
+    ({ tree, key }) =>
+      tree.find((t: { text: string }) => t.text === key)?.children?.[0]?.text ||
+      "",
+  ),
+}));
+vi.mock("roamjs-components/writes/createBlock", () => ({
+  default: vi.fn(),
+}));
+
+import getSubTree from "roamjs-components/util/getSubTree";
+import createBlock from "roamjs-components/writes/createBlock";
+import parseQuery from "~/utils/parseQuery";
+import { getTitleDatalog } from "~/utils/conditionToDatalog";
+
+const mockedGetSubTree = vi.mocked(getSubTree);
+const mockedCreateBlock = vi.mocked(createBlock);
+
+describe("parseQuery", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (globalThis as { window: unknown }).window = {
+      roamAlphaAPI: {
+        util: { generateUID: () => "new-uid" },
+      },
+    };
+  });
+
+  it("parses query nodes and builds default return column", () => {
+    const queryTree = {
+      uid: "parent",
+      children: [
+        { text: "conditions" },
+        { text: "selections" },
+        { text: "custom" },
+      ],
+    };
+    mockedGetSubTree.mockImplementation(({ key }) => {
+      if (key === "conditions") return { uid: "conditions-uid", children: [] };
+      if (key === "selections") {
+        return {
+          uid: "selections-uid",
+          children: [
+            { uid: "sel-node", text: "node", children: [{ text: "Title" }] },
+            {
+              uid: "sel-created",
+              text: "created",
+              children: [{ text: "Created" }],
+            },
+          ],
+        };
+      }
+      return {
+        uid: "custom-uid",
+        children: [{ text: "[:find ?x]" }, { text: "enabled" }],
+      };
+    });
+
+    const parsed = parseQuery(queryTree as never);
+
+    expect(parsed.columns).toEqual([
+      { key: "Title", uid: "returnuid", selection: "node" },
+      { key: "Created", uid: "sel-created", selection: "created" },
+    ]);
+    expect(parsed.isCustomEnabled).toBe(true);
+    expect(parsed.customNode).toBe("[:find ?x]");
+  });
+
+  it("creates missing subtree blocks", () => {
+    const queryTree = { uid: "parent", children: [] };
+    mockedGetSubTree.mockReturnValue({ uid: "", children: [] } as never);
+
+    parseQuery(queryTree as never);
+
+    expect(mockedCreateBlock).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("getTitleDatalog", () => {
+  it("maps :in input target to variable binding", () => {
+    const clauses = getTitleDatalog({ source: "node", target: ":in title" });
+    expect(clauses[0]).toMatchObject({
+      type: "data-pattern",
+      arguments: [
+        { type: "variable", value: "node" },
+        { type: "constant", value: ":node/title" },
+        { type: "variable", value: "title" },
+      ],
+    });
+  });
+
+  it("maps regex target to re-find expression", () => {
+    const clauses = getTitleDatalog({ source: "node", target: "/hello/i" });
+    expect(clauses).toHaveLength(3);
+    expect(clauses[1]).toMatchObject({ type: "fn-expr", fn: "re-pattern" });
+    expect(clauses[2]).toMatchObject({ type: "pred-expr", pred: "re-find" });
+  });
+});