@graffiti-garden/implementation-local 0.6.3 → 1.0.0

package/dist/objects.d.ts

@@ -0,0 +1,63 @@
+import type { Graffiti, JSONSchema, GraffitiSession, GraffitiObjectStreamContinue, GraffitiObjectStreamContinueEntry } from "@graffiti-garden/api";
+import type Ajv from "ajv";
+/**
+ * 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;
+    /**
+     * Wait at least this long (in milliseconds) before continuing a stream.
+     * A basic form of rate limiting. Defaults to 2 seconds.
+     */
+    continueBuffer?: number;
+}
+type GraffitiObjectData = {
+    tombstone: boolean;
+    value: {};
+    channels: string[];
+    allowed?: string[] | null;
+    lastModified: number;
+};
+type ContinueDiscoverParams = {
+    lastDiscovered: number;
+    ifModifiedSince: number;
+};
+/**
+ * An implementation of only the database operations of the
+ * GraffitiAPI without synchronization or session management.
+ */
+export declare class GraffitiLocalObjects {
+    protected db_: Promise<PouchDB.Database<GraffitiObjectData>> | undefined;
+    protected ajv_: Promise<Ajv> | undefined;
+    protected readonly options: GraffitiLocalOptions;
+    protected operationClock: number;
+    get db(): Promise<PouchDB.Database<GraffitiObjectData>>;
+    protected get ajv(): Promise<Ajv>;
+    constructor(options?: GraffitiLocalOptions);
+    get: Graffiti["get"];
+    delete: Graffiti["delete"];
+    post: Graffiti["post"];
+    protected discoverMeta<Schema extends JSONSchema>(args: Parameters<typeof Graffiti.prototype.discover<Schema>>, continueParams?: {
+        lastDiscovered: number;
+        ifModifiedSince: number;
+    }): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>, ContinueDiscoverParams>;
+    protected discoverCursor(args: Parameters<typeof Graffiti.prototype.discover<{}>>, continueParams: {
+        lastDiscovered: number;
+        ifModifiedSince: number;
+    }): string;
+    protected discoverContinue<Schema extends JSONSchema>(args: Parameters<typeof Graffiti.prototype.discover<Schema>>, continueParams: {
+        lastDiscovered: number;
+        ifModifiedSince: number;
+    }, session?: GraffitiSession | null): GraffitiObjectStreamContinue<Schema>;
+    discover: Graffiti["discover"];
+    continueDiscover: Graffiti["continueDiscover"];
+}
+export {};
+//# sourceMappingURL=objects.d.ts.map

package/dist/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../src/objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,UAAU,EACV,eAAe,EACf,4BAA4B,EAC5B,iCAAiC,EAClC,MAAM,sBAAsB,CAAC;AAW9B,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAE3B;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC;IAC7D;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,KAAK,kBAAkB,GAAG;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,EAAE,CAAC;IACV,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,GAAG,SAAS,CAAC;IACzE,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACjD,SAAS,CAAC,cAAc,EAAE,MAAM,CAAK;IAErC,IAAI,EAAE,kDAkDL;IAED,SAAS,KAAK,GAAG,iBAQhB;gBAEW,OAAO,CAAC,EAAE,oBAAoB;IAI1C,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,CA4ClB;IAEF,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAiCxB;IAEF,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CA6BpB;cAEe,YAAY,CAAC,MAAM,SAAS,UAAU,EACrD,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAC5D,cAAc,CAAC,EAAE;QACf,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,GACA,cAAc,CACf,iCAAiC,CAAC,MAAM,CAAC,EACzC,sBAAsB,CACvB;IAoFD,SAAS,CAAC,cAAc,CACtB,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EACxD,cAAc,EAAE;QACd,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,GACA,MAAM;cAaQ,gBAAgB,CAAC,MAAM,SAAS,UAAU,EACzD,IAAI,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAC5D,cAAc,EAAE;QACd,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,EACD,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,4BAA4B,CAAC,MAAM,CAAC;IAqBvC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CA4B5B;IAEF,gBAAgB,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAmB5C;CACH"}

package/dist/utilities.d.ts

@@ -1,10 +1,21 @@
-import type { GraffitiObject, GraffitiObjectBase, GraffitiPatch, JSONSchema, GraffitiSession, GraffitiObjectUrl } from "@graffiti-garden/api";
-import type { Ajv } from "ajv";
-import type { applyPatch } from "fast-json-patch";
-export declare function unpackObjectUrl(url: string | GraffitiObjectUrl): string;
+export declare function encodeBase64(bytes: Uint8Array): string;
+export declare function decodeBase64(base64Url: string): Uint8Array;
 export declare function randomBase64(numBytes?: number): string;
