@graffiti-garden/implementation-local 0.2.0

package/dist/synchronize.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("ajv-draft-04"),t=require("@repeaterjs/repeater"),n=require("fast-json-patch"),a=require("@graffiti-garden/api");function i(e,t,n,i){const r=n[t];if(r&&r.length)try{i[t]=e(i[t],r,!0,!1).newDocument}catch(e){throw"object"==typeof e&&e&&"name"in e&&"string"==typeof e.name&&"message"in e&&"string"==typeof e.message?"TEST_OPERATION_FAILED"===e.name?new a.GraffitiErrorPatchTestFailed(e.message):new a.GraffitiErrorPatchError(e.name+": "+e.message):e}}function r(e,t,n){e.actor!==n?.actor&&(e.allowed=e.allowed&&n?[n.actor]:void 0,e.channels=e.channels.filter((e=>t.includes(e))))}function s(e,t){return void 0===e.allowed||!!t?.actor&&(e.actor===t.actor||e.allowed.includes(t.actor))}exports.GraffitiSynchronize=class{synchronizeEvents=new EventTarget;ajv;graffiti;constructor(t,n){this.ajv=n??new e({strict:!1}),this.graffiti=t}synchronizeDispatch(e,t){const n=new CustomEvent("change",{detail:{oldObject:e,newObject:t}});this.synchronizeEvents.dispatchEvent(n)}get=async(...e)=>{const t=await this.graffiti.get(...e);return this.synchronizeDispatch(t),t};put=async(...e)=>{const t=await this.graffiti.put(...e),n=e[0],a={...t,value:n.value,channels:n.channels,allowed:n.allowed,tombstone:!1};return this.synchronizeDispatch(t,a),t};patch=async(...e)=>{const t=await this.graffiti.patch(...e),a={...t};a.tombstone=!1;for(const t of["value","channels","allowed"])i(n.applyPatch,t,e[0],a);return this.synchronizeDispatch(t,a),t};delete=async(...e)=>{const t=await this.graffiti.delete(...e);return this.synchronizeDispatch(t),t};discover=(...e)=>{const t=this.graffiti.discover(...e),n=this.synchronizeDispatch.bind(this);return async function*(){let e=await t.next();for(;!e.done;)e.value.error||n(e.value.value),yield e.value,e=await t.next();return e.value}()};synchronize=(...e)=>{const[n,i,c]=e,o=function(e,t){try{return e.compile(t)}catch(e){throw new a.GraffitiErrorInvalidSchema(e instanceof Error?e.message:void 0)}}(this.ajv,i);return new t.Repeater((async(e,t)=>{const a=t=>{const{oldObject:a,newObject:i}=t.detail;for(const t of[i,a])if(t&&t.channels.some((e=>n.includes(e)))&&s(t,c)){const a={...t};if(r(a,n,c),o(a)){e({value:a});break}}};this.synchronizeEvents.addEventListener("change",a),await t,this.synchronizeEvents.removeEventListener("change",a)}))}};
+//# sourceMappingURL=synchronize.cjs.js.map

package/dist/synchronize.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronize.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/synchronize.js

