@graffiti-garden/api 0.5.1 → 0.6.1

package/src/1-api.ts

@@ -5,8 +5,10 @@ import type {
   GraffitiPatch,
   GraffitiSession,
   GraffitiPutObject,
-  GraffitiStream,
+  GraffitiObjectStream,
   ChannelStats,
+  GraffitiChannelStatsStream,
+  GraffitiObjectStreamContinue,
 } from "./2-types";
 import type { JSONSchema } from "json-schema-to-ts";
 
@@ -195,13 +197,19 @@ export abstract class Graffiti {
    * Replacement occurs when the {@link GraffitiObjectBase.url | `url`} of
    * the replaced object exactly matches an existing object's URL.
    *
-   * @returns The object that was replaced if one exists or an object with
+   * @throws {@link GraffitiErrorNotFound} if a {@link GraffitiObjectBase.url | `url`}
+   * is provided that has not been created yet or the {@link GraffitiObjectBase.actor | `actor`}
+   * is not {@link GraffitiObjectBase.allowed | `allowed`} to see it.
+   *
+   * @throws {@link GraffitiErrorForbidden} if the {@link GraffitiObjectBase.actor | `actor`}
+   * is not the same `actor` as the one who created the object.
+   *
+   * @returns The object that was replaced if one one exists, otherwise an object with
    * with an empty {@link GraffitiObjectBase.value | `value`},
    * {@link GraffitiObjectBase.channels | `channels`}, and {@link GraffitiObjectBase.allowed | `allowed`}
-   * list if the method created a new object.
-   * In either case, the object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
-   * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
-   * field updated to the time of replacement/creation.
+   * list.
+   * The {@link GraffitiObjectBase.lastModified | `lastModified`} property of the returned object
+   * will be updated to the time of replacement/creation.
    *
    * @group CRUD Methods
    */
@@ -221,7 +229,7 @@ export abstract class Graffiti {
   ): Promise<GraffitiObjectBase>;
 
   /**
-   * Retrieves an object from a given location.
+   * Retrieves an object from a given {@link GraffitiObjectBase.url | `url`}.
    *
    * The retrieved object is type-checked against the provided [JSON schema](https://json-schema.org/)
    * otherwise a {@link GraffitiErrorSchemaMismatch} is thrown.
@@ -232,22 +240,10 @@ export abstract class Graffiti {
    * {@link GraffitiObjectBase.channels | `channels`} properties are
    * not revealed, similar to a BCC.
    *
-   * 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 may 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`. This allows for the invalidation of the object
-   * in a client-side cache.
-   *
-   * 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 it has been permanently deleted,
-   * a {@link GraffitiErrorNotFound} is thrown.
-   * The rate at which permanent deletions happen is implementation dependent.
-   * See the `tombstoneRetention` property returned by {@link discover}.
+   * @throws {@link GraffitiErrorNotFound} if the object does not exist, has been deleted, or the user is not
+   * {@link GraffitiObjectBase.allowed | `allowed`} to access it.
+   *
+   * @throws {@link GraffitiErrorSchemaMismatch} if the retrieved object does not match the provided schema.
    *
    * @group CRUD Methods
    */
@@ -270,16 +266,19 @@ export abstract class Graffiti {
   ): Promise<GraffitiObject<Schema>>;
 
   /**
-   * Patches an existing object at a given location.
+   * Patches an existing object at a given {@link GraffitiObjectBase.url | `url`}.
    * The patching {@link GraffitiObjectBase.actor | `actor`} must be the same as the
    * `actor` that created the object.
    *
-   * @returns The original object prior to the patch
-   * The object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
-   * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
-   * field updated to the time of deletion.
+   * @returns The original object prior to the patch with its
+   * {@link GraffitiObjectBase.lastModified | `lastModified`}
+   * property updated to the time of deletion.
+   *
+   * @throws {@link GraffitiErrorNotFound} if the object does not exist, has already been deleted,
+   * or the user is not {@link GraffitiObjectBase.allowed | `allowed`} to access it.
    *
-   * @throws {@link GraffitiErrorNotFound} if the object does not exist or has already been deleted.
+   * @throws {@link GraffitiErrorForbidden} if the {@link GraffitiObjectBase.actor | `actor`}
+   * is not the same `actor` as the one who created the object.
    *
    * @group CRUD Methods
    */
@@ -301,16 +300,25 @@ export abstract class Graffiti {
   ): Promise<GraffitiObjectBase>;
 
   /**
-   * Deletes an object from a given location.
+   * Deletes an object from a given {@link GraffitiObjectBase.url | `url`}.
    * The deleting {@link GraffitiObjectBase.actor | `actor`} must be the same as the
    * `actor` that created the object.
    *
-   * @returns The object that was deleted if one exists.
-   * The object will have a {@link GraffitiObjectBase.tombstone | `tombstone`}
-   * field set to `true` and a {@link GraffitiObjectBase.lastModified | `lastModified`}
-   * field updated to the time of deletion.
+   * It is not possible to re-{@link put} an object that has been deleted
+   * to ensure a user's [right to be forgotten](https://en.wikipedia.org/wiki/Right_to_be_forgotten).
+   * In cases where deleting and restoring an object is useful, an object's
+   * {@link GraffitiObjectBase.allowed | `allowed`} property can be set to
+   * an empty list to hide it from all users except the creator.
    *
-   * @throws {@link GraffitiErrorNotFound} if the object does not exist or has already been deleted.
+   * @returns The object that was deleted with its
+   * {@link GraffitiObjectBase.lastModified | `lastModified`}
+   * property updated to the time of deletion.
+   *
+   * @throws {@link GraffitiErrorNotFound} if the object does not exist,  has already been deleted,
+   * or the user is not {@link GraffitiObjectBase.allowed | `allowed`} to access it.
+   *
+   * @throws {@link GraffitiErrorForbidden} if the {@link GraffitiObjectBase.actor | `actor`}
+   * is not the same `actor` as the one who created the object.
    *
    * @group CRUD Methods
    */
@@ -333,54 +341,27 @@ export abstract class Graffiti {
    *
    * Objects are returned asynchronously as they are discovered but the stream
    * will end once all leads have been exhausted.
-   * The method must be polled again for new objects.
+   * The {@link GraffitiObjectStream} ends by returning a `continue`
+   * method and a `cursor` string, each of which can be be used to poll for new objects.
+   * The `continue` method preserves the type safety of the stream and the `cursor`
+   * string can be serialized to continue the stream after an application is closed
+   * and reopened.
+   * See the {@link continueObjectStream} method for more information.
    *
    * `discover` will not return objects that the {@link GraffitiObjectBase.actor | `actor`}
    * is not {@link GraffitiObjectBase.allowed | `allowed`} to access.
-   * If the actor is not the creator of a discovered object,
+   * If the `actor` is not the creator of a discovered object,
    * the allowed list will be masked to only contain the querying actor if the
    * allowed list is not `undefined` (public). Additionally, if the actor is not the
    * creator of a discovered object, any {@link GraffitiObjectBase.channels | `channels`}
    * not specified by the `discover` method will not be revealed. This masking happens
-   * before the supplied schema is applied.
+   * before the object is validated against the supplied `schema`.
    *
    * Since different implementations may fetch data from multiple sources there is
-   * no guarentee on the order that objects are returned in. Additionally, the method
-   * will return objects that have been deleted but with a
-   * {@link GraffitiObjectBase.tombstone | `tombstone`} field set to `true` for
-   * client-side cache invalidation purposes.
-   * The final `return()` value of the stream includes a `tombstoneRetention`
-   * property that represents the minimum amount of time,
-   * in milliseconds, that an application will retain and return tombstones for objects that
-   * have been deleted.
-   *
-   * When repolling, the {@link GraffitiObjectBase.lastModified | `lastModified`}
-   * field can be queried via the schema to
-   * only fetch objects that have been modified since the last poll.
-   * Such queries should only be done if the time since the last poll
-   * is less than the `tombstoneRetention` value of that poll, otherwise the tombstones
-   * for objects that have been deleted may not be returned.
-   *
-   * ```json
-   * {
-   *   "properties": {
-   *     "lastModified": {
-   *       "minimum": LAST_RETRIEVED_TIME
-   *     }
-   *   }
-   * }
-   * ```
-   *
-   * `discover` needs to be polled for new data because live updates to
-   * an application can be visually distracting or lead to toxic engagement.
-   * If and when an application wants real-time updates, such as in a chat
-   * application, application authors must be intentional about their polling.
-   *
-   * Implementers should be aware that some users may applications may try to poll
-   * {@link discover} repetitively. They can deal with this by rate limiting or
-   * preemptively fetching data via a bidirectional channel, like a WebSocket.
-   * Additionally, implementers should probably index the `lastModified` field
-   * to speed up responses to schemas like the one above.
+   * no guarentee on the order that objects are returned in.
+   * It is also possible that duplicate objects are returned and their
+   * {@link GraffitiObjectBase.lastModified | `lastModified`} fields must be used
+   * to determine which object is the most recent.
    *
    * @returns A stream of objects that match the given {@link GraffitiObjectBase.channels | `channels`}
    * and [JSON Schema](https://json-schema.org).
@@ -403,12 +384,7 @@ export abstract class Graffiti {
      * property will be returned.
      */
     session?: GraffitiSession | null,
-  ): GraffitiStream<
-    GraffitiObject<Schema>,
-    {
-      tombstoneRetention: number;
-    }
-  >;
+  ): GraffitiObjectStream<Schema>;
 
   /**
    * Discovers objects **not** contained in any
@@ -421,7 +397,13 @@ export abstract class Graffiti {
    * getting a global view of all a user's Graffiti data or debugging
    * channel usage.
    *
-   * It's return value is the same as {@link discover}.
+   * Like {@link discover}, objects are returned asynchronously as they are discovered,
+   * the stream will end once all leads have been exhausted, and the stream
+   * can be continued using the `continue` method or `cursor` string.
+   *
+   * @returns A stream of objects created by the querying {@link GraffitiObjectBase.actor | `actor`}
+   * that do not belong to any {@link GraffitiObjectBase.channels | `channels`}
+   * and match the given [JSON Schema](https://json-schema.org).
    *
    * @group Query Methods
    */
@@ -435,12 +417,7 @@ export abstract class Graffiti {
      * {@link GraffitiObjectBase.actor | `actor`}.
      */
     session: GraffitiSession,
-  ): GraffitiStream<
-    GraffitiObject<Schema>,
-    {
-      tombstoneRetention: number;
-    }
-  >;
+  ): GraffitiObjectStream<Schema>;
 
   /**
    * Returns statistics about all the {@link GraffitiObjectBase.channels | `channels`}
@@ -450,6 +427,9 @@ export abstract class Graffiti {
    * global view of all their Graffiti data or to debug
    * channel usage.
    *
+   * Like {@link discover}, objects are returned asynchronously as they are discovered,
+   * the stream will end once all leads have been exhausted.
+   *
    * @group Query Methods
    *
    * @returns A stream of statistics for each {@link GraffitiObjectBase.channels | `channel`}
@@ -461,7 +441,37 @@ export abstract class Graffiti {
      * {@link GraffitiObjectBase.actor | `actor`}.
      */
     session: GraffitiSession,
-  ): GraffitiStream<ChannelStats>;
+  ): GraffitiChannelStatsStream;
+
+  /**
+   * Continues a {@link GraffitiObjectStream} from a given `cursor` string.
+   * The continuation will return new objects that have been created
+   * that match the original stream, and also returns the
+   * {@link GraffitiObjectBase.url | `url`}s of objects that
+   * have been deleted, as marked by a `tombstone`.
+   *
+   * The continuation may also include duplicates of objects that
+   * were already returned by the original stream. This is dependent
+   * on how much state the underlying implementation maintains.
+   *
+   * The `cursor` allows the client to
+   * serialize the state of the stream and continue it later.
+   * However this method loses any typing information that was
+   * present in the original stream. For better type safety
+   * and when serializing is not necessary, use the `continue`
+   * method instead, returned along with the `cursor` at the
+   * end of the original stream.
+   *
+   * @throws {@link GraffitiErrorForbidden} if the {@link GraffitiObjectBase.actor | `actor`}
+   * provided in the `session` is not the same as the `actor`
+   * that initiated the original stream.
+   *
+   * @group Query Methods
+   */
+  abstract continueObjectStream(
+    cursor: string,
+    session?: GraffitiSession | null,
+  ): GraffitiObjectStreamContinue<{}>;
 
   /**
    * Begins the login process. Depending on the implementation, this may

package/src/2-types.ts

@@ -17,8 +17,7 @@ import type { Operation as JSONPatchOperation } from "fast-json-patch";
  * The {@link channels | `channels`} and {@link allowed | `allowed`} properties
  * enable the object's creator to shape the visibility of and access to their object.
  *
- * The {@link tombstone | `tombstone`} and {@link lastModified | `lastModified`} properties are for
- * caching and synchronization.
+ * The {@link lastModified | `lastModified`} property can be used to compare object versions.
  */
 export interface GraffitiObjectBase {
   /**
@@ -81,9 +80,9 @@ export interface GraffitiObjectBase {
    * If an object is {@link Graffiti.put | put} with the same URL
    * as an existing object, the existing object will be replaced with the new object.
    *
-   * An object's URL is generated when the object is first creation and
+   * An object's URL is generated when the object is first created and
    * should include sufficient randomness to prevent collisions
-   * and guessing. The URL starts with a "scheme", just like web URLs start with `http` or `https`, to indicate
+   * and guessing. The URL starts with a "scheme," just like web URLs start with `http` or `https`, to indicate
    * to indicate the particular Graffiti implementation. This allows for applications
    * to pull from multiple coexisting Graffiti implementations without collision.
    * Existing schemes include `graffiti:local:` for objects stored locally
@@ -97,7 +96,7 @@ export interface GraffitiObjectBase {
 
   /**
    * The time the object was last modified, measured in milliseconds since January 1, 1970.
-   * This is used for client-side caching and synchronization.
+   * It can be used to compare object versions.
    * A number, rather than an ISO string or Date object, is used for easy comparison, sorting,
    * and JSON Schema [range queries](https://json-schema.org/understanding-json-schema/reference/numeric#range).
    *
@@ -107,13 +106,6 @@ export interface GraffitiObjectBase {
    * rather than when it was modified.
    */
   lastModified: number;
-
-  /**
-   * A boolean indicating whether the object has been deleted.
-   * Depending on implementation, objects stay available for some time
-   * after deletion to allow for synchronization and client-side caching
-   */
-  tombstone: boolean;
 }
 
 /**
@@ -141,10 +133,9 @@ export const GraffitiObjectJSONSchema = {
     url: { type: "string" },
     actor: { type: "string" },
     lastModified: { type: "number" },
-    tombstone: { type: "boolean" },
   },
   additionalProperties: false,
-  required: ["value", "channels", "actor", "url", "lastModified", "tombstone"],
+  required: ["value", "channels", "actor", "url", "lastModified"],
 } as const satisfies JSONSchema;
 
 /**
@@ -167,8 +158,8 @@ export type GraffitiObjectUrl = Pick<GraffitiObjectBase, "url">;
  * It may also include a {@link GraffitiObjectBase.url | `url`} property to specify the
  * URL of an existing object to replace. If no `url` is provided, one will be generated during object creation.
  *
- * This object does not need a {@link GraffitiObjectBase.lastModified | `lastModified`} or {@link GraffitiObjectBase.tombstone | `tombstone`}
- * property since these are automatically generated by the Graffiti system.
+ * This object does not need a {@link GraffitiObjectBase.lastModified | `lastModified`}
+ * property since it will be automatically generated by the Graffiti system.
  */
 export type GraffitiPutObject<Schema extends JSONSchema> = Pick<
   GraffitiObjectBase,