-export declare function applyGraffitiPatch<Prop extends keyof GraffitiPatch>(apply: typeof applyPatch, prop: Prop, patch: GraffitiPatch, object: GraffitiObjectBase): void;
-export declare function compileGraffitiObjectSchema<Schema extends JSONSchema>(ajv: Ajv, schema: Schema): (data: GraffitiObjectBase) => data is GraffitiObject<Schema>;
-export declare function maskGraffitiObject(object: GraffitiObjectBase, channels: string[], session?: GraffitiSession | null): void;
-export declare function isActorAllowedGraffitiObject(object: GraffitiObjectBase, session?: GraffitiSession | null): boolean;
+export declare function encodeGraffitiUrl(actor: string, id: string, prefix: string): string;
+export declare function encodeObjectUrl(actor: string, id: string): string;
+export declare function encodeMediaUrl(actor: string, id: string): string;
+export declare function decodeGraffitiUrl(url: string, prefix: string): {
+    actor: string;
+    id: string;
+};
+export declare function decodeObjectUrl(url: string): {
+    actor: string;
+    id: string;
+};
+export declare function decodeMediaUrl(url: string): {
+    actor: string;
+    id: string;
+};
+export declare function blobToBase64(blob: Blob): Promise<string>;
+export declare function base64ToBlob(dataUrl: string): Promise<Blob>;
 //# sourceMappingURL=utilities.d.ts.map

package/dist/utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,UAE9D;AAED,wBAAgB,YAAY,CAAC,QAAQ,GAAE,MAAW,UAOjD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,SAAS,MAAM,aAAa,EACjE,KAAK,EAAE,OAAO,UAAU,EACxB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,kBAAkB,GACzB,IAAI,CAuBN;AAED,wBAAgB,2BAA2B,CAAC,MAAM,SAAS,UAAU,EACnE,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,UAQJ,kBAAkB,KACrB,IAAI,IAAI,cAAc,CAAC,MAAM,CAAC,CAMtC;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,IAAI,CAON;AACD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,WASjC"}
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKtD;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAO1D;AAED,wBAAgB,YAAY,CAAC,QAAQ,GAAE,MAAW,GAAG,MAAM,CAK1D;AAKD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAE1E;AACD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAExD;AACD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,UAEvD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;EAU5D;AACD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM;;;EAE1C;AACD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM;;;EAEzC;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAsB9D;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,iBAGjD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiti-garden/implementation-local",
-  "version": "0.6.3",
+  "version": "1.0.0",
   "description": "A local implementation of the Graffiti API using PouchDB",
   "types": "./dist/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -17,24 +17,34 @@
         "default": "./dist/cjs/index.js"
       }
     },
-    "./database": {
+    "./objects": {
       "import": {
-        "types": "./dist/database.d.ts",
-        "default": "./dist/esm/database.js"
+        "types": "./dist/objects.d.ts",
+        "default": "./dist/esm/objects.js"
       },
       "require": {
-        "types": "./dist/database.d.ts",
-        "default": "./dist/cjs/database.js"
+        "types": "./dist/objects.d.ts",
+        "default": "./dist/cjs/objects.js"
       }
     },
-    "./session-manager": {
+    "./identity": {
       "import": {
-        "types": "./dist/session-manager.d.ts",
-        "default": "./dist/esm/session-manager.js"
+        "types": "./dist/identity.d.ts",
+        "default": "./dist/esm/identity.js"
       },
       "require": {
-        "types": "./dist/session-manager.d.ts",
-        "default": "./dist/cjs/session-manager.js"
+        "types": "./dist/identity.d.ts",
+        "default": "./dist/cjs/identity.js"
+      }
+    },
+    "./media": {
+      "import": {
+        "types": "./dist/media.d.ts",
+        "default": "./dist/esm/media.js"
+      },
+      "require": {
+        "types": "./dist/media.d.ts",
+        "default": "./dist/cjs/media.js"
       }
     },
     "./utilities": {
@@ -49,8 +59,8 @@
     }
   },
   "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "vitest run src/tests.spec.ts",
+    "test:watch": "vitest --watch",
     "test:coverage": "vitest --coverage",
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "build:js": "tsx esbuild.config.mts",
@@ -73,18 +83,20 @@
     "url": "https://github.com/graffiti-garden/implementation-local/issues"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.0.6",
-    "esbuild": "^0.25.0",
+    "@types/negotiator": "^0.6.4",
+    "@types/node": "^25.0.3",
+    "@types/pouchdb": "^6.4.2",
+    "@vitest/coverage-v8": "^4.0.16",
+    "esbuild": "^0.27.2",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@graffiti-garden/api": "^0.6.3",
-    "@types/pouchdb": "^6.4.2",
+    "@graffiti-garden/api": "^1.0.1",
     "ajv": "^8.17.1",
-    "fast-json-patch": "^3.1.1",
+    "negotiator": "^1.0.0",
     "pouchdb": "^9.0.0"
   }
 }

