@graffiti-garden/wrapper-synchronize 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import Ajv from "ajv-draft-04";
+import { Graffiti } from "@graffiti-garden/api";
+import type { GraffitiSession, GraffitiObject, JSONSchema4, GraffitiStream } from "@graffiti-garden/api";
+import type { GraffitiObjectBase } from "@graffiti-garden/api";
+export type * from "@graffiti-garden/api";
+export type GraffitiSynchronizeCallback = (oldObject: GraffitiObjectBase, newObject?: GraffitiObjectBase) => void;
+/**
+ * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
+ * so that changes made or received in one part of an application
+ * are automatically routed to other parts of the application.
+ * This is an important tool for building responsive
+ * and consistent user interfaces, and is built upon to make
+ * the [Graffiti Vue Plugin](https://vue.graffiti.garden/variables/GraffitiPlugin.html)
+ * and possibly other front-end libraries in the future.
+ *
+ * Specifically, it provides the following *synchronize*
+ * methods for each of the following API methods:
+ *
+ * | API Method | Synchronize Method |
+ * |------------|--------------------|
+ * | {@link get} | {@link synchronizeGet} |
+ * | {@link discover} | {@link synchronizeDiscover} |
+ * | {@link recoverOrphans} | {@link synchronizeRecoverOrphans} |
+ *
+ * Whenever a change is made via {@link put}, {@link patch}, and {@link delete} or
+ * received from {@link get}, {@link discover}, and {@link recoverOrphans},
+ * those changes are forwarded to the appropriate synchronize method.
+ * Each synchronize method returns an iterator that streams these changes
+ * continually until the user calls `return` on the iterator or `break`s out of the loop,
+ * allowing for live updates without additional polling.
+ *
+ * Example 1: Suppose a user publishes a post using {@link put}. If the feed
+ * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,
+ * then the user's new post will instantly appear in their feed, giving the UI a
+ * responsive feel.
+ *
+ * Example 2: Suppose one of a user's friends changes their name. As soon as the
+ * user's application receives one notice of that change (using {@link get}
+ * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update
+ * all instance's of that friend's name in the user's application instantly,
+ * providing a consistent user experience.
+ *
+ * @groupDescription Synchronize Methods
+ * This group contains methods that listen for changes made via
+ * {@link put}, {@link patch}, and {@link delete} or fetched from
+ * {@link get}, {@link discover}, and {@link recoverOrphans} and then
+ * streams appropriate changes to provide a responsive and consistent user experience.
+ */
+export declare class GraffitiSynchronize extends Graffiti {
+    protected readonly ajv: Ajv;
+    protected readonly graffiti: Graffiti;
+    protected readonly callbacks: Set<GraffitiSynchronizeCallback>;
+    channelStats: Graffiti["channelStats"];
+    locationToUri: Graffiti["locationToUri"];
+    uriToLocation: Graffiti["uriToLocation"];
+    login: Graffiti["login"];
+    logout: Graffiti["logout"];
+    sessionEvents: Graffiti["sessionEvents"];
+    /**
+     * Wraps a Graffiti API instance to provide the synchronize methods.
+     * The GraffitiSyncrhonize class rather than the Graffiti class
+     * must be used for all functions for the synchronize methods to work.
+     */
+    constructor(
+    /**
+     * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
+     * instance to wrap.
+     */
+    graffiti: Graffiti, 
+    /**
+     * An optional instance of Ajv to use for validating
+     * objects before dispatching them to listeners.
+     * If not provided, a new instance of Ajv will be created.
+     */
+    ajv?: Ajv);
+    protected synchronize<Schema extends JSONSchema4>(matchObject: (object: GraffitiObjectBase) => boolean, channels: string[], schema: Schema, session?: GraffitiSession | null): GraffitiStream<GraffitiObject<Schema>>;
+    /**
+     * This method has the same signature as {@link discover} but listens for
+     * changes made via {@link put}, {@link patch}, and {@link delete} or
+     * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}
+     * and then streams appropriate changes to provide a responsive and
+     * consistent user experience.
+     *
+     * Unlike {@link discover}, this method continuously listens for changes
+     * and will not terminate unless the user calls the `return` method on the iterator
+     * or `break`s out of the loop.
+     *
+     * @group Synchronize Methods
+     */
+    synchronizeDiscover<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.discover<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    /**
+     * This method has the same signature as {@link get} but
+     * listens for changes made via {@link put}, {@link patch}, and {@link delete} or
+     * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then
+     * streams appropriate changes to provide a responsive and consistent user experience.
+     *
+     * Unlike {@link get}, which returns a single result, this method continuously
+     * listens for changes which are output as an asynchronous {@link GraffitiStream}.
+     *
+     * @group Synchronize Methods
+     */
+    synchronizeGet<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.get<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    /**
+     * This method has the same signature as {@link recoverOrphans} but
+     * listens for changes made via
+     * {@link put}, {@link patch}, and {@link delete} or fetched from
+     * {@link get}, {@link discover}, and {@link recoverOrphans} and then
+     * streams appropriate changes to provide a responsive and consistent user experience.
+     *
+     * Unlike {@link recoverOrphans}, this method continuously listens for changes
+     * and will not terminate unless the user calls the `return` method on the iterator
+     * or `break`s out of the loop.
+     *
+     * @group Synchronize Methods
+     */
+    synchronizeRecoverOrphans<Schema extends JSONSchema4>(...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>): GraffitiStream<GraffitiObject<Schema>>;
+    protected synchronizeDispatch(oldObject: GraffitiObjectBase, newObject?: GraffitiObjectBase, waitForListeners?: boolean): Promise<void>;
+    get: Graffiti["get"];
+    put: Graffiti["put"];
+    patch: Graffiti["patch"];
+    delete: Graffiti["delete"];
+    protected objectStream<Schema extends JSONSchema4>(iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>): AsyncGenerator<{
+        error: Error;
+        source: string;
+    } | {
+        error?: undefined;
+        value: GraffitiObject<Schema>;
+    }, {
+        tombstoneRetention: number;
+    }, unknown>;
+    discover: Graffiti["discover"];
+    recoverOrphans: Graffiti["recoverOrphans"];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@graffiti-garden/wrapper-synchronize",
+  "version": "0.0.1",
+  "description": "TBD",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.js",
+  "browser": "./dist/index.browser.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --coverage",
+    "build:types": "tsc --declaration --emitDeclarationOnly",
+    "build:js": "tsx esbuild.config.mts",
+    "build:docs": "typedoc --options typedoc.json",
+    "build": "rm -rf dist && npm run build:types && npm run build:js && npm run build:docs",
+    "prepublishOnly": "npm update && npm test && npm run build"
+  },
+  "files": [
+    "src",
+    "dist",
+    "tests",
+    "package.json",
+    "README.md"
+  ],
+  "author": "Theia Henderson",
+  "license": "GPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graffiti-garden/wrapper-synchronize.git"
+  },
+  "bugs": {
+    "url": "https://github.com/graffiti-garden/wrapper-synchronize/issues"
+  },
+  "homepage": "https://sync.graffiti.garden/classes/GraffitiSynchronize.html",
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "tsx": "^4.19.2",
+    "typedoc": "^0.27.6",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.9"
+  },
+  "dependencies": {
+    "@graffiti-garden/api": "^0.3.0",
+    "@graffiti-garden/implementation-local": "^0.2.12",
+    "@repeaterjs/repeater": "^3.0.6",
+    "ajv": "^8.17.1",
+    "ajv-draft-04": "^1.0.0",
+    "fast-json-patch": "^3.1.1"
+  }
+}

