@graffiti-garden/implementation-local 1.0.3 → 1.0.7

package/src/objects.ts

@@ -14,9 +14,9 @@ import {
   maskGraffitiObject,
   isActorAllowedGraffitiObject,
   compileGraffitiObjectSchema,
+  GraffitiErrorCursorExpired,
 } from "@graffiti-garden/api";
 import { randomBase64, decodeObjectUrl, encodeObjectUrl } from "./utilities.js";
-import type Ajv from "ajv";
 
 /**
  * Constructor options for the GraffitiPoubchDB class.
@@ -56,7 +56,6 @@ type ContinueDiscoverParams = {
  */
 export class GraffitiLocalObjects {
   protected db_: Promise<PouchDB.Database<GraffitiObjectData>> | undefined;
-  protected ajv_: Promise<Ajv> | undefined;
   protected readonly options: GraffitiLocalOptions;
 
   get db() {
@@ -111,16 +110,6 @@ export class GraffitiLocalObjects {
     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_;
-  }
-
   protected async getOperationClock() {
     return Number((await (await this.db).info()).update_seq);
   }
@@ -166,13 +155,13 @@ export class GraffitiLocalObjects {
 
     // Mask out the allowed list and channels
     // if the user is not the owner
-    maskGraffitiObject(object, [], session);
+    const masked = maskGraffitiObject(object, [], session?.actor);
 
-    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
-    if (!validate(object)) {
+    const validate = await compileGraffitiObjectSchema(schema);
+    if (!validate(masked)) {
       throw new GraffitiErrorSchemaMismatch();
     }
-    return object;
+    return masked;
   };
 
   delete: Graffiti["delete"] = async (...args) => {
@@ -206,7 +195,16 @@ export class GraffitiLocalObjects {
       throw new GraffitiErrorNotFound("Object not found.");
     }
 
-    return;
+    // Return the output
+    const { value, channels, allowed } = doc;
+    const object: GraffitiObjectBase = {
+      value,
+      channels,
+      allowed,
+      url,
+      actor,
+    };
+    return object;
   };
 
   post: Graffiti["post"] = async (...args) => {
@@ -265,7 +263,7 @@ export class GraffitiLocalObjects {
     }
 
     const [discoverChannels, schema, session] = args;
-    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
+    const validate = await compileGraffitiObjectSchema(schema);
     const startKeySuffix = continueParams
       ? continueParams.ifModifiedSince.toString().padStart(15, "0")
       : "";
@@ -313,16 +311,20 @@ export class GraffitiLocalObjects {
 
         if (!isActorAllowedGraffitiObject(object, session)) continue;
 
-        maskGraffitiObject(object, discoverChannels, session);
+        const masked = maskGraffitiObject(
+          object,
+          discoverChannels,
+          session?.actor,
+        );
 
-        if (!validate(object)) continue;
+        if (!validate(masked)) continue;
 
         yield tombstone
           ? {
               tombstone: true,
               object: { url },
             }
-          : { object };
+          : { object: masked };
       }
     }
 
@@ -429,7 +431,7 @@ export class GraffitiLocalObjects {
       );
     } else {
       return (async function* () {
-        throw new GraffitiErrorNotFound("Cursor not found");
+        throw new GraffitiErrorCursorExpired("Cursor not found");
       })();
     }
   };

package/src/tests.spec.ts

@@ -6,9 +6,10 @@ import {
 import { GraffitiLocal } from "./index";
 
 const useGraffiti = () => new GraffitiLocal();
-const useSession1 = () => ({ actor: "someone" });
-const useSession2 = () => ({ actor: "someoneelse" });
+const useSession1 = () => ({ actor: "did:example:someone" });
+const useSession2 = () => ({ actor: "did:example:someoneelse" });
 
+// @ts-ignore
 graffitiCRUDTests(useGraffiti, useSession1, useSession2);
 graffitiDiscoverTests(useGraffiti, useSession1, useSession2);
 graffitiMediaTests(useGraffiti, useSession1, useSession2);

package/src/utilities.ts

@@ -23,18 +23,22 @@ export function randomBase64(numBytes: number = 32): string {
   return encodeBase64(bytes);
 }
 
-const OBJECT_URL_PREFIX = "graffiti:object:";
-const MEDIA_URL_PREFIX = "graffiti:media:";
+const OBJECT_URL_PREFIX = "graffiti:";
 
+export function encodeObjectUrlComponent(value: string) {
+  const replaced = value.replace(/:/g, "!").replace(/\//g, "~");
+  return encodeURIComponent(replaced);
+}
+export function decodeObjectUrlComponent(value: string) {
+  const decoded = decodeURIComponent(value);
+  return decoded.replace(/!/g, ":").replace(/~/g, "/");
+}
 export function encodeGraffitiUrl(actor: string, id: string, prefix: string) {
-  return `${prefix}${encodeURIComponent(actor)}:${encodeURIComponent(id)}`;
+  return `${prefix}${encodeObjectUrlComponent(actor)}:${encodeObjectUrlComponent(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 decodeGraffitiUrl(url: string, prefix: string) {
   if (!url.startsWith(prefix)) {
@@ -44,15 +48,12 @@ export function decodeGraffitiUrl(url: string, prefix: string) {
   if (slices.length !== 2) {
     throw new GraffitiErrorNotFound("URL has too many colon-seperated parts");
   }
-  const [actor, id] = slices.map(decodeURIComponent);
+  const [actor, id] = slices.map(decodeObjectUrlComponent);
   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") {