@@ -266,8 +257,7 @@ export interface GraffitiPatch {
 }
 
 /**
- * This type represents a stream of data that are
- * returned by Graffiti's query-like operations such as
+ * A stream of data that are returned by Graffiti's query-like operations
  * {@link Graffiti.discover} and {@link Graffiti.recoverOrphans}.
  *
  * Errors are returned within the stream rather than as
@@ -275,26 +265,159 @@ export interface GraffitiPatch {
  * some implementations may pull data from multiple sources
  * including some that may be unreliable. In many cases,
  * these errors can be safely ignored.
- * The `origin` property of the error object indicates the
- * source of the error including its scheme and other
- * implementation-specific details (e.g. domain name).
+ * See {@link GraffitiStreamError}.
  *
  * The stream is an [`AsyncGenerator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
  * that can be iterated over using `for await` loops or calling `next` on the generator.
  * The stream can be terminated by breaking out of a loop calling `return` on the generator.
+ *
+ * The stream ends by returning a {@link GraffitiObjectStreamReturn.continue | `continue`}
+ * function and a {@link GraffitiObjectStreamReturn.cursor | `cursor`} string,
+ * each of which can be used to resume the stream from where it left off.
  */
-export type GraffitiStream<TValue, TReturn = void> = AsyncGenerator<
-  | {
-      error?: undefined;
-      value: TValue;
-    }
-  | {
-      error: Error;
-      origin: string;
-    },
-  TReturn
+export type GraffitiObjectStream<Schema extends JSONSchema> = AsyncGenerator<
+  GraffitiStreamError | GraffitiObjectStreamEntry<Schema>,
+  GraffitiObjectStreamReturn<Schema>
 >;
 