@@ -0,0 +1,2 @@
+import t from"ajv-draft-04";import{Repeater as e}from"@repeaterjs/repeater";import{applyPatch as n}from"fast-json-patch";import{GraffitiErrorPatchTestFailed as a,GraffitiErrorPatchError as s,GraffitiErrorInvalidSchema as i}from"@graffiti-garden/api";function o(t,e,n,i){const o=n[e];if(o&&o.length)try{i[e]=t(i[e],o,!0,!1).newDocument}catch(t){throw"object"==typeof t&&t&&"name"in t&&"string"==typeof t.name&&"message"in t&&"string"==typeof t.message?"TEST_OPERATION_FAILED"===t.name?new a(t.message):new s(t.name+": "+t.message):t}}function r(t,e,n){t.actor!==n?.actor&&(t.allowed=t.allowed&&n?[n.actor]:void 0,t.channels=t.channels.filter((t=>e.includes(t))))}function c(t,e){return void 0===t.allowed||!!e?.actor&&(t.actor===e.actor||t.allowed.includes(e.actor))}class h{synchronizeEvents=new EventTarget;ajv;graffiti;constructor(e,n){this.ajv=n??new t({strict:!1}),this.graffiti=e}synchronizeDispatch(t,e){const n=new CustomEvent("change",{detail:{oldObject:t,newObject:e}});this.synchronizeEvents.dispatchEvent(n)}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),n=t[0],a={...e,value:n.value,channels:n.channels,allowed:n.allowed,tombstone:!1};return this.synchronizeDispatch(e,a),e};patch=async(...t)=>{const e=await this.graffiti.patch(...t),a={...e};a.tombstone=!1;for(const e of["value","channels","allowed"])o(n,e,t[0],a);return this.synchronizeDispatch(e,a),e};delete=async(...t)=>{const e=await this.graffiti.delete(...t);return this.synchronizeDispatch(e),e};discover=(...t)=>{const e=this.graffiti.discover(...t),n=this.synchronizeDispatch.bind(this);return async function*(){let t=await e.next();for(;!t.done;)t.value.error||n(t.value.value),yield t.value,t=await e.next();return t.value}()};synchronize=(...t)=>{const[n,a,s]=t,o=function(t,e){try{return t.compile(e)}catch(t){throw new i(t instanceof Error?t.message:void 0)}}(this.ajv,a);return new e((async(t,e)=>{const a=e=>{const{oldObject:a,newObject:i}=e.detail;for(const e of[i,a])if(e&&e.channels.some((t=>n.includes(t)))&&c(e,s)){const a={...e};if(r(a,n,s),o(a)){t({value:a});break}}};this.synchronizeEvents.addEventListener("change",a),await e,this.synchronizeEvents.removeEventListener("change",a)}))}}export{h as GraffitiSynchronize};
+//# sourceMappingURL=synchronize.js.map

package/dist/synchronize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronize.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/utilities.browser.js