package/src/identity.ts

@@ -0,0 +1,131 @@
+import type {
+  Graffiti,
+  GraffitiLoginEvent,
+  GraffitiLogoutEvent,
+  GraffitiSessionInitializedEvent,
+} from "@graffiti-garden/api";
+import { decodeBase64, encodeBase64 } from "./utilities";
+
+const DID_LOCAL_PREFIX = "did:local:";
+
+/**
+ * A class that implements the login methods
+ * of the [Graffiti API]() for use in the browser.
+ * It is completely insecure and should only be used
+ * for testing and demonstrations.
+ *
+ * It uses `localStorage` to store login state and
+ * window prompts rather than an oauth flow for log in.
+ * It can be used in node.js but will not persist
+ * login state and a proposed username must be provided.
+ */
+export class GraffitiLocalIdentity {
+  sessionEvents: Graffiti["sessionEvents"] = new EventTarget();
+
+  handleToActor: Graffiti["handleToActor"] = async (handle: string) => {
+    const bytes = new TextEncoder().encode(handle);
+    const base64 = encodeBase64(bytes);
+    return `${DID_LOCAL_PREFIX}${base64}`;
+  };
+
+  actorToHandle: Graffiti["actorToHandle"] = async (actor: string) => {
+    if (!actor.startsWith(DID_LOCAL_PREFIX)) {
+      throw new Error(`actor must start with ${DID_LOCAL_PREFIX}`);
+    }
+    const base64 = actor.slice(DID_LOCAL_PREFIX.length);
+    const bytes = decodeBase64(base64);
+    return new TextDecoder().decode(bytes);
+  };
+
+  constructor() {
+    // Look for any existing sessions
+    const sessionRestorer = async () => {
+      // Allow listeners to be added first
+      await Promise.resolve();
+
+      // Restore previous sessions
+      for (const handle of this.getLoggedInHandles()) {
+        const event: GraffitiLoginEvent = new CustomEvent("login", {
+          detail: { session: { actor: await this.handleToActor(handle) } },
+        });
+        this.sessionEvents.dispatchEvent(event);
+      }
+
+      const event: GraffitiSessionInitializedEvent = new CustomEvent(
+        "initialized",
+        { detail: {} },
+      );
+      this.sessionEvents.dispatchEvent(event);
+    };
+    sessionRestorer();
+  }
+
+  loggedInHandles: string[] = [];
+
+  protected getLoggedInHandles(): string[] {
+    if (typeof window !== "undefined") {
+      const handlesString = window.localStorage.getItem("graffiti-handles");
+      return handlesString
+        ? handlesString.split(",").map(decodeURIComponent)
+        : [];
+    } else {
+      return this.loggedInHandles;
+    }
+  }
+
+  protected setLoggedInHandles(handles: string[]) {
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem("graffiti-handles", handles.join(","));
+    } else {
+      this.loggedInHandles = handles;
+    }
+  }
+
+  login: Graffiti["login"] = async (actor) => {
+    // Wait a tick for the browser to update the UI
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    let handle = actor ? await this.actorToHandle(actor) : undefined;
+
+    if (typeof window !== "undefined") {
+      const response = window.prompt("Choose a username to log in.", handle);
+      handle = response ?? undefined;
+    }
+
+    if (!handle) {
+      const detail: GraffitiLoginEvent["detail"] = {
+        error: new Error("No handle provided to login"),
+      };
+      const event: GraffitiLoginEvent = new CustomEvent("login", { detail });
+      this.sessionEvents.dispatchEvent(event);
+    } else {
+      const existingHandles = this.getLoggedInHandles();
+      if (!existingHandles.includes(handle)) {
+        this.setLoggedInHandles([...existingHandles, handle]);
+      }
+      // Refresh the page to simulate oauth
+      window.location.reload();
+    }
+  };
+
+  logout: Graffiti["logout"] = async (session) => {
+    const handle = await this.actorToHandle(session.actor);
+    const existingHandles = this.getLoggedInHandles();
+    const exists = existingHandles.includes(handle);
+    if (exists) {
+      this.setLoggedInHandles(existingHandles.filter((h) => h !== handle));
+    }
+
+    const detail: GraffitiLogoutEvent["detail"] = exists
+      ? {
+          actor: session.actor,
+        }
+      : {
+          actor: session.actor,
+          error: new Error("Not logged in with that actor"),
+        };
+
+    const event: GraffitiLogoutEvent = new CustomEvent("logout", { detail });
+    this.sessionEvents.dispatchEvent(event);
+  };
+}

