@fungi.computer/inkcap 0.0.0-stage → 0.1.0

package/backend/test/document-marker.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, expect, it } from "vitest";
+import { DatabaseSync } from "node:sqlite";
+import * as Effect from "effect/Effect";
+import { fromNodeSqlite } from "../../../../packages/watchdog/src/node-sqlite.js";
+import { createAppStorage } from "../../../../packages/oyster/src/app-storage.js";
+import {
+  AppStorageError,
+  type AppStorageResult,
+  type AppStorageWire,
+} from "@fungi.computer/agar/storage";
+import { markDocumentsChanged } from "../documents-changed.js";
+import { documentsChangedKey } from "../../src/document-activity-contract.js";
+
+const databases = new Set<DatabaseSync>();
+afterEach(() => {
+  for (const database of databases) database.close();
+  databases.clear();
+});
+
+function storageOwner(): Pick<AppStorageWire, "read" | "write"> {
+  const database = new DatabaseSync(":memory:");
+  databases.add(database);
+  const owner = fromNodeSqlite(database);
+  const storage = createAppStorage({
+    sql: owner.sql,
+    commit: (body) =>
+      Effect.try({
+        try: () => owner.transactionSync(body),
+        catch: (cause) =>
+          cause instanceof Error
+            ? cause
+            : new Error("Storage commit failed", { cause }),
+      }),
+  });
+  const view = storage.open(() =>
+    Effect.succeed({
+      address: "installation:inkcap",
+      appId: "app_inkcap",
+      memberId: "owner",
+      membershipVersion: 1,
+      isOwner: true,
+      keys: [{ key: documentsChangedKey, scopes: ["member"], maxBytes: 2048 }],
+      assertCurrent: () => undefined,
+    }),
+  );
+  const result = <A>(
+    program: Effect.Effect<A, AppStorageError>,
+  ): Promise<AppStorageResult<A>> =>
+    Effect.runPromise(
+      Effect.match(program, {
+        onSuccess: (value) => ({ kind: "accepted" as const, value }),
+        onFailure: (cause) => ({ kind: "rejected" as const, code: cause.code }),
+      }),
+    );
+  return {
+    read: (key) => result(view.read(key)),
+    write: (input) => result(view.write(input)),
+  };
+}
+
+it("updates the same recent-documents marker after an open and every accepted save", async () => {
+  const storage = storageOwner();
+  await markDocumentsChanged(storage, "workspace", 1);
+  await markDocumentsChanged(storage, "workspace", 2);
+  await markDocumentsChanged(storage, "workspace", 3);
+  expect(await storage.read(documentsChangedKey)).toMatchObject({
+    kind: "accepted",
+    value: { member: { value: { computerId: "workspace", sequence: 3 } } },
+  });
+});
+
+it("preserves a competing marker and reports its CAS conflict without retrying", async () => {
+  const owner = storageOwner();
+  await markDocumentsChanged(owner, "workspace", 1);
+  let writes = 0;
+  const storage: Pick<AppStorageWire, "read" | "write"> = {
+    read: async (key) => {
+      const snapshot = await owner.read(key);
+      if (snapshot.kind !== "accepted")
+        throw new AppStorageError(snapshot.code);
+      expect(
+        await owner.write({
+          key,
+          scope: "member",
+          basedOn: snapshot.value.member?.revision ?? null,
+          value: { computerId: "workspace", sequence: 3 },
+        }),
+      ).toMatchObject({ kind: "accepted" });
+      return snapshot;
+    },
+    write: (input) => {
+      writes++;
+      return owner.write(input);
+    },
+  };
+  await expect(
+    markDocumentsChanged(storage, "workspace", 2),
+  ).rejects.toMatchObject({ code: "conflict" });
+  expect(writes).toBe(1);
+  expect(await owner.read(documentsChangedKey)).toMatchObject({
+    kind: "accepted",
+    value: { member: { value: { computerId: "workspace", sequence: 3 } } },
+  });
+});
+
+it("does not attempt a marker write when its live read is refused", async () => {
+  const owner = storageOwner();
+  let writes = 0;
+  await expect(
+    markDocumentsChanged(
+      {
+        read: () =>
+          Promise.resolve({ kind: "rejected", code: "owner_required" }),
+        write: (input) => {
+          writes++;
+          return owner.write(input);
+        },
+      },
+      "workspace",
+      1,
+    ),
+  ).rejects.toMatchObject({ code: "owner_required" });
+  expect(writes).toBe(0);
+  expect(await owner.read(documentsChangedKey)).toMatchObject({
+    kind: "accepted",
+    value: { source: "none", member: null },
+  });
+});

package/backend/test/gills.test.ts

