@graffiti-garden/api 1.0.1 → 1.0.3

package/src/2-types.ts

@@ -102,7 +102,7 @@ export interface GraffitiObjectBase {
  * Schema-aware objects are returned by {@link Graffiti.get} and {@link Graffiti.discover}.
  */
 export type GraffitiObject<Schema extends JSONSchema> = GraffitiObjectBase &
-  FromSchema<Schema & typeof GraffitiObjectJSONSchema>;
+  FromSchema<Schema & typeof GraffitiPostObjectJSONSchema>;
 
 /**
  * A JSON Schema equivalent to the {@link GraffitiObjectBase} type.
@@ -145,7 +145,6 @@ export type GraffitiPostObject<Schema extends JSONSchema> = Pick<
   GraffitiObjectBase,
   "value" | "channels" | "allowed"
 > &
-  Partial<GraffitiObjectBase> &
   FromSchema<Schema & typeof GraffitiPostObjectJSONSchema>;
 
 /**
@@ -397,3 +396,41 @@ export type GraffitiSessionInitializedEvent = CustomEvent<
   | null
   | undefined
 >;
+
+export type GraffitiMedia = {
+  /**
+   * The binary data of the media to be uploaded,
+   * along with its [media type](https://www.iana.org/assignments/media-types/media-types.xhtml),
+   * formatted as a [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
+   */
+  data: Blob;
+  /**
+   * The {@link GraffitiObjectBase.actor | `actor`} that
+   * {@link Graffiti.postMedia | `post`ed} the media.
+   */
+  actor: string;
+  /**
+   * An optional list, identical in function to an object's
+   * {@link GraffitiObjectBase.allowed | `allowed`} property,
+   * that specifies the {@link GraffitiObjectBase.actor | `actor`}s
+   * who are allowed to access the media. If the list is `undefined`
+   * or `null`, anyone with the URL can access the media. If the list
+   * is empty, only the {@link GraffitiObjectBase.actor | `actor`}
+   * who {@link Graffiti.postMedia | `post`ed} the media can access it.
+   */
+  allowed?: string[] | null;
+};
+
+export type GraffitiPostMedia = Pick<GraffitiMedia, "data" | "allowed">;
+
+export type GraffitiMediaRequirements = {
+  /**
+   * A list of acceptable media types for the retrieved media,
+   * formatted as like an [HTTP Accept header](https://httpwg.org/specs/rfc9110.html#field.accept)
+   */
+  accept?: string;
+  /**
+   * The maximum acceptable size, in bytes, of the media.
+   */
+  maxBytes?: number;
+};

package/src/3-errors.ts

@@ -1,11 +1,3 @@
-export class GraffitiErrorUnauthorized extends Error {
-  constructor(message?: string) {
-    super(message);
-    this.name = "GraffitiErrorUnauthorized";
-    Object.setPrototypeOf(this, GraffitiErrorUnauthorized.prototype);
-  }
-}
-
 export class GraffitiErrorForbidden extends Error {
   constructor(message?: string) {
     super(message);

package/tests/crud.ts

@@ -34,6 +34,12 @@ export const graffitiCRUDTests = (
         session2 = await useSession2();
       });
 
+      it("get nonexistant object", async () => {
+        await expect(graffiti.get(randomString(), {})).rejects.toThrow(
+          GraffitiErrorNotFound,
+        );
+      });
+
       it("post, get, delete", async () => {
         const value = {
           something: "hello, world~ c:",

package/tests/discover.ts

@@ -1,10 +1,14 @@
 import { it, expect, describe, assert, beforeAll } from "vitest";
 import type {
   Graffiti,
-  GraffitiObjectBase,
   GraffitiSession,
   JSONSchema,
 } from "@graffiti-garden/api";
+import {
+  GraffitiErrorForbidden,
+  GraffitiErrorInvalidSchema,
+  GraffitiErrorNotFound,
+} from "@graffiti-garden/api";
 import {
   randomString,
   nextStreamValue,
@@ -103,6 +107,19 @@ export const graffitiDiscoverTests = (
       expect(value.actor).toEqual(session1.actor);
     });
 
+    it("discover bad schema", async () => {
+      const iterator = graffiti.discover([], {
+        properties: {
+          value: {
+            //@ts-ignore
+            type: "asdf",
+          },
+        },
+      });
+
+      await expect(iterator.next()).rejects.toThrow(GraffitiErrorInvalidSchema);
+    });
+
     it("discover for actor", async () => {
       const object1 = randomPostObject();
       const posted1 = await graffiti.post<{}>(object1, session1);
@@ -396,12 +413,47 @@ export const graffitiDiscoverTests = (
           assert(!value.done && !value.value.error, "value is done");
           assert(value.value.tombstone, "value is not tombstone");
           expect(value.value.object.url).toEqual(posted.url);
-          await expect(tombIterator.next()).resolves.toHaveProperty(
+          const returnValue2 = await tombIterator.next();
+          assert(returnValue2.done, "value2 is not done");
+
+          // Post another object
+          const posted2 = await graffiti.post<{}>(object, session);
+          const doubleContinueIterator = continueStream<{}>(
+            graffiti,
+            returnValue2.value,
+            continueType,
+          );
+          const value2 = await doubleContinueIterator.next();
+          assert(!value2.done && !value2.value.error, "value2 is done");
+          assert(!value2.value.tombstone, "value2 is tombstone");
+          expect(value2.value.object.url).toEqual(posted2.url);
+          await expect(doubleContinueIterator.next()).resolves.toHaveProperty(
             "done",
             true,
           );
         });
+
+        it("continue with wrong actor", async () => {
+          const iterator = graffiti.discover<{}>([], {}, session1);
+          const result = await iterator.next();
+          assert(result.done, "iterator is not done");
+
+          const continuation = continueStream<{}>(
+            graffiti,
+            result.value,
+            continueType,
+            session2,
+          );
+          await expect(continuation.next()).rejects.toThrow(
+            GraffitiErrorForbidden,
+          );
+        });
       });
     }
+
+    it("lookup non-existant cursor", async () => {
+      const iterator = graffiti.continueDiscover(randomString());
+      await expect(iterator.next()).rejects.toThrow(GraffitiErrorNotFound);
+    });
   });
 };