package/src/index.ts

@@ -1,9 +1,7 @@
 import { Graffiti, type GraffitiSession } from "@graffiti-garden/api";
-import { GraffitiLocalSessionManager } from "./session-manager.js";
-import {
-  GraffitiLocalDatabase,
-  type GraffitiLocalOptions,
-} from "./database.js";
+import { GraffitiLocalIdentity } from "./identity";
+import { GraffitiLocalObjects, type GraffitiLocalOptions } from "./objects";
+import { GraffitiLocalMedia } from "./media";
 
 export type { GraffitiLocalOptions };
 
@@ -14,36 +12,53 @@ export type { GraffitiLocalOptions };
  * 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 {
-  protected sessionManagerLocal = new GraffitiLocalSessionManager();
-  login = this.sessionManagerLocal.login.bind(this.sessionManagerLocal);
-  logout = this.sessionManagerLocal.logout.bind(this.sessionManagerLocal);
-  sessionEvents = this.sessionManagerLocal.sessionEvents;
+export class GraffitiLocal implements Graffiti {
+  protected graffitiLocalIdentity = new GraffitiLocalIdentity();
+  login = this.graffitiLocalIdentity.login.bind(this.graffitiLocalIdentity);
+  logout = this.graffitiLocalIdentity.logout.bind(this.graffitiLocalIdentity);
+  handleToActor = this.graffitiLocalIdentity.handleToActor.bind(
+    this.graffitiLocalIdentity,
+  );
+  actorToHandle = this.graffitiLocalIdentity.actorToHandle.bind(
+    this.graffitiLocalIdentity,
+  );
+  sessionEvents = this.graffitiLocalIdentity.sessionEvents;
 
-  put: Graffiti["put"];
+  protected graffitiLocalObjects: GraffitiLocalObjects;
+  post: Graffiti["post"];
   get: Graffiti["get"];
-  patch: Graffiti["patch"];
   delete: Graffiti["delete"];
   discover: Graffiti["discover"];
-  recoverOrphans: Graffiti["recoverOrphans"];
-  channelStats: Graffiti["channelStats"];
-  continueObjectStream: Graffiti["continueObjectStream"];
+  continueDiscover: Graffiti["continueDiscover"];
 
-  constructor(options?: GraffitiLocalOptions) {
-    super();
+  protected graffitiLocalMedia: GraffitiLocalMedia;
+  postMedia: Graffiti["postMedia"];
+  getMedia: Graffiti["getMedia"];
+  deleteMedia: Graffiti["deleteMedia"];
 
-    const graffitiPouchDbBase = new GraffitiLocalDatabase(options);
+  constructor(options?: GraffitiLocalOptions) {
+    this.graffitiLocalObjects = new GraffitiLocalObjects(options);
+    this.post = this.graffitiLocalObjects.post.bind(this.graffitiLocalObjects);
+    this.get = this.graffitiLocalObjects.get.bind(this.graffitiLocalObjects);
+    this.delete = this.graffitiLocalObjects.delete.bind(
+      this.graffitiLocalObjects,
+    );
+    this.discover = this.graffitiLocalObjects.discover.bind(
+      this.graffitiLocalObjects,
+    );
+    this.continueDiscover = this.graffitiLocalObjects.continueDiscover.bind(
+      this.graffitiLocalObjects,
+    );
 
-    this.put = graffitiPouchDbBase.put.bind(graffitiPouchDbBase);
-    this.get = graffitiPouchDbBase.get.bind(graffitiPouchDbBase);
-    this.patch = graffitiPouchDbBase.patch.bind(graffitiPouchDbBase);
-    this.delete = graffitiPouchDbBase.delete.bind(graffitiPouchDbBase);
-    this.discover = graffitiPouchDbBase.discover.bind(graffitiPouchDbBase);
-    this.recoverOrphans =
-      graffitiPouchDbBase.recoverOrphans.bind(graffitiPouchDbBase);
-    this.channelStats =
-      graffitiPouchDbBase.channelStats.bind(graffitiPouchDbBase);
-    this.continueObjectStream =
-      graffitiPouchDbBase.continueObjectStream.bind(graffitiPouchDbBase);
+    this.graffitiLocalMedia = new GraffitiLocalMedia(this.graffitiLocalObjects);
+    this.postMedia = this.graffitiLocalMedia.postMedia.bind(
+      this.graffitiLocalMedia,
+    );
+    this.getMedia = this.graffitiLocalMedia.getMedia.bind(
+      this.graffitiLocalMedia,
+    );
+    this.deleteMedia = this.graffitiLocalMedia.deleteMedia.bind(
+      this.graffitiLocalMedia,
+    );
   }
 }

package/src/media.ts

@@ -0,0 +1,106 @@
+import {
+  GraffitiErrorNotAcceptable,
+  GraffitiErrorTooLarge,
+  type Graffiti,
+  type JSONSchema,
+} from "@graffiti-garden/api";
+import {
+  decodeObjectUrl,
+  encodeObjectUrl,
+  decodeMediaUrl,
+  encodeMediaUrl,
+  blobToBase64,
+  base64ToBlob,
+} from "./utilities";
+import Negotiator from "negotiator";
+
+const MEDIA_OBJECT_SCHEMA = {
+  properties: {
+    value: {
+      properties: {
+        dataBase64: { type: "string" },
+        type: { type: "string" },
+        size: { type: "number" },
+      },
+      required: ["dataBase64", "type", "size"],
+    },
+  },
+} as const satisfies JSONSchema;
+
+export class GraffitiLocalMedia {
+  protected db: Pick<Graffiti, "post" | "get" | "delete">;
+
+  constructor(db: Pick<Graffiti, "post" | "get" | "delete">) {
+    this.db = db;
+  }
+
+  postMedia: Graffiti["postMedia"] = async (...args) => {
+    const [media, session] = args;
+
+    const dataBase64 = await blobToBase64(media.data);
+    const type = media.data.type;
+
+    const { url } = await this.db.post<typeof MEDIA_OBJECT_SCHEMA>(
+      {
+        value: {
+          dataBase64,
+          type,
+          size: media.data.size,
+        },
+        channels: [],
+        allowed: media.allowed,
+      },
+      session,
+    );
+
+    const { actor, id } = decodeObjectUrl(url);
+    return encodeMediaUrl(actor, id);
+  };
+
+  getMedia: Graffiti["getMedia"] = async (...args) => {
+    const [mediaUrl, requirements, session] = args;
+    const { actor, id } = decodeMediaUrl(mediaUrl);
+    const objectUrl = encodeObjectUrl(actor, id);
+
+    const object = await this.db.get<typeof MEDIA_OBJECT_SCHEMA>(
+      objectUrl,
+      MEDIA_OBJECT_SCHEMA,
+      session,
+    );
+
+    const { dataBase64, type, size } = object.value;
+
+    if (requirements?.maxBytes && size > requirements.maxBytes) {
+      throw new GraffitiErrorTooLarge("File size exceeds limit");
+    }
+
+    // Make sure it adheres to requirements.accept
+    if (requirements?.accept) {
+      const negotiator = new Negotiator({
+        headers: { accept: requirements.accept },
+      });
+      if (negotiator.mediaType([type]) !== type) {
+        throw new GraffitiErrorNotAcceptable(`Unsupported media type, ${type}`);
+      }
+    }
+
+    const data = await base64ToBlob(dataBase64);
+    if (data.size !== size || data.type !== type) {
+      throw new Error("Invalid data");
+    }
+
+    return {
+      data,
+      actor: object.actor,
+      allowed: object.allowed,
+    };
+  };
+
+  deleteMedia: Graffiti["deleteMedia"] = async (...args) => {
+    const [mediaUrl, session] = args;
+    const { actor, id } = decodeMediaUrl(mediaUrl);
+    const objectUrl = encodeObjectUrl(actor, id);
+
+    await this.db.delete(objectUrl, session);
+  };
+}