+/**
+ * An error that can occur in either the
+ * {@link GraffitiObjectStream} or {@link GraffitiChannelStatsStream}.
+ *
+ * @internal
+ */
+export interface GraffitiStreamError {
+  /**
+   * The error that occurred while streaming data.
+   */
+  error: Error;
+  /**
+   * The origin that the error occurred. It will include
+   * the scheme of the Graffiti implementation used and other
+   * implementation-specific information like a hostname.
+   */
+  origin: string;
+}
+
+/**
+ * A successful result from a {@link GraffitiObjectStream} or
+ * {@link GraffitiObjectStreamContinue} that includes an object.
+ *
+ * @internal
+ */
+export interface GraffitiObjectStreamEntry<Schema extends JSONSchema> {
+  /**
+   * Empty property for compatibility with {@link GraffitiStreamError}
+   */
+  error?: undefined;
+  /**
+   * Empty property for compatibility with {@link GraffitiObjectStreamContinueTombstone}
+   */
+  tombstone?: undefined;
+  /**
+   * The object returned by the stream.
+   */
+  object: GraffitiObject<Schema>;
+}
+
+/**
+ * A result from a {@link GraffitiObjectStreamContinue} that indicated
+ * an object has been deleted since the original stream was run.
+ * Only sparse metadata about the deleted object is returned to respect
+ * the deleting user's privacy.
+ *
+ * @internal
+ */
+export interface GraffitiObjectStreamContinueTombstone {
+  /**
+   * Empty property for compatibility with {@link GraffitiStreamError}
+   */
+  error?: undefined;
+  /**
+   * Use this property to differentiate a tombstone from a
+   * {@link GraffitiObjectStreamEntry}.
+   */
+  tombstone: true;
+  /**
+   * Sparse metadata about the deleted object. The full object is not returned
+   * to respect a user's privacy.
+   */
+  object: {
+    /**
+     * The {@link GraffitiObjectBase.url | `url`} of the deleted object.
+     */
+    url: string;
+    /**
+     * The time at which the object was deleted, comparable to
+     * {@link GraffitiObjectBase.lastModified | `lastModified`}.
+     *
+     * While it is not possible to re-{@link Graffiti.put | put} objects that have been
+     * {@link Graffiti.delete | deleted}, objects may appear deleted if
+     * an {@link GraffitiObjectBase.actor | `actor`} is no longer
+     * {@link GraffitiObjectBase.allowed | `allowed`} to access them.
+     * Therefore the {@link GraffitiObjectBase.lastModified | `lastModified`} property
+     * is necessary to compare object versions.
+     */
+    lastModified: number;
+  };
+}
+
+/**
+ * A continuation of the {@link GraffitiObjectStream} type can include
+ * both objects and tombstones of deleted objects.
+ *
+ * @internal
+ */
+export type GraffitiObjectStreamContinueEntry<Schema extends JSONSchema> =
+  | GraffitiObjectStreamEntry<Schema>
+  | GraffitiObjectStreamContinueTombstone;
+
+/**
+ * The output of a {@link GraffitiObjectStream} or a {@link GraffitiObjectStreamContinue}
+ * that allows the stream to be continued from where it left off.
+ *
+ * The {@link continue} function preserves the typing of the original stream,
+ * where as the {@link cursor} string can be serialized for use after a user
+ * has closed and reopened an application.
+ *
+ * The continued stream may include `tombstone`s of objects that have been
+ * deleted since the original stream was run. See {@link GraffitiObjectStreamContinueTombstone}.
+ * The continued stream may also return some objects that were already
+ * returned by the original stream, depending on how much state the
+ * underlying implementation is able to preserve.
+ *
+ * @internal
+ */
+export interface GraffitiObjectStreamReturn<Schema extends JSONSchema> {
+  /**
+   * @returns A function that creates new stream that continues from where the original stream left off.
+   * It preserves the typing of the original stream.
+   */
+  continue: () => GraffitiObjectStreamContinue<Schema>;
+  /**
+   * A string that can be serialized and stored to resume the stream later.
+   * It must be passed to the {@link Graffiti.continueObjectStream} method
+   * to resume the stream.
+   */
+  cursor: string;
+}
+
+/**
+ * A continutation of the {@link GraffitiObjectStream} type, as returned by
+ * the {@link GraffitiObjectStreamReturn.continue} or by using
+ * {@link GraffitiObjectStreamReturn.cursor} with {@link Graffiti.continueObjectStream}.
+ *
+ * The continued stream may include `tombstone`s of objects that have been
+ * deleted since the original stream was run. See {@link GraffitiObjectStreamContinueTombstone}.
+ *
+ * @internal
+ */
+export type GraffitiObjectStreamContinue<Schema extends JSONSchema> =
+  AsyncGenerator<
+    GraffitiStreamError | GraffitiObjectStreamContinueEntry<Schema>,
+    GraffitiObjectStreamReturn<Schema>
+  >;
+
 /**
  * Statistic about single channel returned by {@link Graffiti.channelStats}.
  * These statistics only account for contributions made by the
@@ -306,18 +429,30 @@ export type ChannelStats = {
    */
   channel: string;
   /**
-   * The number of non-{@link GraffitiObjectBase.tombstone | `tombstone`}d objects
-   * that the actor has posted to the channel.
+   * The number of objects that the actor has {@link Graffiti.put | put}
+   * and not {@link Graffiti.delete | deleted} in the channel.
    */
   count: number;
   /**
    * The time that the actor {@link GraffitiObjectBase.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.
+   * {@link Graffiti.delete | Deleted} objects do not effect this modification time.
    */
   lastModified: number;
 };
 
