@graffiti-garden/implementation-local 0.6.3 → 1.0.0

package/src/objects.ts

@@ -0,0 +1,431 @@
+import type {
+  Graffiti,
+  GraffitiObjectBase,
+  JSONSchema,
+  GraffitiSession,
+  GraffitiObjectStreamContinue,
+  GraffitiObjectStreamContinueEntry,
+} from "@graffiti-garden/api";
+import {
+  GraffitiErrorNotFound,
+  GraffitiErrorSchemaMismatch,
+  GraffitiErrorForbidden,
+  unpackObjectUrl,
+  maskGraffitiObject,
+  isActorAllowedGraffitiObject,
+  compileGraffitiObjectSchema,
+} from "@graffiti-garden/api";
+import { randomBase64, decodeObjectUrl, encodeObjectUrl } from "./utilities.js";
+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 class GraffitiLocalObjects {
+  protected db_: Promise<PouchDB.Database<GraffitiObjectData>> | undefined;
+  protected ajv_: Promise<Ajv> | undefined;
+  protected readonly options: GraffitiLocalOptions;
+  protected operationClock: number = 0;
+
+  get db() {
+    if (!this.db_) {
+      this.db_ = (async () => {
+        const { default: PouchDB } = await import("pouchdb");
+        const pouchDbOptions = {
+          name: "graffitiDb",
+          ...this.options.pouchDBOptions,
+        };
+        const db = new PouchDB<GraffitiObjectData>(
+          pouchDbOptions.name,
+          pouchDbOptions,
+        );
+        await db
+          //@ts-ignore
+          .put({
+            _id: "_design/indexes",
+            views: {
+              objectsPerChannelAndLastModified: {
+                map: function (object: GraffitiObjectData) {
+                  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;
+            }
+          });
+        return db;
+      })();
+    }
+    return this.db_;
+  }
+
+  protected get ajv() {
+    if (!this.ajv_) {
+      this.ajv_ = (async () => {
+        const { default: Ajv } = await import("ajv");
+        return new Ajv({ strict: false });
+      })();
+    }
+    return this.ajv_;
+  }
+
+  constructor(options?: GraffitiLocalOptions) {
+    this.options = options ?? {};
+  }
+
+  get: Graffiti["get"] = async (...args) => {
+    const [urlObject, schema, session] = args;
+    const url = unpackObjectUrl(urlObject);
+
+    let doc: GraffitiObjectData;
+    try {
+      doc = await (await this.db).get(url);
+    } catch (error) {
+      throw new GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it",
+      );
+    }
+
+    if (doc.tombstone) {
+      throw new GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it",
+      );
+    }
+
+    const { actor } = decodeObjectUrl(url);
+    const { value, channels, allowed } = doc;
+    const object: GraffitiObjectBase = {
+      value,
+      channels,
+      allowed,
+      url,
+      actor,
+    };
+
+    if (!isActorAllowedGraffitiObject(object, session)) {
+      throw new GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it",
+      );
+    }
+
+    // Mask out the allowed list and channels
+    // if the user is not the owner
+    maskGraffitiObject(object, [], session);
+
+    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
+    if (!validate(object)) {
+      throw new GraffitiErrorSchemaMismatch();
+    }
+    return object;
+  };
+
+  delete: Graffiti["delete"] = async (...args) => {
+    const [urlObject, session] = args;
+
+    const url = unpackObjectUrl(urlObject);
+    const { actor } = decodeObjectUrl(url);
+    if (actor !== session.actor) {
+      throw new GraffitiErrorForbidden(
+        "You cannot delete an object that you did not create.",
+      );
+    }
+
+    let doc: GraffitiObjectData & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta;
+    try {
+      doc = await (await this.db).get(url);
+    } catch {
+      throw new GraffitiErrorNotFound("Object not found.");
+    }
+
+    if (doc.tombstone) {
+      throw new GraffitiErrorNotFound("Object not found.");
+    }
+
+    // Set the tombstone and update lastModified
+    doc.tombstone = true;
+    doc.lastModified = this.operationClock;
+    try {
+      await (await this.db).put(doc);
+    } catch {
+      throw new GraffitiErrorNotFound("Object not found.");
+    }
+    this.operationClock++;
+
+    return;
+  };
+
+  post: Graffiti["post"] = async (...args) => {
+    const [objectPartial, session] = args;
+
+    const actor = session.actor;
+    const id = randomBase64();
+    const url = encodeObjectUrl(actor, id);
+
+    const { value, channels, allowed } = objectPartial;
+    const object: GraffitiObjectData = {
+      value,
+      channels,
+      allowed,
+      lastModified: this.operationClock,
+      tombstone: false,
+    };
+
+    await (
+      await this.db
+    ).put({
+      _id: url,
+      ...object,
+    });
+    this.operationClock++;
+
+    return {
+      ...objectPartial,
+      actor,
+      url,
+    };
+  };
+
+  protected async *discoverMeta<Schema extends JSONSchema>(
+    args: Parameters<typeof Graffiti.prototype.discover<Schema>>,
+    continueParams?: {
+      lastDiscovered: number;
+      ifModifiedSince: number;
+    },
+  ): AsyncGenerator<
+    GraffitiObjectStreamContinueEntry<Schema>,
+    ContinueDiscoverParams
+  > {
+    // If we are continuing a discover, make sure to wait at
+    // least 2 seconds since the last poll to start a new one.
+    if (continueParams) {
+      const continueBuffer = this.options.continueBuffer ?? 2000;
+      const timeElapsedSinceLastDiscover =
+        Date.now() - continueParams.lastDiscovered;
+      if (timeElapsedSinceLastDiscover < continueBuffer) {
+        // Continue was called too soon,
+        // wait a bit before continuing
+        await new Promise((resolve) =>
+          setTimeout(resolve, continueBuffer - timeElapsedSinceLastDiscover),
+        );
+      }
+    }
+
+    const [discoverChannels, schema, session] = args;
+    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
+    const startKeySuffix = continueParams
+      ? continueParams.ifModifiedSince.toString().padStart(15, "0")
+      : "";
+    const endKeySuffix = "\uffff";
+
+    const processedUrls = new Set<string>();
+
+    const startTime = this.operationClock;
+
+    for (const channel of discoverChannels) {
+      const keyPrefix = encodeURIComponent(channel) + "/";
+      const startkey = keyPrefix + startKeySuffix;
+      const endkey = keyPrefix + endKeySuffix;
+
+      const result = await (
+        await this.db
+      ).query<GraffitiObjectData>("indexes/objectsPerChannelAndLastModified", {
+        startkey,
+        endkey,
+        include_docs: true,
+      });
+
+      for (const row of result.rows) {
+        const doc = row.doc;
+        if (!doc) continue;
+
+        const url = doc._id;
+
+        if (processedUrls.has(url)) continue;
+        processedUrls.add(url);
+
+        // If this is not a continuation, skip tombstones
+        if (!continueParams && doc.tombstone) continue;
+
+        const { tombstone, value, channels, allowed } = doc;
+        const { actor } = decodeObjectUrl(url);
+
+        const object: GraffitiObjectBase = {
+          url,
+          value,
+          allowed,
+          channels,
+          actor,
+        };
+
+        if (!isActorAllowedGraffitiObject(object, session)) continue;
+
+        maskGraffitiObject(object, discoverChannels, session);
+
+        if (!validate(object)) continue;
+
+        yield tombstone
+          ? {
+              tombstone: true,
+              object: { url },
+            }
+          : { object };
+      }
+    }
+
+    return {
+      lastDiscovered: Date.now(),
+      ifModifiedSince: startTime,
+    };
+  }
+
+  protected discoverCursor(
+    args: Parameters<typeof Graffiti.prototype.discover<{}>>,
+    continueParams: {
+      lastDiscovered: number;
+      ifModifiedSince: number;
+    },
+  ): string {
+    const [channels, schema, session] = args;
+    return (
+      "discover:" +
+      JSON.stringify({
+        channels,
+        schema,
+        continueParams,
+        actor: session?.actor,
+      })
+    );
+  }
+
+  protected async *discoverContinue<Schema extends JSONSchema>(
+    args: Parameters<typeof Graffiti.prototype.discover<Schema>>,
+    continueParams: {
+      lastDiscovered: number;
+      ifModifiedSince: number;
+    },
+    session?: GraffitiSession | null,
+  ): GraffitiObjectStreamContinue<Schema> {
+    if (session?.actor !== args[2]?.actor) {
+      throw new GraffitiErrorForbidden(
+        "Cannot continue a cursor started by another actor",
+      );
+    }
+    const iterator = this.discoverMeta<Schema>(args, continueParams);
+
+    while (true) {
+      const result = await iterator.next();
+      if (result.done) {
+        return {
+          continue: (session) =>
+            this.discoverContinue<Schema>(args, result.value, session),
+          cursor: this.discoverCursor(args, result.value),
+        };
+      }
+      yield result.value;
+    }
+  }
+
+  discover: Graffiti["discover"] = (...args) => {
+    const [channels, schema, session] = args;
+    const iterator = this.discoverMeta<(typeof args)[1]>([
+      channels,
+      schema,
+      session,
+    ]);
+
+    const this_ = this;
+    return (async function* () {
+      while (true) {
+        const result = await iterator.next();
+        if (result.done) {
+          return {
+            continue: (session) =>
+              this_.discoverContinue<(typeof args)[1]>(
+                args,
+                result.value,
+                session,
+              ),
+            cursor: this_.discoverCursor(args, result.value),
+          };
+        }
+        // Make sure to filter out tombstones
+        if (result.value.tombstone) continue;
+        yield result.value;
+      }
+    })();
+  };
+
+  continueDiscover: Graffiti["continueDiscover"] = (...args) => {
+    const [cursor, session] = args;
+    if (cursor.startsWith("discover:")) {
+      // TODO: use AJV here
+      const { channels, schema, actor, continueParams } = JSON.parse(
+        cursor.slice("discover:".length),
+      );
+      if (actor && actor !== session?.actor) {
+        throw new GraffitiErrorForbidden(
+          "Cannot continue a cursor started by another actor",
+        );
+      }
+      return this.discoverContinue<{}>(
+        [channels, schema, session],
+        continueParams,
+      );
+    } else {
+      throw new GraffitiErrorNotFound("Cursor not found");
+    }
+  };
+}