@@ -0,0 +1,156 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { appBackend, type InkcapBackendContext } from "../methods.js";
+import { createDocumentActivityStore } from "../document-activity.js";
+import { documentsRecentSchema } from "../../src/document-activity-contract.js";
+
+it("projects the saved Recent Files source with stable identities and its own cursor without providers", async () => {
+  const db = new DatabaseSync(":memory:");
+  let providerCalls = 0;
+  const unavailable = (): Promise<never> => {
+    providerCalls++;
+    return Promise.reject(new Error("Recent Files must not call a provider"));
+  };
+  const context: InkcapBackendContext = {
+    activity: createDocumentActivityStore({
+      exec(query, ...bindings) {
+        const rows = db
+          .prepare(query)
+          .all(
+            ...bindings.map((value) =>
+              value instanceof ArrayBuffer ? new Uint8Array(value) : value,
+            ),
+          );
+        return { toArray: () => rows };
+      },
+    }),
+    documentsChanged: () => Promise.resolve(),
+    env: {
+      APP_STORAGE: { read: unavailable, write: unavailable },
+      COMPUTER: { read: unavailable },
+    },
+  };
+  const caller = {
+    actor: { kind: "member" as const, memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  try {
+    for (let i = 0; i < 11; i++)
+      await appBackend.call(
+        "documents.opened",
+        { computerId: "computer-a", path: `/notes/file-${String(i)}.md` },
+        context,
+        caller,
+      );
+    const source = documentsRecentSchema.parse(
+      await appBackend.call("documents.recent", { limit: 10 }, context, caller),
+    );
+    const first = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in first) || first.state !== "full")
+      throw new Error("Expected recorded files");
+    expect(first.rows).toHaveLength(10);
+    expect(first.rows.map((row) => row.id)).toEqual(
+      source.rows.map((row) => row.id),
+    );
+    expect(first.rows[0]?.open?.params).toEqual([
+      { key: "path", value: "/notes/file-10.md" },
+    ]);
+    expect(first.next).toBe(JSON.stringify(source.next));
+    const second = await appBackend.gill(
+      {
+        id: "recent-files",
+        params: { computer: "computer-a" },
+        after: first.next,
+      },
+      context,
+      caller,
+    );
+    if (!("rows" in second) || second.state !== "full")
+      throw new Error("Expected the final recorded file");
+    expect(second.rows).toHaveLength(1);
+    expect(second.rows[0]?.open?.params).toEqual([
+      { key: "path", value: "/notes/file-0.md" },
+    ]);
+    expect(second.next).toBeUndefined();
+    const identity = first.rows[0]?.id;
+    await appBackend.call(
+      "documents.edited",
+      { computerId: "computer-a", path: "/notes/file-10.md" },
+      context,
+      caller,
+    );
+    const updated = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in updated) || updated.state !== "full")
+      throw new Error("Expected edited files");
+    expect(updated.rows[0]?.id).toBe(identity);
+    expect(updated.rows[0]?.detail).toContain("Edited");
+    // These paths are accepted metadata from the public recording method, not a filesystem-open proof.
+    for (let i = 0; i < 10; i++)
+      await appBackend.call(
+        "documents.opened",
+        {
+          computerId: "computer-a",
+          path: `/${"界".repeat(4094)}${String(i)}`,
+        },
+        context,
+        caller,
+      );
+    const longPage = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in longPage) || longPage.state !== "full")
+      throw new Error("Expected all saved long-path records");
+    expect(longPage.rows).toHaveLength(10);
+    expect(longPage.rows[0]?.open?.params).toEqual([
+      { key: "path", value: `/${"界".repeat(4094)}9` },
+    ]);
+    expect(longPage.rows[9]?.open?.params).toEqual([
+      { key: "path", value: `/${"界".repeat(4094)}0` },
+    ]);
+    expect(longPage.rows[0]?.title.length).toBeLessThan(4095);
+    expect(
+      new TextEncoder().encode(JSON.stringify(longPage)).byteLength,
+    ).toBeLessThanOrEqual(240 * 1024);
+    expect(providerCalls).toBe(0);
+  } finally {
+    db.close();
+  }
+});
+
+it("keeps missing Computer access distinct from an empty activity page and rejects malformed source cursors", async () => {
+  const { recentFilesGill } = await import("../gills.js");
+  expect(
+    recentFilesGill.rows({ error: "not_granted" }, { params: {} }),
+  ).toMatchObject({
+    state: "error",
+    rows: [],
+    error: "Choose a Computer and allow Inkcap to read its files.",
+    recovery: { kind: "configure", param: "computer" },
+  });
+  expect(
+    recentFilesGill.rows({ rows: [], next: null }, { params: {} }),
+  ).toMatchObject({ state: "empty", rows: [] });
+  expect(recentFilesGill.declaration.watch).toEqual({
+    storage: "documents-recent",
+  });
+  expect(() =>
+    recentFilesGill.input({ params: {}, limit: 10, after: '{"before":0}' }),
+  ).toThrow();
+  expect(() =>
+    recentFilesGill.input({
+      params: {},
+      limit: 10,
+      after: '{"before":1,"computerId":"other"}',
+    }),
+  ).toThrow();
+});