@@ -0,0 +1,2 @@
+class t extends Error{constructor(e){super(e),this.name="GraffitiErrorInvalidSchema",Object.setPrototypeOf(this,t.prototype)}}class e extends Error{constructor(t){super(t),this.name="GraffitiErrorPatchTestFailed",Object.setPrototypeOf(this,e.prototype)}}class o extends Error{constructor(t){super(t),this.name="GraffitiErrorPatchError",Object.setPrototypeOf(this,o.prototype)}}class r extends Error{constructor(t){super(t),this.name="GraffitiErrorInvalidUri",Object.setPrototypeOf(this,r.prototype)}}const n=t=>`${t.source}/${encodeURIComponent(t.actor)}/${encodeURIComponent(t.name)}`,c=t=>{const e=t.split("/"),o=e.pop(),n=e.pop();if(!o||!n||!e.length)throw new r;return{name:decodeURIComponent(o),actor:decodeURIComponent(n),source:e.join("/")}};function s(t=16){const e=new Uint8Array(t);crypto.getRandomValues(e);return btoa(String.fromCodePoint(...e)).replace(/\+/g,"-").replace(/\//g,"_").replace(/\=+$/,"")}function a(t){return"string"==typeof t?{location:c(t),uri:t}:{location:{name:t.name,actor:t.actor,source:t.source},uri:n(t)}}function i(t,r,n,c){const s=n[r];if(s&&s.length)try{c[r]=t(c[r],s,!0,!1).newDocument}catch(t){throw"object"==typeof t&&t&&"name"in t&&"string"==typeof t.name&&"message"in t&&"string"==typeof t.message?"TEST_OPERATION_FAILED"===t.name?new e(t.message):new o(t.name+": "+t.message):t}}function p(e,o){try{return e.compile(o)}catch(e){throw new t(e instanceof Error?e.message:void 0)}}function l(t,e,o){t.actor!==o?.actor&&(t.allowed=t.allowed&&o?[o.actor]:void 0,t.channels=t.channels.filter((t=>e.includes(t))))}function u(t,e){return void 0===t.allowed||!!e?.actor&&(t.actor===e.actor||t.allowed.includes(e.actor))}export{i as applyGraffitiPatch,p as attemptAjvCompile,u as isActorAllowedGraffitiObject,n as locationToUri,l as maskGraffitiObject,s as randomBase64,a as unpackLocationOrUri,c as uriToLocation};
+//# sourceMappingURL=utilities.browser.js.map

package/dist/utilities.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.browser.js","sources":["../node_modules/@graffiti-garden/api/dist/index.js"],"sourcesContent":["class r{objectToUri(r){return this.locationToUri(r)}}class t extends Error{constructor(r){super(r),this.name=\"GraffitiErrorUnauthorized\",Object.setPrototypeOf(this,t.prototype)}}class o extends Error{constructor(r){super(r),this.name=\"GraffitiErrorForbidden\",Object.setPrototypeOf(this,o.prototype)}}class e extends Error{constructor(r){super(r),this.name=\"GraffitiErrorNotFound\",Object.setPrototypeOf(this,e.prototype)}}class s extends Error{constructor(r){super(r),this.name=\"GraffitiErrorInvalidSchema\",Object.setPrototypeOf(this,s.prototype)}}class i extends Error{constructor(r){super(r),this.name=\"GraffitiErrorSchemaMismatch\",Object.setPrototypeOf(this,i.prototype)}}class c extends Error{constructor(r){super(r),this.name=\"GraffitiErrorPatchTestFailed\",Object.setPrototypeOf(this,c.prototype)}}class a extends Error{constructor(r){super(r),this.name=\"GraffitiErrorPatchError\",Object.setPrototypeOf(this,a.prototype)}}class p extends Error{constructor(r){super(r),this.name=\"GraffitiErrorInvalidUri\",Object.setPrototypeOf(this,p.prototype)}}export{r as Graffiti,o as GraffitiErrorForbidden,s as GraffitiErrorInvalidSchema,p as GraffitiErrorInvalidUri,e as GraffitiErrorNotFound,a as GraffitiErrorPatchError,c as GraffitiErrorPatchTestFailed,i as GraffitiErrorSchemaMismatch,t as GraffitiErrorUnauthorized};\n//# sourceMappingURL=index.js.map\n"],"names":["s","Error","constructor","r","super","this","name","Object","setPrototypeOf","prototype","c","a","p"],"mappings":"AAAqa,MAAMA,UAAUC,MAAM,WAAAC,CAAYC,GAAGC,MAAMD,GAAGE,KAAKC,KAAK,6BAA6BC,OAAOC,eAAeH,KAAKL,EAAES,UAAU,EAAiI,MAAMC,UAAUT,MAAM,WAAAC,CAAYC,GAAGC,MAAMD,GAAGE,KAAKC,KAAK,+BAA+BC,OAAOC,eAAeH,KAAKK,EAAED,UAAU,EAAE,MAAME,UAAUV,MAAM,WAAAC,CAAYC,GAAGC,MAAMD,GAAGE,KAAKC,KAAK,0BAA0BC,OAAOC,eAAeH,KAAKM,EAAEF,UAAU,EAAE,MAAMG,UAAUX,MAAM,WAAAC,CAAYC,GAAGC,MAAMD,GAAGE,KAAKC,KAAK,0BAA0BC,OAAOC,eAAeH,KAAKO,EAAEH,UAAU","x_google_ignoreList":[0]}

package/dist/utilities.cjs.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("@graffiti-garden/api");const o=e=>`${e.source}/${encodeURIComponent(e.actor)}/${encodeURIComponent(e.name)}`,r=o=>{const r=o.split("/"),t=r.pop(),n=r.pop();if(!t||!n||!r.length)throw new e.GraffitiErrorInvalidUri;return{name:decodeURIComponent(t),actor:decodeURIComponent(n),source:r.join("/")}};exports.applyGraffitiPatch=function(o,r,t,n){const a=t[r];if(a&&a.length)try{n[r]=o(n[r],a,!0,!1).newDocument}catch(o){throw"object"==typeof o&&o&&"name"in o&&"string"==typeof o.name&&"message"in o&&"string"==typeof o.message?"TEST_OPERATION_FAILED"===o.name?new e.GraffitiErrorPatchTestFailed(o.message):new e.GraffitiErrorPatchError(o.name+": "+o.message):o}},exports.attemptAjvCompile=function(o,r){try{return o.compile(r)}catch(o){throw new e.GraffitiErrorInvalidSchema(o instanceof Error?o.message:void 0)}},exports.isActorAllowedGraffitiObject=function(e,o){return void 0===e.allowed||!!o?.actor&&(e.actor===o.actor||e.allowed.includes(o.actor))},exports.locationToUri=o,exports.maskGraffitiObject=function(e,o,r){e.actor!==r?.actor&&(e.allowed=e.allowed&&r?[r.actor]:void 0,e.channels=e.channels.filter((e=>o.includes(e))))},exports.randomBase64=function(e=16){const o=new Uint8Array(e);return crypto.getRandomValues(o),btoa(String.fromCodePoint(...o)).replace(/\+/g,"-").replace(/\//g,"_").replace(/\=+$/,"")},exports.unpackLocationOrUri=function(e){return"string"==typeof e?{location:r(e),uri:e}:{location:{name:e.name,actor:e.actor,source:e.source},uri:o(e)}},exports.uriToLocation=r;
+//# sourceMappingURL=utilities.cjs.js.map

package/dist/utilities.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/utilities.js

@@ -0,0 +1,2 @@
+import{GraffitiErrorInvalidUri as e,GraffitiErrorPatchTestFailed as o,GraffitiErrorPatchError as n,GraffitiErrorInvalidSchema as t}from"@graffiti-garden/api";const r=e=>`${e.source}/${encodeURIComponent(e.actor)}/${encodeURIComponent(e.name)}`,c=o=>{const n=o.split("/"),t=n.pop(),r=n.pop();if(!t||!r||!n.length)throw new e;return{name:decodeURIComponent(t),actor:decodeURIComponent(r),source:n.join("/")}};function a(e=16){const o=new Uint8Array(e);crypto.getRandomValues(o);return btoa(String.fromCodePoint(...o)).replace(/\+/g,"-").replace(/\//g,"_").replace(/\=+$/,"")}function i(e){return"string"==typeof e?{location:c(e),uri:e}:{location:{name:e.name,actor:e.actor,source:e.source},uri:r(e)}}function s(e,t,r,c){const a=r[t];if(a&&a.length)try{c[t]=e(c[t],a,!0,!1).newDocument}catch(e){throw"object"==typeof e&&e&&"name"in e&&"string"==typeof e.name&&"message"in e&&"string"==typeof e.message?"TEST_OPERATION_FAILED"===e.name?new o(e.message):new n(e.name+": "+e.message):e}}function l(e,o){try{return e.compile(o)}catch(e){throw new t(e instanceof Error?e.message:void 0)}}function m(e,o,n){e.actor!==n?.actor&&(e.allowed=e.allowed&&n?[n.actor]:void 0,e.channels=e.channels.filter((e=>o.includes(e))))}function p(e,o){return void 0===e.allowed||!!o?.actor&&(e.actor===o.actor||e.allowed.includes(o.actor))}export{s as applyGraffitiPatch,l as attemptAjvCompile,p as isActorAllowedGraffitiObject,r as locationToUri,m as maskGraffitiObject,a as randomBase64,i as unpackLocationOrUri,c as uriToLocation};
+//# sourceMappingURL=utilities.js.map

package/dist/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@graffiti-garden/implementation-local",
+  "version": "0.2.0",
+  "description": "A local-only implementation of the Graffiti API using PouchDB",
+  "types": "./dist/src/index.d.ts",
+  "module": "./dist/index.js",
+  "browser": "./dist/index.browser.js",
+  "main": "./dist/index.cjs.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/src/index.d.ts",
+        "node": "./dist/index.cjs.js",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/src/index.d.ts",
+        "default": "./dist/index.cjs.js"
+      }
+    },
+    "./database": {
+      "import": {
+        "types": "./dist/src/database.d.ts",
+        "node": "./dist/database.cjs.js",
+        "default": "./dist/database.js"
+      },
+      "require": {
+        "types": "./dist/src/database.d.ts",
+        "default": "./dist/database.cjs.js"
+      }
+    },
+    "./session-manager": {
+      "import": {
+        "types": "./dist/src/session-manager-local.d.ts",
+        "node": "./dist/session-manager-local.cjs.js",
+        "default": "./dist/session-manager-local.js"
+      },
+      "require": {
+        "types": "./dist/src/session-manager-local.d.ts",
+        "default": "./dist/session-manager-local.cjs.js"
+      }
+    },
+    "./synchronize": {
+      "import": {
+        "types": "./dist/src/synchronize.d.ts",
+        "node": "./dist/synchronize.cjs.js",
+        "default": "./dist/synchronize.js"
+      },
+      "require": {
+        "types": "./dist/src/synchronize.d.ts",
+        "default": "./dist/synchronize.cjs.js"
+      }
+    },
+    "./utilities": {
+      "import": {
+        "types": "./dist/src/utilities.d.ts",
+        "node": "./dist/utilities.cjs.js",
+        "default": "./dist/utilities.js"
+      },
+      "require": {
+        "types": "./dist/src/utilities.d.ts",
+        "default": "./dist/utilities.cjs.js"
+      }
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --coverage",
+    "build": "rollup -c rollup.config.ts --configPlugin rollup-plugin-typescript2",
+    "prepublishOnly": "npm update && npm test && npm run build"
+  },
+  "files": [
+    "src",
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "author": "Theia Henderson",
+  "license": "GPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graffiti-garden/implementation-pouchdb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/graffiti-garden/implementation-pouchdb/issues"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@vitest/coverage-v8": "^2.1.8",
+    "rollup": "^4.30.1",
+    "rollup-plugin-node-polyfills": "^0.2.1",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "rollup-plugin-visualizer": "^5.14.0",
+    "tslib": "^2.8.1",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "@graffiti-garden/api": "^0.1.10",
+    "@repeaterjs/repeater": "^3.0.6",
+    "@types/pouchdb": "^6.4.2",
+    "ajv": "^8.17.1",
+    "ajv-draft-04": "^1.0.0",
+    "fast-json-patch": "^3.1.1",
+    "pouchdb": "^9.0.0"
+  }
+}

package/src/database.ts

@@ -0,0 +1,450 @@
+import type {
+  Graffiti,
+  GraffitiObjectBase,
+  GraffitiLocation,
+} from "@graffiti-garden/api";
+import {
+  GraffitiErrorNotFound,
+  GraffitiErrorSchemaMismatch,
+  GraffitiErrorForbidden,
+  GraffitiErrorPatchError,
+} from "@graffiti-garden/api";
+import PouchDB from "pouchdb";
+import {
+  locationToUri,
+  unpackLocationOrUri,
+  randomBase64,
+  applyGraffitiPatch,
+  attemptAjvCompile,
+  maskGraffitiObject,
+  isActorAllowedGraffitiObject,
+} from "./utilities";
+import { Repeater } from "@repeaterjs/repeater";
+import Ajv from "ajv-draft-04";
+import { applyPatch } from "fast-json-patch";
+
+/**
+ * Constructor options for the GraffitiPoubchDB class.
+ */
+export interface GraffitiLocalOptions {
+  /**
+   * Options to pass to the PouchDB constructor.
+   * Defaults to `{ name: "graffitiDb" }`.
+   *
+   * See the [PouchDB documentation](https://pouchdb.com/api.html#create_database)
+   * for available options.
+   */
+  pouchDBOptions?: PouchDB.Configuration.DatabaseConfiguration;
+  /**
+   * Defines the name of the {@link https://api.graffiti.garden/interfaces/GraffitiObjectBase.html#source | `source` }
+   * under which to store objects.
+   * Defaults to `"local"`.
+   */
+  sourceName?: string;
+  /**
+   * The time in milliseconds to keep tombstones before deleting them.
+   * See the {@link https://api.graffiti.garden/classes/Graffiti.html#discover | `discover` }
+   * documentation for more information.
+   */
+  tombstoneRetention?: number;
+}
+
+/**
+ * An implementation of only the database operations of the
+ * GraffitiAPI without synchronization or session management.
+ */
+export class GraffitiLocalDatabase
+  implements
+    Pick<
+      Graffiti,
+      | "get"
+      | "put"
+      | "patch"
+      | "delete"
+      | "discover"
+      | "listChannels"
+      | "listOrphans"
+    >
+{
+  protected readonly db: PouchDB.Database<GraffitiObjectBase>;
+  protected readonly source: string = "local";
+  protected readonly tombstoneRetention: number = 86400000; // 1 day in ms
+  protected readonly ajv: Ajv;
+
+  constructor(options?: GraffitiLocalOptions, ajv?: Ajv) {
+    this.ajv = ajv ?? new Ajv({ strict: false });
+    this.source = options?.sourceName ?? this.source;
+    this.tombstoneRetention =
+      options?.tombstoneRetention ?? this.tombstoneRetention;
+    const pouchDbOptions = {
+      name: "graffitiDb",
+      ...options?.pouchDBOptions,
+    };
+    this.db = new PouchDB<GraffitiObjectBase>(
+      pouchDbOptions.name,
+      pouchDbOptions,
+    );
+
+    this.db
+      //@ts-ignore
+      .put({
+        _id: "_design/index3",
+        views: {
+          byChannelAndLastModified: {
+            map: function (object: GraffitiObjectBase) {
+              const paddedLastModified = object.lastModified
+                .toString()
+                .padStart(15, "0");
+              object.channels.forEach(function (channel) {
+                const id =
+                  encodeURIComponent(channel) + "/" + paddedLastModified;
+                //@ts-ignore
+                emit(id);
+              });
+            }.toString(),
+          },
+        },
+      })
+      //@ts-ignore
+      .catch((error) => {
+        if (
+          error &&
+          typeof error === "object" &&
+          "name" in error &&
+          error.name === "conflict"
+        ) {
+          // Design document already exists
+          return;
+        } else {
+          throw error;
+        }
+      });
+  }
+
+  protected async queryByLocation(location: GraffitiLocation) {
+    const uri = locationToUri(location) + "/";
+    const results = await this.db.allDocs({
+      startkey: uri,
+      endkey: uri + "\uffff", // \uffff is the last unicode character
+      include_docs: true,
+    });
+    const docs = results.rows
+      .map((row) => row.doc)
+      // Remove undefined docs
+      .reduce<
+        PouchDB.Core.ExistingDocument<
+          GraffitiObjectBase & PouchDB.Core.AllDocsMeta
+        >[]
+      >((acc, doc) => {
+        if (doc) acc.push(doc);
+        return acc;
+      }, [])
+      // Remove tombstones
+      .filter((doc) => !doc.tombstone);
+    return docs;
+  }
+
+  protected docId(location: GraffitiLocation) {
+    return locationToUri(location) + "/" + randomBase64();
+  }
+
+  get: Graffiti["get"] = async (...args) => {
+    const [locationOrUri, schema, session] = args;
+    const { location } = unpackLocationOrUri(locationOrUri);
+
+    const docs = await this.queryByLocation(location);
+    if (!docs.length) throw new GraffitiErrorNotFound();
+
+    // Get the most recent document
+    const doc = docs.reduce((a, b) =>
+      a.lastModified > b.lastModified ? a : b,
+    );
+
+    // Strip out the _id and _rev
+    const { _id, _rev, ...object } = doc;
+
+    // Make sure the user is allowed to see it
+    if (!isActorAllowedGraffitiObject(doc, session))
+      throw new GraffitiErrorNotFound();
+
+    // Mask out the allowed list and channels
+    // if the user is not the owner
+    maskGraffitiObject(object, [], session);
+
+    const validate = attemptAjvCompile(this.ajv, schema);
+    if (!validate(object)) {
+      throw new GraffitiErrorSchemaMismatch();
+    }
+    return object;
+  };
+
+  /**
+   * Deletes all docs at a particular location.
+   * If the `keepLatest` flag is set to true,
+   * the doc with the most recent timestamp will be
+   * spared. If there are multiple docs with the same
+   * timestamp, the one with the highest `_id` will be
+   * spared.
+   */
+  protected async deleteAtLocation(
+    location: GraffitiLocation,
+    keepLatest: boolean = false,
+  ) {
+    const docsAtLocation = await this.queryByLocation(location);
+    if (!docsAtLocation.length) return undefined;
+
+    // Get the most recent lastModified timestamp.
+    const latestModified = docsAtLocation
+      .map((doc) => doc.lastModified)
+      .reduce((a, b) => (a > b ? a : b));
+
+    // Delete all old docs
+    const docsToDelete = docsAtLocation.filter(
+      (doc) => !keepLatest || doc.lastModified < latestModified,
+    );
+
+    // For docs with the same timestamp,
+    // keep the one with the highest _id
+    // to break concurrency ties
+    const concurrentDocsAll = docsAtLocation.filter(
+      (doc) => keepLatest && doc.lastModified === latestModified,
+    );
+    if (concurrentDocsAll.length) {
+      const keepDocId = concurrentDocsAll
+        .map((doc) => doc._id)
+        .reduce((a, b) => (a > b ? a : b));
+      const concurrentDocsToDelete = concurrentDocsAll.filter(
+        (doc) => doc._id !== keepDocId,
+      );
+      docsToDelete.push(...concurrentDocsToDelete);
+    }
+
+    const lastModified = keepLatest ? latestModified : new Date().getTime();
+
+    let deletedObject: GraffitiObjectBase | undefined = undefined;
+    // Go through documents oldest to newest
+    for (const doc of docsToDelete.sort(
+      (a, b) => a.lastModified - b.lastModified,
+    )) {
+      // Change it's tombstone to true
+      // and update it's timestamp
+      const deletedDoc = {
+        ...doc,
+        tombstone: true,
+        lastModified,
+      };
+      try {
+        await this.db.put(deletedDoc);
+      } catch (error) {
+        if (
+          error &&
+          typeof error === "object" &&
+          "name" in error &&
+          error.name === "conflict"
+        ) {
+          // Document was already deleted
+          continue;
+        }
+      }
+      const { _id, _rev, ...object } = deletedDoc;
+      deletedObject = object;
+    }
+
+    return deletedObject;
+  }
+
+  delete: Graffiti["delete"] = async (...args) => {
+    const [locationOrUri, session] = args;
+    const { location } = unpackLocationOrUri(locationOrUri);
+    if (location.actor !== session.actor) {
+      throw new GraffitiErrorForbidden();
+    }
+
+    const deletedObject = await this.deleteAtLocation(location);
+    if (!deletedObject) {
+      throw new GraffitiErrorNotFound();
+    }
+    return deletedObject;
+  };
+
+  put: Graffiti["put"] = async (...args) => {
+    const [objectPartial, session] = args;
+    if (objectPartial.actor && objectPartial.actor !== session.actor) {
+      throw new GraffitiErrorForbidden();
+    }
+
+    const object: GraffitiObjectBase = {
+      value: objectPartial.value,
+      channels: objectPartial.channels,
+      allowed: objectPartial.allowed,
+      name: objectPartial.name ?? randomBase64(),
+      source: objectPartial.source ?? this.source,
+      actor: session.actor,
+      tombstone: false,
+      lastModified: new Date().getTime(),
+    };
+
+    await this.db.put({
+      _id: this.docId(object),
+      ...object,
+    });
+
+    // Delete the old object
+    const previousObject = await this.deleteAtLocation(object, true);
+    if (previousObject) {
+      return previousObject;
+    } else {
+      return {
+        ...object,
+        value: {},
+        channels: [],
+        allowed: undefined,
+        tombstone: true,
+      };
+    }
+  };
+
+  patch: Graffiti["patch"] = async (...args) => {
+    const [patch, locationOrUri, session] = args;
+    const { location } = unpackLocationOrUri(locationOrUri);
+    if (location.actor !== session.actor) {
+      throw new GraffitiErrorForbidden();
+    }
+    const originalObject = await this.get(locationOrUri, {}, session);
+
+    // Patch it outside of the database
+    const patchObject: GraffitiObjectBase = { ...originalObject };
+    for (const prop of ["value", "channels", "allowed"] as const) {
+      applyGraffitiPatch(applyPatch, prop, patch, patchObject);
+    }
+
+    // Make sure the value is an object
+    if (
+      typeof patchObject.value !== "object" ||
+      Array.isArray(patchObject.value) ||
+      !patchObject.value
+    ) {
+      throw new GraffitiErrorPatchError("value is no longer an object");
+    }
+
+    // Make sure the channels are an array of strings
+    if (
+      !Array.isArray(patchObject.channels) ||
+      !patchObject.channels.every((channel) => typeof channel === "string")
+    ) {
+      throw new GraffitiErrorPatchError(
+        "channels are no longer an array of strings",
+      );
+    }
+
+    // Make sure the allowed list is an array of strings or undefined
+    if (
+      patchObject.allowed &&
+      (!Array.isArray(patchObject.allowed) ||
+        !patchObject.allowed.every((allowed) => typeof allowed === "string"))
+    ) {
+      throw new GraffitiErrorPatchError(
+        "allowed list is not an array of strings",
+      );
+    }
+
+    patchObject.lastModified = new Date().getTime();
+    await this.db.put({
+      ...patchObject,
+      _id: this.docId(patchObject),
+    });
+
+    // Delete the old object
+    await this.deleteAtLocation(patchObject, true);
+
+    return {
+      ...originalObject,
+      tombstone: true,
+      lastModified: patchObject.lastModified,
+    };
+  };
+
+  discover: Graffiti["discover"] = (...args) => {
+    const [channels, schema, session] = args;
+
+    const validate = attemptAjvCompile(this.ajv, schema);
+
+    // Use the index for queries over ranges of lastModified
+    let startKeyAppend = "";
+    let endKeyAppend = "\uffff";
+    const lastModifiedSchema = schema.properties?.lastModified;
+    if (lastModifiedSchema?.minimum) {
+      let minimum = Math.ceil(lastModifiedSchema.minimum);
+      minimum === lastModifiedSchema.minimum &&
+        lastModifiedSchema.exclusiveMinimum &&
+        minimum++;
+      startKeyAppend = minimum.toString().padStart(15, "0");
+    }
+    if (lastModifiedSchema?.maximum) {
+      let maximum = Math.floor(lastModifiedSchema.maximum);
+      maximum === lastModifiedSchema.maximum &&
+        lastModifiedSchema.exclusiveMaximum &&
+        maximum--;
+      endKeyAppend = maximum.toString().padStart(15, "0");
+    }
+
+    const repeater: ReturnType<
+      typeof Graffiti.prototype.discover<typeof schema>
+    > = new Repeater(async (push, stop) => {
+      const processedIds = new Set<string>();
+
+      for (const channel of channels) {
+        const encodedChannel = encodeURIComponent(channel);
+        const startkey = encodedChannel + "/" + startKeyAppend;
+        const endkey = encodedChannel + "/" + endKeyAppend;
+
+        const result = await this.db.query<GraffitiObjectBase>(
+          "index3/byChannelAndLastModified",
+          { startkey, endkey, include_docs: true },
+        );
+
+        for (const row of result.rows) {
+          const doc = row.doc;
+          if (!doc) continue;
+
+          const { _id, _rev, ...object } = doc;
+
+          // Don't double return the same object
+          // (which can happen if it's in multiple channels)
+          if (processedIds.has(_id)) continue;
+          processedIds.add(_id);
+
+          // Make sure the user is allowed to see it
+          if (!isActorAllowedGraffitiObject(doc, session)) continue;
+
+          // Mask out the allowed list and channels
+          // if the user is not the owner
+          maskGraffitiObject(object, channels, session);
+
+          // Check that it matches the schema
+          if (validate(object)) {
+            push({
+              value: object,
+            });
+          }
+        }
+      }
+      stop();
+      return {
+        tombstoneRetention: this.tombstoneRetention,
+      };
+    });
+
+    return repeater;
+  };
+
+  listChannels: Graffiti["listChannels"] = (...args) => {
+    // TODO
+    return (async function* () {})();
+  };
+
+  listOrphans: Graffiti["listOrphans"] = (...args) => {
+    // TODO
+    return (async function* () {})();
+  };
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+import { Graffiti } from "@graffiti-garden/api";
+import Ajv from "ajv-draft-04";
+import { GraffitiLocalSessionManager } from "./session-manager";
+import { GraffitiLocalDatabase, type GraffitiLocalOptions } from "./database";
+import { GraffitiSynchronize } from "./synchronize";
+import { locationToUri, uriToLocation } from "./utilities";
+
+/**
+ * A local implementation of the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)
+ * based on [PouchDB](https://pouchdb.com/). PouchDb will automatically persist data in a local
+ * database, either in the browser or in Node.js.
+ * It can also be configured to work with an external [CouchDB](https://couchdb.apache.org/) server,
+ * although using it with a remote server will not be secure.
+ */
+export class GraffitiLocal extends Graffiti {
+  locationToUri = locationToUri;
+  uriToLocation = uriToLocation;
+
+  login: Graffiti["login"];
+  logout: Graffiti["logout"];
+  sessionEvents: Graffiti["sessionEvents"];
+  put: Graffiti["put"];
+  get: Graffiti["get"];
+  patch: Graffiti["patch"];
+  delete: Graffiti["delete"];
+  discover: Graffiti["discover"];
+  synchronize: Graffiti["synchronize"];
+  listChannels: Graffiti["listChannels"];
+  listOrphans: Graffiti["listOrphans"];
+
+  constructor(options?: GraffitiLocalOptions) {
+    super();
+
+    const sessionManagerLocal = new GraffitiLocalSessionManager();
+    this.login = sessionManagerLocal.login.bind(sessionManagerLocal);
+    this.logout = sessionManagerLocal.logout.bind(sessionManagerLocal);
+    this.sessionEvents = sessionManagerLocal.sessionEvents;
+
+    const ajv = new Ajv({ strict: false });
+    const graffitiPouchDbBase = new GraffitiLocalDatabase(options, ajv);
+    const graffitiSynchronize = new GraffitiSynchronize(
+      graffitiPouchDbBase,
+      ajv,
+    );
+
+    this.put = graffitiSynchronize.put.bind(graffitiSynchronize);
+    this.get = graffitiSynchronize.get.bind(graffitiSynchronize);
+    this.patch = graffitiSynchronize.patch.bind(graffitiSynchronize);
+    this.delete = graffitiSynchronize.delete.bind(graffitiSynchronize);
+    this.discover = graffitiSynchronize.discover.bind(graffitiSynchronize);
+    this.synchronize =
+      graffitiSynchronize.synchronize.bind(graffitiSynchronize);
+    this.listChannels =
+      graffitiPouchDbBase.listChannels.bind(graffitiPouchDbBase);
+    this.listOrphans =
+      graffitiPouchDbBase.listOrphans.bind(graffitiPouchDbBase);
+  }
+}