package/src/tests.spec.ts

@@ -1,8 +1,7 @@
 import {
   graffitiCRUDTests,
   graffitiDiscoverTests,
-  graffitiOrphanTests,
-  graffitiChannelStatsTests,
+  graffitiMediaTests,
 } from "@graffiti-garden/api/tests";
 import { GraffitiLocal } from "./index";
 
@@ -12,5 +11,4 @@ const useSession2 = () => ({ actor: "someoneelse" });
 
 graffitiCRUDTests(useGraffiti, useSession1, useSession2);
 graffitiDiscoverTests(useGraffiti, useSession1, useSession2);
-graffitiOrphanTests(useGraffiti, useSession1, useSession2);
-graffitiChannelStatsTests(useGraffiti, useSession1, useSession2);
+graffitiMediaTests(useGraffiti, useSession1, useSession2);

package/src/utilities.ts

@@ -1,102 +1,82 @@
-import {
-  GraffitiErrorInvalidSchema,
-  GraffitiErrorPatchError,
-  GraffitiErrorPatchTestFailed,
-} from "@graffiti-garden/api";
-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 function encodeBase64(bytes: Uint8Array): string {
+  // Convert it to base64
+  const base64 = btoa(String.fromCodePoint(...bytes));
+  // Make sure it is url safe
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=+$/, "");
+}
 