+/**
+ * A stream of data that are returned by Graffiti's {@link Graffiti.channelStats} method.
+ * See {@link GraffitiObjectStream} for more information on streams.
+ */
+export type GraffitiChannelStatsStream = AsyncGenerator<
+  | GraffitiStreamError
+  | {
+      error?: undefined;
+      value: ChannelStats;
+    }
+>;
+
 /**
  * The event type produced in {@link Graffiti.sessionEvents}
  * when a user logs in manually from {@link Graffiti.login}

package/tests/crud.ts

@@ -72,7 +72,6 @@ export const graffitiCRUDTests = (
           session,
         );
         expect(beforeReplaced.value).toEqual(value);
-        expect(beforeReplaced.tombstone).toEqual(true);
         expect(beforeReplaced.url).toEqual(previous.url);
         expect(beforeReplaced.actor).toEqual(previous.actor);
         expect(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
@@ -83,24 +82,31 @@ export const graffitiCRUDTests = (
         const afterReplaced = await graffiti.get(previous, {});
         expect(afterReplaced.value).toEqual(newValue);
         expect(afterReplaced.lastModified).toEqual(beforeReplaced.lastModified);
-        expect(afterReplaced.tombstone).toEqual(false);
 
         // Delete it
         const beforeDeleted = await graffiti.delete(afterReplaced, session);
-        expect(beforeDeleted.tombstone).toEqual(true);
         expect(beforeDeleted.value).toEqual(newValue);
         expect(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
           beforeReplaced.lastModified,
         );
 
-        // Get a tombstone
-        const final = await graffiti.get(afterReplaced, {});
-        expect(final).toEqual(beforeDeleted);
+        // Get is not found
+        await expect(graffiti.get(afterReplaced, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound,
+        );
 
         // Delete it again
-        await expect(graffiti.delete(final, session)).rejects.toThrow(
+        await expect(graffiti.delete(beforeDeleted, session)).rejects.toThrow(
           GraffitiErrorNotFound,
         );
+
+        // Try to re-put it
+        await expect(
+          graffiti.put(
+            { url: beforeDeleted.url, value: {}, channels: [] },
+            session,
+          ),
+        ).rejects.toThrow(GraffitiErrorNotFound);
       });
 
       it("put, delete, patch with wrong actor", async () => {
@@ -339,7 +345,6 @@ export const graffitiCRUDTests = (
         };
         const beforePatched = await graffiti.patch(patch, putted, session);
         expect(beforePatched.value).toEqual(value);
-        expect(beforePatched.tombstone).toBe(true);
         expect(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
 
         const gotten = await graffiti.get(putted, {});