package/src/index.spec.ts

@@ -0,0 +1,408 @@
+import { it, expect, describe, assert, beforeAll } from "vitest";
+import type { GraffitiSession } from "@graffiti-garden/api";
+import { GraffitiLocal } from "@graffiti-garden/implementation-local";
+import { randomPutObject, randomString } from "@graffiti-garden/api/tests";
+
+const useGraffiti = () => new GraffitiLocal();
+const graffiti = useGraffiti();
+
+const useSession1 = async () => {
+  return {
+    actor: randomString(),
+  };
+};
+const useSession2 = async () => {
+  return {
+    actor: randomString(),
+  };
+};
+
+describe.concurrent("synchronizeDiscover", () => {
+  let session: GraffitiSession;
+  let session1: GraffitiSession;
+  let session2: GraffitiSession;
+  beforeAll(async () => {
+    session1 = await useSession1();
+    session = session1;
+    session2 = await useSession2();
+  });
+
+  it("get", async () => {
+    const graffiti1 = useGraffiti();
+
+    const object = randomPutObject();
+    const channels = object.channels.slice(1);
+    const putted = await graffiti1.put(object, session);
+
+    const graffiti2 = useGraffiti();
+    const next = graffiti2.synchronizeDiscover(channels, {}).next();
+    const gotten = await graffiti2.get(putted, {}, session);
+
+    const result = (await next).value;
+    if (!result || result.error) {
+      throw new Error("Error in synchronize");
+    }
+    expect(result.value.value).toEqual(object.value);
+    expect(result.value.channels).toEqual(channels);
+    expect(result.value.tombstone).toBe(false);
+    expect(result.value.lastModified).toEqual(gotten.lastModified);
+  });
+
+  it("put", async () => {
+    const beforeChannel = randomString();
+    const afterChannel = randomString();
+    const sharedChannel = randomString();
+
+    const oldValue = { hello: "world" };
+    const oldChannels = [beforeChannel, sharedChannel];
+    const putted = await graffiti.put(
+      {
+        value: oldValue,
+        channels: oldChannels,
+      },
+      session,
+    );
+
+    // Start listening for changes...
+    const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+    const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
+    const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
+
+    // Replace the object
+    const newValue = { goodbye: "world" };
+    const newChannels = [afterChannel, sharedChannel];
+    await graffiti.put(
+      {
+        ...putted,
+        value: newValue,
+        channels: newChannels,
+      },
+      session,
+    );
+
+    const beforeResult = (await before).value;
+    const afterResult = (await after).value;
+    const sharedResult = (await shared).value;
+    if (
+      !beforeResult ||
+      beforeResult.error ||
+      !afterResult ||
+      afterResult.error ||
+      !sharedResult ||
+      sharedResult.error
+    ) {
+      throw new Error("Error in synchronize");
+    }
+
+    expect(beforeResult.value.value).toEqual(oldValue);
+    expect(beforeResult.value.channels).toEqual([beforeChannel]);
+    expect(beforeResult.value.tombstone).toBe(true);
+    expect(afterResult.value.value).toEqual(newValue);
+    expect(afterResult.value.channels).toEqual([afterChannel]);
+    expect(afterResult.value.tombstone).toBe(false);
+    expect(sharedResult.value.value).toEqual(newValue);
+    expect(sharedResult.value.channels).toEqual([sharedChannel]);
+    expect(sharedResult.value.tombstone).toBe(false);
+    expect(beforeResult.value.lastModified).toEqual(
+      afterResult.value.lastModified,
+    );
+    expect(sharedResult.value.lastModified).toEqual(
+      afterResult.value.lastModified,
+    );
+  });
+
+  it("patch", async () => {
+    const beforeChannel = randomString();
+    const afterChannel = randomString();
+    const sharedChannel = randomString();
+
+    const oldValue = { hello: "world" };
+    const oldChannels = [beforeChannel, sharedChannel];
+    const putted = await graffiti.put(
+      {
+        value: oldValue,
+        channels: oldChannels,
+      },
+      session,
+    );
+
+    // Start listening for changes...
+    const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+    const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
+    const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
+
+    await graffiti.patch(
+      {
+        value: [
+          {
+            op: "add",
+            path: "/something",
+            value: "new value",
+          },
+        ],
+        channels: [
+          {
+            op: "add",
+            path: "/-",
+            value: afterChannel,
+          },
+          {
+            op: "remove",
+            path: `/${oldChannels.indexOf(beforeChannel)}`,
+          },
+        ],
+      },
+      putted,
+      session,
+    );
+
+    const beforeResult = (await before).value;
+    const afterResult = (await after).value;
+    const sharedResult = (await shared).value;
+    if (
+      !beforeResult ||
+      beforeResult.error ||
+      !afterResult ||
+      afterResult.error ||
+      !sharedResult ||
+      sharedResult.error
+    ) {
+      throw new Error("Error in synchronize");
+    }
+
+    const newValue = { ...oldValue, something: "new value" };
+    const newChannels = [sharedChannel, afterChannel];
+    expect(beforeResult.value.value).toEqual(oldValue);
+    expect(beforeResult.value.channels).toEqual([beforeChannel]);
+    expect(beforeResult.value.tombstone).toBe(true);
+    expect(afterResult.value.value).toEqual(newValue);
+    expect(afterResult.value.channels).toEqual([afterChannel]);
+    expect(afterResult.value.tombstone).toBe(false);
+    expect(sharedResult.value.value).toEqual(newValue);
+    expect(sharedResult.value.channels).toEqual([sharedChannel]);
+    expect(sharedResult.value.tombstone).toBe(false);
+    expect(beforeResult.value.lastModified).toEqual(
+      afterResult.value.lastModified,
+    );
+    expect(sharedResult.value.lastModified).toEqual(
+      afterResult.value.lastModified,
+    );
+  });
+
+  it("delete", async () => {
+    const channels = [randomString(), randomString(), randomString()];
+
+    const oldValue = { hello: "world" };
+    const oldChannels = [randomString(), ...channels.slice(1)];
+    const putted = await graffiti.put(
+      {
+        value: oldValue,
+        channels: oldChannels,
+      },
+      session,
+    );
+
+    const next = graffiti.synchronizeDiscover(channels, {}).next();
+
+    graffiti.delete(putted, session);
+
+    const result = (await next).value;
+    if (!result || result.error) {
+      throw new Error("Error in synchronize");
+    }
+    expect(result.value.tombstone).toBe(true);
+    expect(result.value.value).toEqual(oldValue);
+    expect(result.value.channels).toEqual(
+      channels.filter((c) => oldChannels.includes(c)),
+    );
+  });
+
+  it("synchronize happens before putters", async () => {
+    const object = randomPutObject();
+    const iterator = graffiti.synchronizeDiscover(object.channels, {});
+
+    for (let i = 0; i < 10; i++) {
+      const next = iterator.next();
+      const putted = graffiti.put(object, session);
+
+      let first: undefined | string = undefined;
+      next.then(() => {
+        if (!first) first = "synchronize";
+      });
+      putted.then(() => {
+        if (!first) first = "put";
+      });
+      await putted;
+
+      expect(first).toBe("synchronize");
+
+      const patched = graffiti.patch({}, await putted, session);
+      const next2 = iterator.next();
+
+      let second: undefined | string = undefined;
+      next2.then(() => {
+        if (!second) second = "synchronize";
+      });
+      patched.then(() => {
+        if (!second) second = "patch";
+      });
+      await patched;
+
+      expect(second).toBe("synchronize");
+
+      const deleted = graffiti.delete(await putted, session);
+      const next3 = iterator.next();
+
+      let third: undefined | string = undefined;
+      next3.then(() => {
+        if (!third) third = "synchronize";
+      });
+      deleted.then(() => {
+        if (!third) third = "delete";
+      });
+      await deleted;
+
+      expect(third).toBe("synchronize");
+    }
+  });
+
+  it("not allowed", async () => {
+    const allChannels = [randomString(), randomString(), randomString()];
+    const channels = allChannels.slice(1);
+
+    const creatorNext = graffiti
+      .synchronizeDiscover(channels, {}, session1)
+      .next();
+    const allowedNext = graffiti
+      .synchronizeDiscover(channels, {}, session2)
+      .next();
+    const noSession = graffiti.synchronizeDiscover(channels, {}).next();
+
+    const value = {
+      hello: "world",
+    };
+    const allowed = [randomString(), session2.actor];
+    await graffiti.put({ value, channels: allChannels, allowed }, session1);
+
+    // Expect no session to time out!
+    await expect(
+      Promise.race([
+        noSession,
+        new Promise((resolve, rejects) => setTimeout(rejects, 100, "Timeout")),
+      ]),
+    ).rejects.toThrow("Timeout");
+
+    const creatorResult = (await creatorNext).value;
+    const allowedResult = (await allowedNext).value;
+
+    if (
+      !creatorResult ||
+      creatorResult.error ||
+      !allowedResult ||
+      allowedResult.error
+    ) {
+      throw new Error("Error in synchronize");
+    }
+
+    expect(creatorResult.value.value).toEqual(value);
+    expect(creatorResult.value.allowed).toEqual(allowed);
+    expect(creatorResult.value.channels).toEqual(allChannels);
+    expect(allowedResult.value.value).toEqual(value);
+    expect(allowedResult.value.allowed).toEqual([session2.actor]);
+    expect(allowedResult.value.channels).toEqual(channels);
+  });
+});
+
+describe.concurrent("synchronizeGet", () => {
+  let graffiti: ReturnType<typeof useGraffiti>;
+  let session: GraffitiSession;
+  let session1: GraffitiSession;
+  let session2: GraffitiSession;
+  beforeAll(async () => {
+    graffiti = useGraffiti();
+    session1 = await useSession1();
+    session = session1;
+    session2 = await useSession2();
+  });
+
+  it("replace, delete", async () => {
+    const object = randomPutObject();
+    const putted = await graffiti.put(object, session);
+
+    const iterator = graffiti.synchronizeGet(putted, {});
+    const next = iterator.next();
+
+    // Change the object
+    const newValue = { goodbye: "world" };
+    const putted2 = await graffiti.put(
+      {
+        ...putted,
+        value: newValue,
+      },
+      session,
+    );
+
+    const result = (await next).value;
+    assert(result && !result.error);
+
+    expect(result.value.value).toEqual(newValue);
+    expect(result.value.actor).toEqual(session.actor);
+    expect(result.value.channels).toEqual([]);
+    expect(result.value.tombstone).toBe(false);
+    expect(result.value.lastModified).toEqual(putted2.lastModified);
+    expect(result.value.allowed).toBeUndefined();
+
+    // Delete the object
+    const deleted = await graffiti.delete(putted2, session);
+    const result2 = (await iterator.next()).value;
+    assert(result2 && !result2.error);
+    expect(result2.value.tombstone).toBe(true);
+    expect(result2.value.lastModified).toEqual(deleted.lastModified);
+
+    // Put something else
+    await graffiti.put(randomPutObject(), session);
+    await expect(
+      Promise.race([
+        iterator.next(),
+        new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout")),
+      ]),
+    ).rejects.toThrow("Timeout");
+  });
+
+  it("not allowed", async () => {
+    const object = randomPutObject();
+    const putted = await graffiti.put(object, session1);
+
+    const iterator1 = graffiti.synchronizeGet(putted, {}, session1);
+    const iterator2 = graffiti.synchronizeGet(putted, {}, session2);
+
+    const next1 = iterator1.next();
+    const next2 = iterator2.next();
+
+    const newValue = { goodbye: "world" };
+    const putted2 = await graffiti.put(
+      {
+        ...putted,
+        ...object,
+        allowed: [],
+        value: newValue,
+      },
+      session1,
+    );
+    const result1 = (await next1).value;
+    const result2 = (await next2).value;
+    assert(result1 && !result1.error);
+    assert(result2 && !result2.error);
+
+    expect(result1.value.value).toEqual(newValue);
+    expect(result2.value.value).toEqual(object.value);
+    expect(result1.value.actor).toEqual(session1.actor);
+    expect(result2.value.actor).toEqual(session1.actor);
+    expect(result1.value.channels).toEqual(object.channels);
+    expect(result2.value.channels).toEqual([]);
+    expect(result1.value.tombstone).toBe(false);
+    expect(result2.value.tombstone).toBe(true);
+    expect(result1.value.lastModified).toEqual(putted2.lastModified);
+    expect(result2.value.lastModified).toEqual(putted2.lastModified);
+  });
+});