-export function unpackObjectUrl(url: string | GraffitiObjectUrl) {
-  return typeof url === "string" ? url : url.url;
+export function decodeBase64(base64Url: string): Uint8Array {
+  // Undo url-safe base64
+  let base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+  // Add padding if necessary
+  while (base64.length % 4 !== 0) base64 += "=";
+  // Decode
+  return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
 }
 
-export function randomBase64(numBytes: number = 24) {
+export function randomBase64(numBytes: number = 32): string {
+  // Generate random bytes
   const bytes = new Uint8Array(numBytes);
   crypto.getRandomValues(bytes);
-  // Convert it to base64
-  const base64 = btoa(String.fromCodePoint(...bytes));
-  // Make sure it is url safe
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=+$/, "");
+  return encodeBase64(bytes);
 }
 
-export function applyGraffitiPatch<Prop extends keyof GraffitiPatch>(
-  apply: typeof applyPatch,
-  prop: Prop,
-  patch: GraffitiPatch,
-  object: GraffitiObjectBase,
-): void {
-  const ops = patch[prop];
-  if (!ops || !ops.length) return;
-  try {
-    object[prop] = apply(object[prop], ops, true, false).newDocument;
-  } catch (e) {
-    if (
-      typeof e === "object" &&
-      e &&
-      "name" in e &&
-      typeof e.name === "string" &&
-      "message" in e &&
-      typeof e.message === "string"
-    ) {
-      if (e.name === "TEST_OPERATION_FAILED") {
-        throw new GraffitiErrorPatchTestFailed(e.message);
-      } else {
-        throw new GraffitiErrorPatchError(e.name + ": " + e.message);
-      }
-    } else {
-      throw e;
-    }
-  }
+const OBJECT_URL_PREFIX = "graffiti:object:";
+const MEDIA_URL_PREFIX = "graffiti:media:";
+
+export function encodeGraffitiUrl(actor: string, id: string, prefix: string) {
+  return `${prefix}${encodeURIComponent(actor)}:${encodeURIComponent(id)}`;
+}
+export function encodeObjectUrl(actor: string, id: string) {
+  return encodeGraffitiUrl(actor, id, OBJECT_URL_PREFIX);
+}
+export function encodeMediaUrl(actor: string, id: string) {
+  return encodeGraffitiUrl(actor, id, MEDIA_URL_PREFIX);
 }
 
-export function compileGraffitiObjectSchema<Schema extends JSONSchema>(
-  ajv: Ajv,
-  schema: Schema,
-) {
-  try {
-    // Force the validation guard because
-    // it is too big for the type checker.
-    // Fortunately json-schema-to-ts is
-    // well tested against ajv.
-    return ajv.compile(schema) as (
-      data: GraffitiObjectBase,
-    ) => data is GraffitiObject<Schema>;
-  } catch (error) {
-    throw new GraffitiErrorInvalidSchema(
-      error instanceof Error ? error.message : undefined,
-    );
+export function decodeGraffitiUrl(url: string, prefix: string) {
+  if (!url.startsWith(prefix)) {
+    throw new Error(`URL does not start with ${prefix}`);
   }
+  const slices = url.slice(prefix.length).split(":");
+  if (slices.length !== 2) {
+    throw new Error("URL has too many colon-seperated parts");
+  }
+  const [actor, id] = slices.map(decodeURIComponent);
+  return { actor, id };
+}
+export function decodeObjectUrl(url: string) {
+  return decodeGraffitiUrl(url, OBJECT_URL_PREFIX);
 }
+export function decodeMediaUrl(url: string) {
+  return decodeGraffitiUrl(url, MEDIA_URL_PREFIX);
+}
+
+export async function blobToBase64(blob: Blob): Promise<string> {
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve, reject) => {
+      const r = new FileReader();
+      r.onload = () => {
+        if (typeof r.result === "string") {
+          resolve(r.result);
+        } else {
+          reject(new Error("Unexpected result type"));
+        }
+      };
+      r.onerror = reject;
+      r.readAsDataURL(blob);
+    });
+  }
 
-export function maskGraffitiObject(
-  object: GraffitiObjectBase,
-  channels: string[],
-  session?: GraffitiSession | null,
-): void {
-  if (object.actor !== session?.actor) {
-    object.allowed = object.allowed && session ? [session.actor] : undefined;
-    object.channels = object.channels.filter((channel) =>
-      channels.includes(channel),
-    );
+  if (typeof Buffer !== "undefined") {
+    const ab = await blob.arrayBuffer();
+    return `data:${blob.type};base64,${Buffer.from(ab).toString("base64")}`;
   }
+
+  throw new Error("Unsupported environment");
 }
-export function isActorAllowedGraffitiObject(
-  object: GraffitiObjectBase,
-  session?: GraffitiSession | null,
-) {
-  return (
-    object.allowed === undefined ||
-    object.allowed === null ||
-    (!!session?.actor &&
-      (object.actor === session.actor ||
-        object.allowed.includes(session.actor)))
-  );
+
+export async function base64ToBlob(dataUrl: string) {
+  const response = await fetch(dataUrl);
+  return await response.blob();
 }