@graffiti-garden/wrapper-synchronize 0.0.3 → 0.1.0

package/dist/cjs/index.js

@@ -1,2 +1,241 @@
-"use strict";var j=Object.create;var h=Object.defineProperty;var O=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var w=Object.getPrototypeOf,z=Object.prototype.hasOwnProperty;var g=(r,t)=>{for(var e in t)h(r,e,{get:t[e],enumerable:!0})},y=(r,t,e,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of v(t))!z.call(r,i)&&i!==e&&h(r,i,{get:()=>t[i],enumerable:!(a=O(t,i))||a.enumerable});return r};var u=(r,t,e)=>(e=r!=null?j(w(r)):{},y(t||!r||!r.__esModule?h(e,"default",{value:r,enumerable:!0}):e,r)),P=r=>y(h({},"__esModule",{value:!0}),r);var x={};g(x,{GraffitiSynchronize:()=>k});module.exports=P(x);var b=require("@graffiti-garden/api"),d=require("@repeaterjs/repeater"),o=require("@graffiti-garden/implementation-local/utilities");class k extends b.Graffiti{ajv_;applyPatch_;graffiti;callbacks=new Set;options;channelStats;locationToUri;uriToLocation;login;logout;sessionEvents;get ajv(){return this.ajv_||(this.ajv_=(async()=>{const{default:t}=await import("ajv");return new t({strict:!1})})()),this.ajv_}get applyPatch(){return this.applyPatch_||(this.applyPatch_=(async()=>{const{applyPatch:t}=await import("fast-json-patch");return t})()),this.applyPatch_}constructor(t,e){super(),this.options=e??{},this.graffiti=t,this.channelStats=t.channelStats.bind(t),this.locationToUri=t.locationToUri.bind(t),this.uriToLocation=t.uriToLocation.bind(t),this.login=t.login.bind(t),this.logout=t.logout.bind(t),this.sessionEvents=t.sessionEvents}synchronize(t,e,a,i){return new d.Repeater(async(c,s)=>{const p=(0,o.compileGraffitiObjectSchema)(await this.ajv,a),m=(G,S)=>{for(const f of[S,G])if(f&&t(f)&&(this.options.omniscient||(0,o.isActorAllowedGraffitiObject)(f,i))){const l={...f};if(this.options.omniscient||(0,o.maskGraffitiObject)(l,e,i),p(l)){c({value:l});break}}};this.callbacks.add(m),await s,this.callbacks.delete(m)})}synchronizeDiscover(...t){const[e,a,i]=t;function n(c){return c.channels.some(s=>e.includes(s))}return this.synchronize(n,e,a,i)}synchronizeGet(...t){const[e,a,i]=t;function n(c){const s=(0,o.locationToUri)(c),{uri:p}=(0,o.unpackLocationOrUri)(e);return s===p}return this.synchronize(n,[],a,i)}synchronizeRecoverOrphans(...t){const[e,a]=t;function i(n){return n.actor===a.actor&&n.channels.length===0}return this.synchronize(i,[],e,a)}synchronizeAll(t,e){return this.synchronize(()=>!0,[],t??{},e)}async synchronizeDispatch(t,e,a=!1){for(const i of this.callbacks)i(t,e);a&&await new Promise(i=>setTimeout(i,0))}get=async(...t)=>{const e=await this.graffiti.get(...t);return this.synchronizeDispatch(e),e};put=async(...t)=>{const e=await this.graffiti.put(...t),a=t[0],i={...e,value:a.value,channels:a.channels,allowed:a.allowed,tombstone:!1};return await this.synchronizeDispatch(e,i,!0),e};patch=async(...t)=>{const e=await this.graffiti.patch(...t),a={...e};a.tombstone=!1;for(const i of["value","channels","allowed"])(0,o.applyGraffitiPatch)(await this.applyPatch,i,t[0],a);return await this.synchronizeDispatch(e,a,!0),e};delete=async(...t)=>{const e=await this.graffiti.delete(...t);return await this.synchronizeDispatch(e,void 0,!0),e};objectStream(t){const e=this.synchronizeDispatch.bind(this);return async function*(){let i=await t.next();for(;!i.done;)i.value.error||e(i.value.value),yield i.value,i=await t.next();return i.value}()}discover=(...t)=>{const e=this.graffiti.discover(...t);return this.objectStream(e)};recoverOrphans=(...t)=>{const e=this.graffiti.recoverOrphans(...t);return this.objectStream(e)}}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  GraffitiSynchronize: () => GraffitiSynchronize
+});
+module.exports = __toCommonJS(index_exports);
+var import_api = require("@graffiti-garden/api");
+var import_repeater = require("@repeaterjs/repeater");
+var import_utilities = require("@graffiti-garden/implementation-local/utilities");
+class GraffitiSynchronize extends import_api.Graffiti {
+  ajv_;
+  applyPatch_;
+  graffiti;
+  callbacks = /* @__PURE__ */ new Set();
+  options;
+  channelStats;
+  login;
+  logout;
+  sessionEvents;
+  get ajv() {
+    if (!this.ajv_) {
+      this.ajv_ = (async () => {
+        const { default: Ajv } = await import("ajv");
+        return new Ajv({ strict: false });
+      })();
+    }
+    return this.ajv_;
+  }
+  get applyPatch() {
+    if (!this.applyPatch_) {
+      this.applyPatch_ = (async () => {
+        const { applyPatch } = await import("fast-json-patch");
+        return applyPatch;
+      })();
+    }
+    return this.applyPatch_;
+  }
+  /**
+   * 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(graffiti, options) {
+    super();
+    this.options = options ?? {};
+    this.graffiti = graffiti;
+    this.channelStats = graffiti.channelStats.bind(graffiti);
+    this.login = graffiti.login.bind(graffiti);
+    this.logout = graffiti.logout.bind(graffiti);
+    this.sessionEvents = graffiti.sessionEvents;
+  }
+  synchronize(matchObject, channels, schema, session) {
+    const repeater = new import_repeater.Repeater(
+      async (push, stop) => {
+        const validate = (0, import_utilities.compileGraffitiObjectSchema)(await this.ajv, schema);
+        const callback = (oldObjectRaw, newObjectRaw) => {
+          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {
+            if (objectRaw && matchObject(objectRaw) && (this.options.omniscient || (0, import_utilities.isActorAllowedGraffitiObject)(objectRaw, session))) {
+              const object = { ...objectRaw };
+              if (!this.options.omniscient) {
+                (0, import_utilities.maskGraffitiObject)(object, channels, session);
+              }
+              if (validate(object)) {
+                push({ value: object });
+                break;
+              }
+            }
+          }
+        };
+        this.callbacks.add(callback);
+        await stop;
+        this.callbacks.delete(callback);
+      }
+    );
+    return repeater;
+  }
+  /**
+   * 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(...args) {
+    const [channels, schema, session] = args;
+    function matchObject(object) {
+      return object.channels.some((channel) => channels.includes(channel));
+    }
+    return this.synchronize(matchObject, channels, schema, session);
+  }
+  /**
+   * 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(...args) {
+    const [locationOrUri, schema, session] = args;
+    const uri = (0, import_utilities.unpackLocationOrUri)(locationOrUri);
+    function matchObject(object) {
+      return object.uri === uri;
+    }
+    return this.synchronize(matchObject, [], schema, session);
+  }
+  /**
+   * 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(...args) {
+    const [schema, session] = args;
+    function matchObject(object) {
+      return object.actor === session.actor && object.channels.length === 0;
+    }
+    return this.synchronize(matchObject, [], schema, session);
+  }
+  /**
+   * Streams changes made to *any* object in *any* channel
+   * and made by *any* user. You may want to use it in conjuction with
+   * {@link GraffitiSynchronizeOptions.omniscient} to get a global view
+   * of all Graffiti objects passing through the system. This is useful
+   * for building a client-side cache, for example.
+   *
+   * Be careful using this method. Without additional filters it can
+   * expose the user to content out of context.
+   */
+  synchronizeAll(schema, session) {
+    return this.synchronize(() => true, [], schema ?? {}, session);
+  }
+  async synchronizeDispatch(oldObject, newObject, waitForListeners = false) {
+    for (const callback of this.callbacks) {
+      callback(oldObject, newObject);
+    }
+    if (waitForListeners) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  get = async (...args) => {
+    const object = await this.graffiti.get(...args);
+    this.synchronizeDispatch(object);
+    return object;
+  };
+  put = async (...args) => {
+    const oldObject = await this.graffiti.put(...args);
+    const partialObject = args[0];
+    const newObject = {
+      ...oldObject,
+      value: partialObject.value,
+      channels: partialObject.channels,
+      allowed: partialObject.allowed,
+      tombstone: false
+    };
+    await this.synchronizeDispatch(oldObject, newObject, true);
+    return oldObject;
+  };
+  patch = async (...args) => {
+    const oldObject = await this.graffiti.patch(...args);
+    const newObject = { ...oldObject };
+    newObject.tombstone = false;
+    for (const prop of ["value", "channels", "allowed"]) {
+      (0, import_utilities.applyGraffitiPatch)(await this.applyPatch, prop, args[0], newObject);
+    }
+    await this.synchronizeDispatch(oldObject, newObject, true);
+    return oldObject;
+  };
+  delete = async (...args) => {
+    const oldObject = await this.graffiti.delete(...args);
+    await this.synchronizeDispatch(oldObject, void 0, true);
+    return oldObject;
+  };
+  objectStream(iterator) {
+    const dispatch = this.synchronizeDispatch.bind(this);
+    const wrapper = async function* () {
+      let result = await iterator.next();
+      while (!result.done) {
+        if (!result.value.error) {
+          dispatch(result.value.value);
+        }
+        yield result.value;
+        result = await iterator.next();
+      }
+      return result.value;
+    };
+    return wrapper();
+  }
+  discover = (...args) => {
+    const iterator = this.graffiti.discover(...args);
+    return this.objectStream(iterator);
+  };
+  recoverOrphans = (...args) => {
+    const iterator = this.graffiti.recoverOrphans(...args);
+    return this.objectStream(iterator);
+  };
+}
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["import type Ajv from \"ajv\";\nimport { Graffiti } from \"@graffiti-garden/api\";\nimport type {\n  GraffitiSession,\n  GraffitiObject,\n  JSONSchema,\n  GraffitiStream,\n} from \"@graffiti-garden/api\";\nimport type { GraffitiObjectBase } from \"@graffiti-garden/api\";\nimport { Repeater } from \"@repeaterjs/repeater\";\nimport type { applyPatch } from \"fast-json-patch\";\nimport {\n  applyGraffitiPatch,\n  compileGraffitiObjectSchema,\n  isActorAllowedGraffitiObject,\n  locationToUri,\n  maskGraffitiObject,\n  unpackLocationOrUri,\n} from \"@graffiti-garden/implementation-local/utilities\";\nexport type * from \"@graffiti-garden/api\";\n\nexport type GraffitiSynchronizeCallback = (\n  oldObject: GraffitiObjectBase,\n  newObject?: GraffitiObjectBase,\n) => void;\n\nexport interface GraffitiSynchronizeOptions {\n  /**\n   * Allows synchronize to listen to all objects, not just those\n   * that the session is allowed to see. This is useful to get a\n   * global view of all Graffiti objects passsing through the system,\n   * for example to build a client-side cache. Additional mechanisms\n   * should be in place to ensure that users do not see objects or\n   * properties they are not allowed to see.\n   *\n   * Default: `false`\n   */\n  omniscient?: boolean;\n}\n\n/**\n * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * so that changes made or received in one part of an application\n * are automatically routed to other parts of the application.\n * This is an important tool for building responsive\n * and consistent user interfaces, and is built upon to make\n * the [Graffiti Vue Plugin](https://vue.graffiti.garden/variables/GraffitiPlugin.html)\n * and possibly other front-end libraries in the future.\n *\n * Specifically, it provides the following *synchronize*\n * methods for each of the following API methods:\n *\n * | API Method | Synchronize Method |\n * |------------|--------------------|\n * | {@link get} | {@link synchronizeGet} |\n * | {@link discover} | {@link synchronizeDiscover} |\n * | {@link recoverOrphans} | {@link synchronizeRecoverOrphans} |\n *\n * Whenever a change is made via {@link put}, {@link patch}, and {@link delete} or\n * received from {@link get}, {@link discover}, and {@link recoverOrphans},\n * those changes are forwarded to the appropriate synchronize method.\n * Each synchronize method returns an iterator that streams these changes\n * continually until the user calls `return` on the iterator or `break`s out of the loop,\n * allowing for live updates without additional polling.\n *\n * Example 1: Suppose a user publishes a post using {@link put}. If the feed\n * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,\n * then the user's new post will instantly appear in their feed, giving the UI a\n * responsive feel.\n *\n * Example 2: Suppose one of a user's friends changes their name. As soon as the\n * user's application receives one notice of that change (using {@link get}\n * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update\n * all instance's of that friend's name in the user's application instantly,\n * providing a consistent user experience.\n *\n * @groupDescription Synchronize Methods\n * This group contains methods that listen for changes made via\n * {@link put}, {@link patch}, and {@link delete} or fetched from\n * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n * streams appropriate changes to provide a responsive and consistent user experience.\n */\nexport class GraffitiSynchronize extends Graffiti {\n  protected ajv_: Promise<Ajv> | undefined;\n  protected applyPatch_: Promise<typeof applyPatch> | undefined;\n  protected readonly graffiti: Graffiti;\n  protected readonly callbacks = new Set<GraffitiSynchronizeCallback>();\n  protected readonly options: GraffitiSynchronizeOptions;\n\n  channelStats: Graffiti[\"channelStats\"];\n  locationToUri: Graffiti[\"locationToUri\"];\n  uriToLocation: Graffiti[\"uriToLocation\"];\n  login: Graffiti[\"login\"];\n  logout: Graffiti[\"logout\"];\n  sessionEvents: Graffiti[\"sessionEvents\"];\n\n  get ajv() {\n    if (!this.ajv_) {\n      this.ajv_ = (async () => {\n        const { default: Ajv } = await import(\"ajv\");\n        return new Ajv({ strict: false });\n      })();\n    }\n    return this.ajv_;\n  }\n\n  get applyPatch() {\n    if (!this.applyPatch_) {\n      this.applyPatch_ = (async () => {\n        const { applyPatch } = await import(\"fast-json-patch\");\n        return applyPatch;\n      })();\n    }\n    return this.applyPatch_;\n  }\n\n  /**\n   * Wraps a Graffiti API instance to provide the synchronize methods.\n   * The GraffitiSyncrhonize class rather than the Graffiti class\n   * must be used for all functions for the synchronize methods to work.\n   */\n  constructor(\n    /**\n     * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n     * instance to wrap.\n     */\n    graffiti: Graffiti,\n    options?: GraffitiSynchronizeOptions,\n  ) {\n    super();\n    this.options = options ?? {};\n    this.graffiti = graffiti;\n    this.channelStats = graffiti.channelStats.bind(graffiti);\n    this.locationToUri = graffiti.locationToUri.bind(graffiti);\n    this.uriToLocation = graffiti.uriToLocation.bind(graffiti);\n    this.login = graffiti.login.bind(graffiti);\n    this.logout = graffiti.logout.bind(graffiti);\n    this.sessionEvents = graffiti.sessionEvents;\n  }\n\n  protected synchronize<Schema extends JSONSchema>(\n    matchObject: (object: GraffitiObjectBase) => boolean,\n    channels: string[],\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ) {\n    const repeater: GraffitiStream<GraffitiObject<Schema>> = new Repeater(\n      async (push, stop) => {\n        const validate = compileGraffitiObjectSchema(await this.ajv, schema);\n        const callback: GraffitiSynchronizeCallback = (\n          oldObjectRaw,\n          newObjectRaw,\n        ) => {\n          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {\n            if (\n              objectRaw &&\n              matchObject(objectRaw) &&\n              (this.options.omniscient ||\n                isActorAllowedGraffitiObject(objectRaw, session))\n            ) {\n              const object = { ...objectRaw };\n              if (!this.options.omniscient) {\n                maskGraffitiObject(object, channels, session);\n              }\n              if (validate(object)) {\n                push({ value: object });\n                break;\n              }\n            }\n          }\n        };\n\n        this.callbacks.add(callback);\n        await stop;\n        this.callbacks.delete(callback);\n      },\n    );\n\n    return repeater;\n  }\n\n  /**\n   * This method has the same signature as {@link discover} but listens for\n   * changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}\n   * and then streams appropriate changes to provide a responsive and\n   * consistent user experience.\n   *\n   * Unlike {@link discover}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeDiscover<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.discover<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [channels, schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.channels.some((channel) => channels.includes(channel));\n    }\n    return this.synchronize<Schema>(matchObject, channels, schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link get} but\n   * listens for changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link get}, which returns a single result, this method continuously\n   * listens for changes which are output as an asynchronous {@link GraffitiStream}.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeGet<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.get<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [locationOrUri, schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      const objectUri = locationToUri(object);\n      const { uri } = unpackLocationOrUri(locationOrUri);\n      return objectUri === uri;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link recoverOrphans} but\n   * listens for changes made via\n   * {@link put}, {@link patch}, and {@link delete} or fetched from\n   * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link recoverOrphans}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeRecoverOrphans<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.actor === session.actor && object.channels.length === 0;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * Streams changes made to *any* object in *any* channel\n   * and made by *any* user. You may want to use it in conjuction with\n   * {@link GraffitiSyncrhonizeOptions.omniscient} to get a global view\n   * of all Graffiti objects passing through the system. This is useful\n   * for building a client-side cache, for example.\n   *\n   * Be careful using this method. Without additional filters it can\n   * expose the user to content out of context.\n   */\n  synchronizeAll(\n    schema?: JSONSchema,\n    session?: GraffitiSession | null,\n  ): GraffitiStream<GraffitiObjectBase> {\n    return this.synchronize(() => true, [], schema ?? {}, session);\n  }\n\n  protected async synchronizeDispatch(\n    oldObject: GraffitiObjectBase,\n    newObject?: GraffitiObjectBase,\n    waitForListeners = false,\n  ) {\n    for (const callback of this.callbacks) {\n      callback(oldObject, newObject);\n    }\n    if (waitForListeners) {\n      // Wait for the listeners to receive\n      // their objects, before returning the operation\n      // that triggered them.\n      //\n      // This is important for mutators (put, patch, delete)\n      // to ensure the application state has been updated\n      // everywhere before returning, giving consistent\n      // feedback to the user that the operation has completed.\n      //\n      // The opposite is true for accessors (get, discover, recoverOrphans),\n      // where it is a weird user experience to call `get`\n      // in one place and have the application update\n      // somewhere else first. It is also less efficient.\n      //\n      // The hack is simply to await one \"macro task cycle\".\n      // We need to wait for this cycle rather than using\n      // `await push` in the callback, because it turns out\n      // that `await push` won't resolve until the following\n      // .next() call of the iterator, so if only\n      // one .next() is called, this dispatch will hang.\n      await new Promise((resolve) => setTimeout(resolve, 0));\n    }\n  }\n\n  get: Graffiti[\"get\"] = async (...args) => {\n    const object = await this.graffiti.get(...args);\n    this.synchronizeDispatch(object);\n    return object;\n  };\n\n  put: Graffiti[\"put\"] = async (...args) => {\n    const oldObject = await this.graffiti.put<{}>(...args);\n    const partialObject = args[0];\n    const newObject: GraffitiObjectBase = {\n      ...oldObject,\n      value: partialObject.value,\n      channels: partialObject.channels,\n      allowed: partialObject.allowed,\n      tombstone: false,\n    };\n    await this.synchronizeDispatch(oldObject, newObject, true);\n    return oldObject;\n  };\n\n  patch: Graffiti[\"patch\"] = async (...args) => {\n    const oldObject = await this.graffiti.patch(...args);\n    const newObject: GraffitiObjectBase = { ...oldObject };\n    newObject.tombstone = false;\n    for (const prop of [\"value\", \"channels\", \"allowed\"] as const) {\n      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);\n    }\n    await this.synchronizeDispatch(oldObject, newObject, true);\n    return oldObject;\n  };\n\n  delete: Graffiti[\"delete\"] = async (...args) => {\n    const oldObject = await this.graffiti.delete(...args);\n    await this.synchronizeDispatch(oldObject, undefined, true);\n    return oldObject;\n  };\n\n  protected objectStream<Schema extends JSONSchema>(\n    iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>,\n  ) {\n    const dispatch = this.synchronizeDispatch.bind(this);\n    const wrapper = async function* () {\n      let result = await iterator.next();\n      while (!result.done) {\n        if (!result.value.error) {\n          dispatch(result.value.value);\n        }\n        yield result.value;\n        result = await iterator.next();\n      }\n      return result.value;\n    };\n    return wrapper();\n  }\n\n  discover: Graffiti[\"discover\"] = (...args) => {\n    const iterator = this.graffiti.discover(...args);\n    return this.objectStream<(typeof args)[1]>(iterator);\n  };\n\n  recoverOrphans: Graffiti[\"recoverOrphans\"] = (...args) => {\n    const iterator = this.graffiti.recoverOrphans(...args);\n    return this.objectStream<(typeof args)[0]>(iterator);\n  };\n}\n"],
-  "mappings": "0jBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,IAAA,eAAAC,EAAAH,GACA,IAAAI,EAAyB,gCAQzBC,EAAyB,gCAEzBC,EAOO,2DAgEA,MAAMJ,UAA4B,UAAS,CACtC,KACA,YACS,SACA,UAAY,IAAI,IAChB,QAEnB,aACA,cACA,cACA,MACA,OACA,cAEA,IAAI,KAAM,CACR,OAAK,KAAK,OACR,KAAK,MAAQ,SAAY,CACvB,KAAM,CAAE,QAASK,CAAI,EAAI,KAAM,QAAO,KAAK,EAC3C,OAAO,IAAIA,EAAI,CAAE,OAAQ,EAAM,CAAC,CAClC,GAAG,GAEE,KAAK,IACd,CAEA,IAAI,YAAa,CACf,OAAK,KAAK,cACR,KAAK,aAAe,SAAY,CAC9B,KAAM,CAAE,WAAAC,CAAW,EAAI,KAAM,QAAO,iBAAiB,EACrD,OAAOA,CACT,GAAG,GAEE,KAAK,WACd,CAOA,YAKEC,EACAC,EACA,CACA,MAAM,EACN,KAAK,QAAUA,GAAW,CAAC,EAC3B,KAAK,SAAWD,EAChB,KAAK,aAAeA,EAAS,aAAa,KAAKA,CAAQ,EACvD,KAAK,cAAgBA,EAAS,cAAc,KAAKA,CAAQ,EACzD,KAAK,cAAgBA,EAAS,cAAc,KAAKA,CAAQ,EACzD,KAAK,MAAQA,EAAS,MAAM,KAAKA,CAAQ,EACzC,KAAK,OAASA,EAAS,OAAO,KAAKA,CAAQ,EAC3C,KAAK,cAAgBA,EAAS,aAChC,CAEU,YACRE,EACAC,EACAC,EACAC,EACA,CAiCA,OAhCyD,IAAI,WAC3D,MAAOC,EAAMC,IAAS,CACpB,MAAMC,KAAW,+BAA4B,MAAM,KAAK,IAAKJ,CAAM,EAC7DK,EAAwC,CAC5CC,EACAC,IACG,CACH,UAAWC,IAAa,CAACD,EAAcD,CAAY,EACjD,GACEE,GACAV,EAAYU,CAAS,IACpB,KAAK,QAAQ,eACZ,gCAA6BA,EAAWP,CAAO,GACjD,CACA,MAAMQ,EAAS,CAAE,GAAGD,CAAU,EAI9B,GAHK,KAAK,QAAQ,eAChB,sBAAmBC,EAAQV,EAAUE,CAAO,EAE1CG,EAASK,CAAM,EAAG,CACpBP,EAAK,CAAE,MAAOO,CAAO,CAAC,EACtB,KACF,CACF,CAEJ,EAEA,KAAK,UAAU,IAAIJ,CAAQ,EAC3B,MAAMF,EACN,KAAK,UAAU,OAAOE,CAAQ,CAChC,CACF,CAGF,CAeA,uBACKK,EACqC,CACxC,KAAM,CAACX,EAAUC,EAAQC,CAAO,EAAIS,EACpC,SAASZ,EAAYW,EAA4B,CAC/C,OAAOA,EAAO,SAAS,KAAME,GAAYZ,EAAS,SAASY,CAAO,CAAC,CACrE,CACA,OAAO,KAAK,YAAoBb,EAAaC,EAAUC,EAAQC,CAAO,CACxE,CAaA,kBACKS,EACqC,CACxC,KAAM,CAACE,EAAeZ,EAAQC,CAAO,EAAIS,EACzC,SAASZ,EAAYW,EAA4B,CAC/C,MAAMI,KAAY,iBAAcJ,CAAM,EAChC,CAAE,IAAAK,CAAI,KAAI,uBAAoBF,CAAa,EACjD,OAAOC,IAAcC,CACvB,CACA,OAAO,KAAK,YAAoBhB,EAAa,CAAC,EAAGE,EAAQC,CAAO,CAClE,CAeA,6BACKS,EACqC,CACxC,KAAM,CAACV,EAAQC,CAAO,EAAIS,EAC1B,SAASZ,EAAYW,EAA4B,CAC/C,OAAOA,EAAO,QAAUR,EAAQ,OAASQ,EAAO,SAAS,SAAW,CACtE,CACA,OAAO,KAAK,YAAoBX,EAAa,CAAC,EAAGE,EAAQC,CAAO,CAClE,CAYA,eACED,EACAC,EACoC,CACpC,OAAO,KAAK,YAAY,IAAM,GAAM,CAAC,EAAGD,GAAU,CAAC,EAAGC,CAAO,CAC/D,CAEA,MAAgB,oBACdc,EACAC,EACAC,EAAmB,GACnB,CACA,UAAWZ,KAAY,KAAK,UAC1BA,EAASU,EAAWC,CAAS,EAE3BC,GAqBF,MAAM,IAAI,QAASC,GAAY,WAAWA,EAAS,CAAC,CAAC,CAEzD,CAEA,IAAuB,SAAUR,IAAS,CACxC,MAAMD,EAAS,MAAM,KAAK,SAAS,IAAI,GAAGC,CAAI,EAC9C,YAAK,oBAAoBD,CAAM,EACxBA,CACT,EAEA,IAAuB,SAAUC,IAAS,CACxC,MAAMK,EAAY,MAAM,KAAK,SAAS,IAAQ,GAAGL,CAAI,EAC/CS,EAAgBT,EAAK,CAAC,EACtBM,EAAgC,CACpC,GAAGD,EACH,MAAOI,EAAc,MACrB,SAAUA,EAAc,SACxB,QAASA,EAAc,QACvB,UAAW,EACb,EACA,aAAM,KAAK,oBAAoBJ,EAAWC,EAAW,EAAI,EAClDD,CACT,EAEA,MAA2B,SAAUL,IAAS,CAC5C,MAAMK,EAAY,MAAM,KAAK,SAAS,MAAM,GAAGL,CAAI,EAC7CM,EAAgC,CAAE,GAAGD,CAAU,EACrDC,EAAU,UAAY,GACtB,UAAWI,IAAQ,CAAC,QAAS,WAAY,SAAS,KAChD,sBAAmB,MAAM,KAAK,WAAYA,EAAMV,EAAK,CAAC,EAAGM,CAAS,EAEpE,aAAM,KAAK,oBAAoBD,EAAWC,EAAW,EAAI,EAClDD,CACT,EAEA,OAA6B,SAAUL,IAAS,CAC9C,MAAMK,EAAY,MAAM,KAAK,SAAS,OAAO,GAAGL,CAAI,EACpD,aAAM,KAAK,oBAAoBK,EAAW,OAAW,EAAI,EAClDA,CACT,EAEU,aACRM,EACA,CACA,MAAMC,EAAW,KAAK,oBAAoB,KAAK,IAAI,EAYnD,OAXgB,iBAAmB,CACjC,IAAIC,EAAS,MAAMF,EAAS,KAAK,EACjC,KAAO,CAACE,EAAO,MACRA,EAAO,MAAM,OAChBD,EAASC,EAAO,MAAM,KAAK,EAE7B,MAAMA,EAAO,MACbA,EAAS,MAAMF,EAAS,KAAK,EAE/B,OAAOE,EAAO,KAChB,EACe,CACjB,CAEA,SAAiC,IAAIb,IAAS,CAC5C,MAAMW,EAAW,KAAK,SAAS,SAAS,GAAGX,CAAI,EAC/C,OAAO,KAAK,aAA+BW,CAAQ,CACrD,EAEA,eAA6C,IAAIX,IAAS,CACxD,MAAMW,EAAW,KAAK,SAAS,eAAe,GAAGX,CAAI,EACrD,OAAO,KAAK,aAA+BW,CAAQ,CACrD,CACF",
-  "names": ["index_exports", "__export", "GraffitiSynchronize", "__toCommonJS", "import_api", "import_repeater", "import_utilities", "Ajv", "applyPatch", "graffiti", "options", "matchObject", "channels", "schema", "session", "push", "stop", "validate", "callback", "oldObjectRaw", "newObjectRaw", "objectRaw", "object", "args", "channel", "locationOrUri", "objectUri", "uri", "oldObject", "newObject", "waitForListeners", "resolve", "partialObject", "prop", "iterator", "dispatch", "result"]
+  "sourcesContent": ["import type Ajv from \"ajv\";\nimport { Graffiti } from \"@graffiti-garden/api\";\nimport type {\n  GraffitiSession,\n  GraffitiObject,\n  JSONSchema,\n  GraffitiStream,\n} from \"@graffiti-garden/api\";\nimport type { GraffitiObjectBase } from \"@graffiti-garden/api\";\nimport { Repeater } from \"@repeaterjs/repeater\";\nimport type { applyPatch } from \"fast-json-patch\";\nimport {\n  applyGraffitiPatch,\n  compileGraffitiObjectSchema,\n  isActorAllowedGraffitiObject,\n  maskGraffitiObject,\n  unpackLocationOrUri,\n} from \"@graffiti-garden/implementation-local/utilities\";\nexport type * from \"@graffiti-garden/api\";\n\nexport type GraffitiSynchronizeCallback = (\n  oldObject: GraffitiObjectBase,\n  newObject?: GraffitiObjectBase,\n) => void;\n\nexport interface GraffitiSynchronizeOptions {\n  /**\n   * Allows synchronize to listen to all objects, not just those\n   * that the session is allowed to see. This is useful to get a\n   * global view of all Graffiti objects passsing through the system,\n   * for example to build a client-side cache. Additional mechanisms\n   * should be in place to ensure that users do not see objects or\n   * properties they are not allowed to see.\n   *\n   * Default: `false`\n   */\n  omniscient?: boolean;\n}\n\n/**\n * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * so that changes made or received in one part of an application\n * are automatically routed to other parts of the application.\n * This is an important tool for building responsive\n * and consistent user interfaces, and is built upon to make\n * the [Graffiti Vue Plugin](https://vue.graffiti.garden/variables/GraffitiPlugin.html)\n * and possibly other front-end libraries in the future.\n *\n * Specifically, it provides the following *synchronize*\n * methods for each of the following API methods:\n *\n * | API Method | Synchronize Method |\n * |------------|--------------------|\n * | {@link get} | {@link synchronizeGet} |\n * | {@link discover} | {@link synchronizeDiscover} |\n * | {@link recoverOrphans} | {@link synchronizeRecoverOrphans} |\n *\n * Whenever a change is made via {@link put}, {@link patch}, and {@link delete} or\n * received from {@link get}, {@link discover}, and {@link recoverOrphans},\n * those changes are forwarded to the appropriate synchronize method.\n * Each synchronize method returns an iterator that streams these changes\n * continually until the user calls `return` on the iterator or `break`s out of the loop,\n * allowing for live updates without additional polling.\n *\n * Example 1: Suppose a user publishes a post using {@link put}. If the feed\n * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,\n * then the user's new post will instantly appear in their feed, giving the UI a\n * responsive feel.\n *\n * Example 2: Suppose one of a user's friends changes their name. As soon as the\n * user's application receives one notice of that change (using {@link get}\n * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update\n * all instance's of that friend's name in the user's application instantly,\n * providing a consistent user experience.\n *\n * @groupDescription Synchronize Methods\n * This group contains methods that listen for changes made via\n * {@link put}, {@link patch}, and {@link delete} or fetched from\n * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n * streams appropriate changes to provide a responsive and consistent user experience.\n */\nexport class GraffitiSynchronize extends Graffiti {\n  protected ajv_: Promise<Ajv> | undefined;\n  protected applyPatch_: Promise<typeof applyPatch> | undefined;\n  protected readonly graffiti: Graffiti;\n  protected readonly callbacks = new Set<GraffitiSynchronizeCallback>();\n  protected readonly options: GraffitiSynchronizeOptions;\n\n  channelStats: Graffiti[\"channelStats\"];\n  login: Graffiti[\"login\"];\n  logout: Graffiti[\"logout\"];\n  sessionEvents: Graffiti[\"sessionEvents\"];\n\n  get ajv() {\n    if (!this.ajv_) {\n      this.ajv_ = (async () => {\n        const { default: Ajv } = await import(\"ajv\");\n        return new Ajv({ strict: false });\n      })();\n    }\n    return this.ajv_;\n  }\n\n  get applyPatch() {\n    if (!this.applyPatch_) {\n      this.applyPatch_ = (async () => {\n        const { applyPatch } = await import(\"fast-json-patch\");\n        return applyPatch;\n      })();\n    }\n    return this.applyPatch_;\n  }\n\n  /**\n   * Wraps a Graffiti API instance to provide the synchronize methods.\n   * The GraffitiSyncrhonize class rather than the Graffiti class\n   * must be used for all functions for the synchronize methods to work.\n   */\n  constructor(\n    /**\n     * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n     * instance to wrap.\n     */\n    graffiti: Graffiti,\n    options?: GraffitiSynchronizeOptions,\n  ) {\n    super();\n    this.options = options ?? {};\n    this.graffiti = graffiti;\n    this.channelStats = graffiti.channelStats.bind(graffiti);\n    this.login = graffiti.login.bind(graffiti);\n    this.logout = graffiti.logout.bind(graffiti);\n    this.sessionEvents = graffiti.sessionEvents;\n  }\n\n  protected synchronize<Schema extends JSONSchema>(\n    matchObject: (object: GraffitiObjectBase) => boolean,\n    channels: string[],\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ) {\n    const repeater: GraffitiStream<GraffitiObject<Schema>> = new Repeater(\n      async (push, stop) => {\n        const validate = compileGraffitiObjectSchema(await this.ajv, schema);\n        const callback: GraffitiSynchronizeCallback = (\n          oldObjectRaw,\n          newObjectRaw,\n        ) => {\n          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {\n            if (\n              objectRaw &&\n              matchObject(objectRaw) &&\n              (this.options.omniscient ||\n                isActorAllowedGraffitiObject(objectRaw, session))\n            ) {\n              const object = { ...objectRaw };\n              if (!this.options.omniscient) {\n                maskGraffitiObject(object, channels, session);\n              }\n              if (validate(object)) {\n                push({ value: object });\n                break;\n              }\n            }\n          }\n        };\n\n        this.callbacks.add(callback);\n        await stop;\n        this.callbacks.delete(callback);\n      },\n    );\n\n    return repeater;\n  }\n\n  /**\n   * This method has the same signature as {@link discover} but listens for\n   * changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}\n   * and then streams appropriate changes to provide a responsive and\n   * consistent user experience.\n   *\n   * Unlike {@link discover}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeDiscover<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.discover<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [channels, schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.channels.some((channel) => channels.includes(channel));\n    }\n    return this.synchronize<Schema>(matchObject, channels, schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link get} but\n   * listens for changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link get}, which returns a single result, this method continuously\n   * listens for changes which are output as an asynchronous {@link GraffitiStream}.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeGet<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.get<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [locationOrUri, schema, session] = args;\n    const uri = unpackLocationOrUri(locationOrUri);\n    function matchObject(object: GraffitiObjectBase) {\n      return object.uri === uri;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link recoverOrphans} but\n   * listens for changes made via\n   * {@link put}, {@link patch}, and {@link delete} or fetched from\n   * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link recoverOrphans}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeRecoverOrphans<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>\n  ): GraffitiStream<GraffitiObject<Schema>> {\n    const [schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.actor === session.actor && object.channels.length === 0;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * Streams changes made to *any* object in *any* channel\n   * and made by *any* user. You may want to use it in conjuction with\n   * {@link GraffitiSynchronizeOptions.omniscient} to get a global view\n   * of all Graffiti objects passing through the system. This is useful\n   * for building a client-side cache, for example.\n   *\n   * Be careful using this method. Without additional filters it can\n   * expose the user to content out of context.\n   */\n  synchronizeAll<Schema extends JSONSchema>(\n    schema?: Schema,\n    session?: GraffitiSession | null,\n  ): GraffitiStream<GraffitiObjectBase> {\n    return this.synchronize(() => true, [], schema ?? {}, session);\n  }\n\n  protected async synchronizeDispatch(\n    oldObject: GraffitiObjectBase,\n    newObject?: GraffitiObjectBase,\n    waitForListeners = false,\n  ) {\n    for (const callback of this.callbacks) {\n      callback(oldObject, newObject);\n    }\n    if (waitForListeners) {\n      // Wait for the listeners to receive\n      // their objects, before returning the operation\n      // that triggered them.\n      //\n      // This is important for mutators (put, patch, delete)\n      // to ensure the application state has been updated\n      // everywhere before returning, giving consistent\n      // feedback to the user that the operation has completed.\n      //\n      // The opposite is true for accessors (get, discover, recoverOrphans),\n      // where it is a weird user experience to call `get`\n      // in one place and have the application update\n      // somewhere else first. It is also less efficient.\n      //\n      // The hack is simply to await one \"macro task cycle\".\n      // We need to wait for this cycle rather than using\n      // `await push` in the callback, because it turns out\n      // that `await push` won't resolve until the following\n      // .next() call of the iterator, so if only\n      // one .next() is called, this dispatch will hang.\n      await new Promise((resolve) => setTimeout(resolve, 0));\n    }\n  }\n\n  get: Graffiti[\"get\"] = async (...args) => {\n    const object = await this.graffiti.get(...args);\n    this.synchronizeDispatch(object);\n    return object;\n  };\n\n  put: Graffiti[\"put\"] = async (...args) => {\n    const oldObject = await this.graffiti.put<{}>(...args);\n    const partialObject = args[0];\n    const newObject: GraffitiObjectBase = {\n      ...oldObject,\n      value: partialObject.value,\n      channels: partialObject.channels,\n      allowed: partialObject.allowed,\n      tombstone: false,\n    };\n    await this.synchronizeDispatch(oldObject, newObject, true);\n    return oldObject;\n  };\n\n  patch: Graffiti[\"patch\"] = async (...args) => {\n    const oldObject = await this.graffiti.patch(...args);\n    const newObject: GraffitiObjectBase = { ...oldObject };\n    newObject.tombstone = false;\n    for (const prop of [\"value\", \"channels\", \"allowed\"] as const) {\n      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);\n    }\n    await this.synchronizeDispatch(oldObject, newObject, true);\n    return oldObject;\n  };\n\n  delete: Graffiti[\"delete\"] = async (...args) => {\n    const oldObject = await this.graffiti.delete(...args);\n    await this.synchronizeDispatch(oldObject, undefined, true);\n    return oldObject;\n  };\n\n  protected objectStream<Schema extends JSONSchema>(\n    iterator: ReturnType<typeof Graffiti.prototype.discover<Schema>>,\n  ) {\n    const dispatch = this.synchronizeDispatch.bind(this);\n    const wrapper = async function* () {\n      let result = await iterator.next();\n      while (!result.done) {\n        if (!result.value.error) {\n          dispatch(result.value.value);\n        }\n        yield result.value;\n        result = await iterator.next();\n      }\n      return result.value;\n    };\n    return wrapper();\n  }\n\n  discover: Graffiti[\"discover\"] = (...args) => {\n    const iterator = this.graffiti.discover(...args);\n    return this.objectStream<(typeof args)[1]>(iterator);\n  };\n\n  recoverOrphans: Graffiti[\"recoverOrphans\"] = (...args) => {\n    const iterator = this.graffiti.recoverOrphans(...args);\n    return this.objectStream<(typeof args)[0]>(iterator);\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
 }

package/dist/esm/index.js

@@ -1,2 +1,217 @@
-import{Graffiti as m}from"@graffiti-garden/api";import{Repeater as y}from"@repeaterjs/repeater";import{applyGraffitiPatch as u,compileGraffitiObjectSchema as b,isActorAllowedGraffitiObject as d,locationToUri as G,maskGraffitiObject as S,unpackLocationOrUri as j}from"@graffiti-garden/implementation-local/utilities";class g extends m{ajv_;applyPatch_;graffiti;callbacks=new Set;options;channelStats;locationToUri;uriToLocation;login;logout;sessionEvents;get ajv(){return this.ajv_||(this.ajv_=(async()=>{const{default:t}=await import("ajv");return new t({strict:!1})})()),this.ajv_}get applyPatch(){return this.applyPatch_||(this.applyPatch_=(async()=>{const{applyPatch:t}=await import("fast-json-patch");return t})()),this.applyPatch_}constructor(t,e){super(),this.options=e??{},this.graffiti=t,this.channelStats=t.channelStats.bind(t),this.locationToUri=t.locationToUri.bind(t),this.uriToLocation=t.uriToLocation.bind(t),this.login=t.login.bind(t),this.logout=t.logout.bind(t),this.sessionEvents=t.sessionEvents}synchronize(t,e,a,i){return new y(async(o,n)=>{const s=b(await this.ajv,a),h=(p,l)=>{for(const c of[l,p])if(c&&t(c)&&(this.options.omniscient||d(c,i))){const f={...c};if(this.options.omniscient||S(f,e,i),s(f)){o({value:f});break}}};this.callbacks.add(h),await n,this.callbacks.delete(h)})}synchronizeDiscover(...t){const[e,a,i]=t;function r(o){return o.channels.some(n=>e.includes(n))}return this.synchronize(r,e,a,i)}synchronizeGet(...t){const[e,a,i]=t;function r(o){const n=G(o),{uri:s}=j(e);return n===s}return this.synchronize(r,[],a,i)}synchronizeRecoverOrphans(...t){const[e,a]=t;function i(r){return r.actor===a.actor&&r.channels.length===0}return this.synchronize(i,[],e,a)}synchronizeAll(t,e){return this.synchronize(()=>!0,[],t??{},e)}async synchronizeDispatch(t,e,a=!1){for(const i of this.callbacks)i(t,e);a&&await new Promise(i=>setTimeout(i,0))}get=async(...t)=>{const e=await this.graffiti.get(...t);return this.synchronizeDispatch(e),e};put=async(...t)=>{const e=await this.graffiti.put(...t),a=t[0],i={...e,value:a.value,channels:a.channels,allowed:a.allowed,tombstone:!1};return await this.synchronizeDispatch(e,i,!0),e};patch=async(...t)=>{const e=await this.graffiti.patch(...t),a={...e};a.tombstone=!1;for(const i of["value","channels","allowed"])u(await this.applyPatch,i,t[0],a);return await this.synchronizeDispatch(e,a,!0),e};delete=async(...t)=>{const e=await this.graffiti.delete(...t);return await this.synchronizeDispatch(e,void 0,!0),e};objectStream(t){const e=this.synchronizeDispatch.bind(this);return async function*(){let i=await t.next();for(;!i.done;)i.value.error||e(i.value.value),yield i.value,i=await t.next();return i.value}()}discover=(...t)=>{const e=this.graffiti.discover(...t);return this.objectStream(e)};recoverOrphans=(...t)=>{const e=this.graffiti.recoverOrphans(...t);return this.objectStream(e)}}export{g as GraffitiSynchronize};
+import { Graffiti } from "@graffiti-garden/api";
+import { Repeater } from "@repeaterjs/repeater";
+import {
+  applyGraffitiPatch,
+  compileGraffitiObjectSchema,
+  isActorAllowedGraffitiObject,
+  maskGraffitiObject,
+  unpackLocationOrUri
+} from "@graffiti-garden/implementation-local/utilities";
+class GraffitiSynchronize extends Graffiti {
+  ajv_;
+  applyPatch_;
+  graffiti;
+  callbacks = /* @__PURE__ */ new Set();
+  options;
+  channelStats;
+  login;
+  logout;
+  sessionEvents;
+  get ajv() {
+    if (!this.ajv_) {
+      this.ajv_ = (async () => {
+        const { default: Ajv } = await import("ajv");
+        return new Ajv({ strict: false });
+      })();
+    }
+    return this.ajv_;
+  }
+  get applyPatch() {
+    if (!this.applyPatch_) {
+      this.applyPatch_ = (async () => {
+        const { applyPatch } = await import("fast-json-patch");
+        return applyPatch;
+      })();
+    }
+    return this.applyPatch_;
+  }
+  /**
+   * 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(graffiti, options) {
+    super();
+    this.options = options ?? {};
+    this.graffiti = graffiti;
+    this.channelStats = graffiti.channelStats.bind(graffiti);
+    this.login = graffiti.login.bind(graffiti);
+    this.logout = graffiti.logout.bind(graffiti);
+    this.sessionEvents = graffiti.sessionEvents;
+  }
+  synchronize(matchObject, channels, schema, session) {
+    const repeater = new Repeater(
+      async (push, stop) => {
+        const validate = compileGraffitiObjectSchema(await this.ajv, schema);
+        const callback = (oldObjectRaw, newObjectRaw) => {
+          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {
+            if (objectRaw && matchObject(objectRaw) && (this.options.omniscient || isActorAllowedGraffitiObject(objectRaw, session))) {
+              const object = { ...objectRaw };
+              if (!this.options.omniscient) {
+                maskGraffitiObject(object, channels, session);
+              }
+              if (validate(object)) {
+                push({ value: object });
+                break;
+              }
+            }
+          }
+        };
+        this.callbacks.add(callback);
+        await stop;
+        this.callbacks.delete(callback);
+      }
+    );
+    return repeater;
+  }
+  /**
+   * 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(...args) {
+    const [channels, schema, session] = args;
+    function matchObject(object) {
+      return object.channels.some((channel) => channels.includes(channel));
+    }
+    return this.synchronize(matchObject, channels, schema, session);
+  }
+  /**
+   * 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(...args) {
+    const [locationOrUri, schema, session] = args;
+    const uri = unpackLocationOrUri(locationOrUri);
+    function matchObject(object) {
+      return object.uri === uri;
+    }
+    return this.synchronize(matchObject, [], schema, session);
+  }
+  /**
+   * 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(...args) {
+    const [schema, session] = args;
+    function matchObject(object) {
+      return object.actor === session.actor && object.channels.length === 0;
+    }
+    return this.synchronize(matchObject, [], schema, session);
+  }
+  /**
+   * Streams changes made to *any* object in *any* channel
+   * and made by *any* user. You may want to use it in conjuction with
+   * {@link GraffitiSynchronizeOptions.omniscient} to get a global view
+   * of all Graffiti objects passing through the system. This is useful
+   * for building a client-side cache, for example.
+   *
+   * Be careful using this method. Without additional filters it can
+   * expose the user to content out of context.
+   */
+  synchronizeAll(schema, session) {
+    return this.synchronize(() => true, [], schema ?? {}, session);
+  }
+  async synchronizeDispatch(oldObject, newObject, waitForListeners = false) {
+    for (const callback of this.callbacks) {
+      callback(oldObject, newObject);
+    }
+    if (waitForListeners) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  get = async (...args) => {
+    const object = await this.graffiti.get(...args);
+    this.synchronizeDispatch(object);
+    return object;
+  };
+  put = async (...args) => {
+    const oldObject = await this.graffiti.put(...args);
+    const partialObject = args[0];
+    const newObject = {
+      ...oldObject,
+      value: partialObject.value,
+      channels: partialObject.channels,
+      allowed: partialObject.allowed,
+      tombstone: false
+    };
+    await this.synchronizeDispatch(oldObject, newObject, true);
+    return oldObject;
+  };
+  patch = async (...args) => {
+    const oldObject = await this.graffiti.patch(...args);
+    const newObject = { ...oldObject };
+    newObject.tombstone = false;
+    for (const prop of ["value", "channels", "allowed"]) {
+      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);
+    }
+    await this.synchronizeDispatch(oldObject, newObject, true);
+    return oldObject;
+  };
+  delete = async (...args) => {
+    const oldObject = await this.graffiti.delete(...args);
+    await this.synchronizeDispatch(oldObject, void 0, true);
+    return oldObject;
+  };
+  objectStream(iterator) {
+    const dispatch = this.synchronizeDispatch.bind(this);
+    const wrapper = async function* () {
+      let result = await iterator.next();
+      while (!result.done) {
+        if (!result.value.error) {
+          dispatch(result.value.value);
+        }
+        yield result.value;
+        result = await iterator.next();
+      }
+      return result.value;
+    };
+    return wrapper();
+  }
+  discover = (...args) => {
+    const iterator = this.graffiti.discover(...args);
+    return this.objectStream(iterator);
+  };
+  recoverOrphans = (...args) => {
+    const iterator = this.graffiti.recoverOrphans(...args);
+    return this.objectStream(iterator);
+  };
+}
+export {
+  GraffitiSynchronize
+};
 //# sourceMappingURL=index.js.map