@graffiti-garden/api 0.2.0 → 0.2.2

package/src/1-api.ts

@@ -6,6 +6,7 @@ import type {
   GraffitiSession,
   GraffitiPutObject,
   GraffitiStream,
+  ChannelStats,
 } from "./2-types";
 import type { JSONSchema4 } from "json-schema";
 
@@ -23,6 +24,7 @@ import type { JSONSchema4 } from "json-schema";
  *
  * There are several different implementations of this Graffiti API available,
  * including a [federated implementation](https://github.com/graffiti-garden/implementation-federated),
+ * that lets users choose where their data is stored,
  * and a [local implementation](https://github.com/graffiti-garden/implementation-local)
  * that can be used for testing and development. In our design of Graffiti, this API is our
  * primary focus as it is the layer that shapes the experience
@@ -36,22 +38,28 @@ import type { JSONSchema4 } from "json-schema";
  *
  * ## Overview
  *
- * This API tries to draw from well-known concepts and standards wherever possible.
- * JSON objects, representing social artifacts (e.g. posts, profiles) and activities
- * (e.g. likes, follows) can be interacted with through standard CRUD operations:
+ * Graffiti provides applications with methods to create and store data
+ * on behalf of their users using standard CRUD operations:
  *  {@link put}, {@link get}, {@link patch}, and {@link delete}.
- * Objects can be typed with [JSON Schema](https://json-schema.org/) and patches
- * can be applied with [JSON Patch](https://jsonpatch.com).
- * For interoperability between Graffiti applications, we recommend using established properties from the
- * [Activity Vocabulary](https://www.w3.org/TR/activitystreams-vocabulary/) when available.
+ * This data can represent both social artifacts (e.g. posts, profiles) and
+ * activities (e.g. likes, follows) and is stored as JSON.
  *
- * The social aspect of Graffiti comes from the {@link discover} operation
+ * The social aspect of Graffiti comes from the {@link discover} method
  * which allows applications to find objects that other users made.
  * It is a lot like a traditional query operation, but it only
  * returns objects that have been placed in particular
  * {@link GraffitiObjectBase.channels | `channels`}
  * specified by the discovering application.
  *
+ * Graffiti builds on well known concepts and standards wherever possible.
+ * JSON Objects can be typed with [JSON Schema](https://json-schema.org/) and patches
+ * can be applied with [JSON Patch](https://jsonpatch.com).
+ * For interoperability between Graffiti applications, we recommend that
+ * objects use established properties from the
+ * [Activity Vocabulary](https://www.w3.org/TR/activitystreams-vocabulary/) when available,
+ * however it is always possible to create additional properties, contributing
+ * to the broader [folksonomy](https://en.wikipedia.org/wiki/Folksonomy).
+ *
  * {@link GraffitiObjectBase.channels | `channels`} are one of the major concepts
  * unique to Graffiti along with *interaction relativity*.
  * Channels create boundaries between public spaces and work to prevent
@@ -231,19 +239,17 @@ import type { JSONSchema4 } from "json-schema";
  *
  * ## TODO
  *
- * - Test for listChannels and listOrphans,
  * - Implement scope.
  *
  * @groupDescription CRUD Methods
  * Methods for {@link put | creating}, {@link get | reading}, {@link patch | updating},
  * and {@link delete | deleting} {@link GraffitiObjectBase | Graffiti objects}.
  * @groupDescription Query Methods
- * Methods for retrieving multiple {@link GraffitiObjectBase | Graffiti objects} at a time.
+ * Methods that retrieve or accumulate information about multiple {@link GraffitiObjectBase | Graffiti objects} at a time.
  * @groupDescription Session Management
  * Methods and properties for logging in and out of a Graffiti implementation.
  * @groupDescription Utilities
- * Methods for for converting Graffiti objects to and from URIs
- * and for finding lost objects.
+ * Methods for for converting Graffiti objects to and from URIs.
  */
 export abstract class Graffiti {
   /**
@@ -313,14 +319,26 @@ export abstract class Graffiti {
 
   /**
    * Retrieves an object from a given location.
-   * If no object exists at that location or if the retrieving
-   * {@link GraffitiObjectBase.actor | `actor`} is not the creator or included in
-   * the object's {@link GraffitiObjectBase.allowed | `allowed`} property,
-   * a {@link GraffitiErrorNotFound} is thrown.
    *
-   * The retrieved object is also type-checked against the provided [JSON schema](https://json-schema.org/)
+   * The retrieved object is type-checked against the provided [JSON schema](https://json-schema.org/)
    * otherwise a {@link GraffitiErrorSchemaMismatch} is thrown.
    *
+   * If the object existed but has since been deleted,
+   * or the retrieving {@link GraffitiObjectBase.actor | `actor`}
+   * was {@link GraffitiObjectBase.allowed | `allowed`} to access
+   * the object but now isn't, this method will return the latest
+   * version of the object that the {@link GraffitiObjectBase.actor | `actor`}
+   * was allowed to access with its {@link GraffitiObjectBase.tombstone | `tombstone`}
+   * set to `true`, so long as that version is still cached.
+   *
+   * Otherwise, if the object never existed, or the
+   * retrieving {@link GraffitiObjectBase.actor | `actor`} was never
+   * {@link GraffitiObjectBase.allowed | `allowed`} to access it, or if
+   * the object was changed long enough ago that its history has been
+   * purged from the cache, a {@link GraffitiErrorNotFound} is thrown.
+   * The rate at which the cache is purged is implementation dependent.
+   * See the `tombstoneReturn` property returned by {@link discover}.
+   *
    * @group CRUD Methods
    */
   abstract get<Schema extends JSONSchema4>(
@@ -417,7 +435,7 @@ export abstract class Graffiti {
    * not specified by the `discover` method will not be revealed. This masking happens
    * before the supplied schema is applied.
    *
-   * {@link discover} can be used in conjunction with {@link synchronize}
+   * {@link discover} can be used in conjunction with {@link synchronizeDiscover}
    * to provide a responsive and consistent user experience.
    *
    * Since different implementations may fetch data from multiple sources there is
@@ -487,129 +505,57 @@ export abstract class Graffiti {
   >;
 
   /**
-   * This method has the same signature as {@link discover} but listens for
-   * changes made via {@link put}, {@link patch}, and {@link delete} or
-   * fetched from {@link get} or {@link discover} and then streams appropriate
-   * changes to provide a responsive and consistent user experience.
-   *
-   * Unlike {@link discover}, this method continuously listens for changes
-   * and will not terminate unless the user calls the `return` method on the iterator
-   * or `break`s out of the loop.
-   *
-   * Example 1: Suppose a user publishes a post using {@link put}. If the feed
-   * displaying that user's posts is using {@link synchronize} to listen for changes,
-   * then the user's new post will instantly appear in their feed, giving the UI a
-   * responsive feel.
-   *
-   * Example 2: Suppose one of a user's friends changes their name. As soon as the
-   * user's application receives one notice of that change (using {@link get}
-   * or {@link discover}), then {@link synchronize} listeners can be used to update
-   * all instance's of that friend's name in the user's application instantly,
-   * providing a consistent user experience.
+   * Discovers objects **not** contained in any
+   * {@link GraffitiObjectBase.channels | `channels`}
+   * that were created by the querying {@link GraffitiObjectBase.actor | `actor`}
+   * and match the given [JSON Schema](https://json-schema.org).
+   * Unlike {@link discover}, this method will not return objects created by other users.
    *
-   * @group Synchronize Methods
-   */
-  abstract synchronizeDiscover<Schema extends JSONSchema4>(
-    /**
-     * The {@link GraffitiObjectBase.channels | `channels`} that the objects must be associated with.
-     */
-    channels: string[],
-    /**
-     * A [JSON Schema](https://json-schema.org) that objects must satisfy.
-     */
-    schema: Schema,
-    /**
-     * An implementation-specific object with information to authenticate the
-     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
-     * only objects that have no {@link GraffitiObjectBase.allowed | `allowed`}
-     * property will be returned.
-     */
-    session?: GraffitiSession | null,
-  ): GraffitiStream<GraffitiObject<Schema>>;
-
-  /**
-   * This method has the same signature as {@link get} but, like {@link synchronizeDiscover},
-   * it listens for changes made via {@link put}, {@link patch}, and {@link delete} or
-   * fetched from {@link get} or {@link discover} and then streams appropriate
-   * changes to provide a responsive and consistent user experience.
+   * This method is not useful for most applications, but necessary for
+   * getting a global view of all a user's Graffiti data or debugging
+   * channel usage.
    *
-   * Unlike {@link get}, which returns a single result, this method continuously
-   *  listens for changes which are output as an asynchronous {@link GraffitiStream}.
+   * It's return value is the same as {@link discover}.
    *
-   * @group Synchronize Methods
+   * @group Query Methods
    */
-  abstract synchronizeGet<Schema extends JSONSchema4>(
-    /**
-     * The location of the object to get.
-     */
-    locationOrUri: GraffitiLocation | string,
+  abstract recoverOrphans<Schema extends JSONSchema4>(
     /**
-     * The JSON schema to validate the retrieved object against.
+     * A [JSON Schema](https://json-schema.org) that orphaned objects must satisfy.
      */
     schema: Schema,
     /**
      * An implementation-specific object with information to authenticate the
-     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
-     * the retrieved object's {@link GraffitiObjectBase.allowed | `allowed`}
-     * property must be `undefined`.
+     * {@link GraffitiObjectBase.actor | `actor`}.
      */
-    session?: GraffitiSession | null,
-  ): GraffitiStream<GraffitiObject<Schema>>;
+    session: GraffitiSession,
+  ): GraffitiStream<
+    GraffitiObject<Schema>,
+    {
+      tombstoneRetention: number;
+    }
+  >;
 
   /**
-   * Returns a list of all {@link GraffitiObjectBase.channels | `channels`}
+   * Returns statistics about all the {@link GraffitiObjectBase.channels | `channels`}
    * that an {@link GraffitiObjectBase.actor | `actor`} has posted to.
    * This is not very useful for most applications, but
    * necessary for certain applications where a user wants a
    * global view of all their Graffiti data or to debug
    * channel usage.
    *
-   * @group Utilities
+   * @group Query Methods
    *
-   * @returns A stream the {@link GraffitiObjectBase.channels | `channel`}s
+   * @returns A stream of statistics for each {@link GraffitiObjectBase.channels | `channel`}
    * that the {@link GraffitiObjectBase.actor | `actor`} has posted to.
-   * The `lastModified` field is the time that the user last modified an
-   * object in that channel. The `count` field is the number of objects
-   * that the user has posted to that channel.
    */
-  abstract listChannels(
+  abstract channelStats(
     /**
      * An implementation-specific object with information to authenticate the
      * {@link GraffitiObjectBase.actor | `actor`}.
      */
     session: GraffitiSession,
-  ): GraffitiStream<{
-    channel: string;
-    lastModified: number;
-    count: number;
-  }>;
-
-  /**
-   * Returns a list of all {@link GraffitiObjectBase | objects} a user has posted that are
-   * not associated with any {@link GraffitiObjectBase.channels | `channel`}, i.e. orphaned objects.
-   * This is not very useful for most applications, but
-   * necessary for certain applications where a user wants a
-   * global view of all their Graffiti data or to debug
-   * channel usage.
-   *
-   * @group Utilities
-   *
-   * @returns A stream of the {@link GraffitiObjectBase.name | `name`}
-   * and {@link GraffitiObjectBase.source | `source`} of the orphaned objects
-   * that the {@link GraffitiObjectBase.actor | `actor`} has posted to.
-   * The {@link GraffitiObjectBase.lastModified | lastModified} field is the
-   * time that the user last modified the orphan.
-   */
-  abstract listOrphans(session: GraffitiSession): GraffitiStream<{
-    name: string;
-    source: string;
-    lastModified: string;
-  }>;
-
-  /**
-   * The age at which a query for a session will be considered expired.
-   */
-  // abstract readonly maxAge: number;
+  ): GraffitiStream<ChannelStats>;
 
   /**
    * Begins the login process. Depending on the implementation, this may
@@ -682,6 +628,102 @@ export abstract class Graffiti {
    * @group Session Management
    */
   abstract readonly sessionEvents: EventTarget;
+
+  /**
+   * This method has the same signature as {@link discover} but listens for
+   * changes made via {@link put}, {@link patch}, and {@link delete} or
+   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}
+   * and then streams appropriate changes to provide a responsive and
+   * consistent user experience.
+   *
+   * Unlike {@link discover}, this method continuously listens for changes
+   * and will not terminate unless the user calls the `return` method on the iterator
+   * or `break`s out of the loop.
+   *
+   * Example 1: Suppose a user publishes a post using {@link put}. If the feed
+   * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,
+   * then the user's new post will instantly appear in their feed, giving the UI a
+   * responsive feel.
+   *
+   * Example 2: Suppose one of a user's friends changes their name. As soon as the
+   * user's application receives one notice of that change (using {@link get}
+   * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update
+   * all instance's of that friend's name in the user's application instantly,
+   * providing a consistent user experience.
+   *
+   * @group Synchronize Methods
+   */
+  abstract synchronizeDiscover<Schema extends JSONSchema4>(
+    /**
+     * The {@link GraffitiObjectBase.channels | `channels`} that the objects must be associated with.
+     */
+    channels: string[],
+    /**
+     * A [JSON Schema](https://json-schema.org) that objects must satisfy.
+     */
+    schema: Schema,
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
+     * only objects that have no {@link GraffitiObjectBase.allowed | `allowed`}
+     * property will be returned.
+     */
+    session?: GraffitiSession | null,
+  ): GraffitiStream<GraffitiObject<Schema>>;
+
+  /**
+   * This method has the same signature as {@link get} but, like {@link synchronizeDiscover},
+   * it listens for changes made via {@link put}, {@link patch}, and {@link delete} or
+   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then
+   * streams appropriate changes to provide a responsive and consistent user experience.
+   *
+   * Unlike {@link get}, which returns a single result, this method continuously
+   * listens for changes which are output as an asynchronous {@link GraffitiStream}.
+   *
+   * @group Synchronize Methods
+   */
+  abstract synchronizeGet<Schema extends JSONSchema4>(
+    /**
+     * The location of the object to get.
+     */
+    locationOrUri: GraffitiLocation | string,
+    /**
+     * The JSON schema to validate the retrieved object against.
+     */
+    schema: Schema,
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}. If no `session` is provided,
+     * the retrieved object's {@link GraffitiObjectBase.allowed | `allowed`}
+     * property must be `undefined`.
+     */
+    session?: GraffitiSession | null,
+  ): GraffitiStream<GraffitiObject<Schema>>;
+
+  /**
+   * This method has the same signature as {@link recoverOrphans} but,
+   * like {@link synchronizeDiscover}, it listens for changes made via
+   * {@link put}, {@link patch}, and {@link delete} or fetched from
+   * {@link get}, {@link discover}, and {@link recoverOrphans} and then
+   * streams appropriate changes to provide a responsive and consistent user experience.
+   *
+   * Unlike {@link recoverOrphans}, this method continuously listens for changes
+   * and will not terminate unless the user calls the `return` method on the iterator
+   * or `break`s out of the loop.
+   *
+   * @group Synchronize Methods
+   */
+  abstract synchronizeRecoverOrphans<Schema extends JSONSchema4>(
+    /**
+     * A [JSON Schema](https://json-schema.org) that orphaned objects must satisfy.
+     */
+    schema: Schema,
+    /**
+     * An implementation-specific object with information to authenticate the
+     * {@link GraffitiObjectBase.actor | `actor`}.
+     */
+    session: GraffitiSession,
+  ): GraffitiStream<GraffitiObject<Schema>>;
 }
 
 /**

package/src/2-types.ts

@@ -245,7 +245,7 @@ export interface GraffitiPatch {
 /**
  * This type represents a stream of data that are
  * returned by Graffiti's query-like operations such as
- * {@link Graffiti.discover} and {@link Graffiti.listChannels}.
+ * {@link Graffiti.discover} and {@link Graffiti.recoverOrphans}.
  *
  * Errors are returned within the stream rather than as
  * exceptions that would halt the entire stream. This is because
@@ -270,6 +270,29 @@ export type GraffitiStream<TValue, TReturn = void> = AsyncGenerator<
   TReturn
 >;
 
+/**
+ * Statistic about single channel returned by {@link Graffiti.channelStats}.
+ * These statistics only account for contributions made by the
+ * querying actor.
+ */
+export type ChannelStats = {
+  /**
+   * The URI of the channel.
+   */
+  channel: string;
+  /**
+   * The number of non-{@link GraffitiObjectBase.tombstone | `tombstone`}d objects
+   * that the actor has posted to the channel.
+   */
+  count: number;
+  /**
+   * The time that the actor {@link Graffiti.lastModified | last modified} an object in the channel,
+   * measured in milliseconds since January 1, 1970.
+   * {@link GraffitiObjectBase.tombstone | Tombstone}d objects do not effect this modification time.
+   */
+  lastModified: number;
+};
+
 /**
  * The event type produced in {@link Graffiti.sessionEvents}
  * when a user logs in manually from {@link Graffiti.login}
@@ -310,8 +333,11 @@ export type GraffitiLogoutEvent = CustomEvent<
  * and restore any previously active sessions.
  * Successful session restores will be returned in parallel as
  * their own {@link GraffitiLoginEvent} events.
- * This event optionally return an `href` property
- * if there were any redirects during the restoration process.
+ *
+ * This event optionally returns an `href` property
+ * representing the URL the user originated a login request
+ * from, which may be useful for redirecting the user back to
+ * the page they were on after login.
  * The event name to listen for is `initialized`.
  */
 export type GraffitiSessionInitializedEvent = CustomEvent<

package/tests/src/channel-stats.ts

@@ -0,0 +1,124 @@
+import { it, expect, describe, assert } from "vitest";
+import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
+import { randomPutObject, randomString } from "./utils";
+
+export const graffitiChannelStatsTests = (
+  useGraffiti: () => Pick<
+    Graffiti,
+    "channelStats" | "put" | "delete" | "patch"
+  >,
+  useSession1: () => GraffitiSession,
+  useSession2: () => GraffitiSession,
+) => {
+  describe("channel stats", () => {
+    it("list channels", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+
+      const existingChannels: Map<string, number> = new Map();
+      const channelIterator1 = graffiti.channelStats(session);
+      for await (const channel of channelIterator1) {
+        if (channel.error) continue;
+        existingChannels.set(channel.value.channel, channel.value.count);
+      }
+
+      const channels = [randomString(), randomString(), randomString()];
+
+      // Add one value to channels[0],
+      // two values to both channels[0] and channels[1],
+      // three values to all channels
+      // one value to channels[2]
+      for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < i + 1; j++) {
+          await graffiti.put(
+            {
+              value: {
+                index: j,
+              },
+              channels: channels.slice(0, i + 1),
+            },
+            session,
+          );
+        }
+      }
+      await graffiti.put(
+        { value: { index: 3 }, channels: [channels[2]] },
+        session,
+      );
+
+      const channelIterator2 = graffiti.channelStats(session);
+      let newChannels: Map<string, number> = new Map();
+      for await (const channel of channelIterator2) {
+        if (channel.error) continue;
+        newChannels.set(channel.value.channel, channel.value.count);
+      }
+      // Filter out existing channels
+      newChannels = new Map(
+        Array.from(newChannels).filter(
+          ([channel, count]) => !existingChannels.has(channel),
+        ),
+      );
+      expect(newChannels.size).toBe(3);
+      expect(newChannels.get(channels[0])).toBe(6);
+      expect(newChannels.get(channels[1])).toBe(5);
+      expect(newChannels.get(channels[2])).toBe(4);
+    });
+
+    it("list channels with deleted channel", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+
+      const channels = [randomString(), randomString(), randomString()];
+
+      // Add an item with two channels
+      const before = await graffiti.put(
+        {
+          value: { index: 2 },
+          channels: channels.slice(1),
+        },
+        session,
+      );
+
+      // Add an item with all channels
+      const first = await graffiti.put(
+        { value: { index: 0 }, channels },
+        session,
+      );
+      // But then delete it
+      await graffiti.delete(first, session);
+
+      // Create a new object with only one channel
+      const second = await graffiti.put(
+        {
+          value: { index: 1 },
+          channels: channels.slice(2),
+        },
+        session,
+      );
+
+      const channelIterator = graffiti.channelStats(session);
+
+      let got1 = 0;
+      let got2 = 0;
+      for await (const result of channelIterator) {
+        if (result.error) continue;
+        const { channel, count, lastModified } = result.value;
+        assert(
+          channel !== channels[0],
+          "There should not be an object in channel[0]",
+        );
+        if (channel === channels[1]) {
+          expect(count).toBe(1);
+          expect(lastModified).toBe(before.lastModified);
+          got1++;
+        } else if (channel === channels[2]) {
+          expect(count).toBe(2);
+          expect(lastModified).toBe(second.lastModified);
+          got2++;
+        }
+      }
+      expect(got1).toBe(1);
+      expect(got2).toBe(1);
+    });
+  });
+};

package/tests/src/crud.ts

@@ -63,7 +63,7 @@ export const graffitiCRUDTests = (
         expect(beforeReplaced.name).toEqual(previous.name);
         expect(beforeReplaced.actor).toEqual(previous.actor);
         expect(beforeReplaced.source).toEqual(previous.source);
-        expect(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
+        expect(beforeReplaced.lastModified).toBeGreaterThan(
           gotten.lastModified,
         );
 
@@ -77,14 +77,29 @@ export const graffitiCRUDTests = (
         const beforeDeleted = await graffiti.delete(afterReplaced, session);
         expect(beforeDeleted.tombstone).toEqual(true);
         expect(beforeDeleted.value).toEqual(newValue);
-        expect(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
+        expect(beforeDeleted.lastModified).toBeGreaterThan(
           beforeReplaced.lastModified,
         );
 
-        // Try to get it and fail
-        await expect(graffiti.get(afterReplaced, {})).rejects.toThrow(
-          GraffitiErrorNotFound,
-        );
+        // Get a tombstone
+        const final = await graffiti.get(afterReplaced, {});
+        expect(final).toEqual(beforeDeleted);
+      });
+
+      it("get non-existant", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+
+        const putted = await graffiti.put(randomPutObject(), session);
+        await expect(
+          graffiti.get(
+            {
+              ...putted,
+              name: randomString(),
+            },
+            {},
+          ),
+        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
       });
 
       it("put, get, delete with wrong actor", async () => {
@@ -218,10 +233,14 @@ export const graffitiCRUDTests = (
         expect(gotten.channels).toEqual(channels);
 
         // But not without session
-        await expect(graffiti.get(putted, {})).rejects.toThrow();
+        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound,
+        );
 
         // Or the wrong session
-        await expect(graffiti.get(putted, {}, session2)).rejects.toThrow();
+        await expect(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound,
+        );
       });
 
       it("put and get with specific access control", async () => {
@@ -250,7 +269,9 @@ export const graffitiCRUDTests = (
         expect(gotten.channels).toEqual(channels);
 
         // But not without session
-        await expect(graffiti.get(putted, {})).rejects.toThrow();
+        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound,
+        );
 
         const gotten2 = await graffiti.get(putted, {}, session2);
         expect(gotten2.value).toEqual(value);
@@ -287,6 +308,17 @@ export const graffitiCRUDTests = (
         await graffiti.delete(putted, session);
       });
 
+      it("patch deleted object", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+
+        const putted = await graffiti.put(randomPutObject(), session);
+        const deleted = await graffiti.delete(putted, session);
+        await expect(
+          graffiti.patch({}, putted, session),
+        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
+      });
+
       it("deep patch", async () => {
         const graffiti = useGraffiti();
         const session = useSession1();

package/tests/src/index.ts

@@ -2,3 +2,5 @@ export * from "./location";
 export * from "./crud";
 export * from "./synchronize";
 export * from "./discover";
+export * from "./orphans";
+export * from "./channel-stats";