@graffiti-garden/api 0.6.0 → 0.6.1

package/dist/src/1-api.d.ts

@@ -1,4 +1,4 @@
-import type { GraffitiObjectUrl, GraffitiObject, GraffitiObjectBase, GraffitiPatch, GraffitiSession, GraffitiPutObject, GraffitiStream, ChannelStats } from "./2-types";
+import type { GraffitiObjectUrl, GraffitiObject, GraffitiObjectBase, GraffitiPatch, GraffitiSession, GraffitiPutObject, GraffitiObjectStream, GraffitiChannelStatsStream, GraffitiObjectStreamContinue } from "./2-types";
 import type { JSONSchema } from "json-schema-to-ts";
 /**
  * This API describes a small but powerful set of methods that
@@ -286,7 +286,13 @@ export declare abstract class Graffiti {
      * The deleting {@link GraffitiObjectBase.actor | `actor`} must be the same as the
      * `actor` that created the object.
      *
-     * @returns The object that was deleted its
+     * 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.
+     *
+     * @returns The object that was deleted with its
      * {@link GraffitiObjectBase.lastModified | `lastModified`}
      * property updated to the time of deletion.
      *
@@ -315,21 +321,21 @@ export declare abstract class Graffiti {
      *
      * Objects are returned asynchronously as they are discovered but the stream
      * will end once all leads have been exhausted.
-     * The {@link GraffitiStream} ends by returning a `continue`
+     * 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 typing of the stream and the `cursor`
+     * 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 continueStream} method for more information on continuing a stream.
+     * 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.
@@ -357,7 +363,7 @@ export declare abstract class Graffiti {
      * only objects that have no {@link GraffitiObjectBase.allowed | `allowed`}
      * property will be returned.
      */
-    session?: GraffitiSession | null): GraffitiStream<GraffitiObject<Schema>>;
+    session?: GraffitiSession | null): GraffitiObjectStream<Schema>;
     /**
      * Discovers objects **not** contained in any
      * {@link GraffitiObjectBase.channels | `channels`}
@@ -388,7 +394,7 @@ export declare abstract class Graffiti {
      * An implementation-specific object with information to authenticate the
      * {@link GraffitiObjectBase.actor | `actor`}.
      */
-    session: GraffitiSession): GraffitiStream<GraffitiObject<Schema>>;
+    session: GraffitiSession): GraffitiObjectStream<Schema>;
     /**
      * Returns statistics about all the {@link GraffitiObjectBase.channels | `channels`}
      * that an {@link GraffitiObjectBase.actor | `actor`} has posted to.
@@ -396,10 +402,9 @@ export declare abstract class Graffiti {
      * necessary for certain applications where a user wants a
      * 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, and the stream
-        * can be continued using the `continue` method or `cursor` string.
+     * the stream will end once all leads have been exhausted.
      *
      * @group Query Methods
      *
@@ -411,12 +416,13 @@ export declare abstract class Graffiti {
      * An implementation-specific object with information to authenticate the
      * {@link GraffitiObjectBase.actor | `actor`}.
      */
-    session: GraffitiSession): GraffitiStream<ChannelStats>;
+    session: GraffitiSession): GraffitiChannelStatsStream;
     /**
-     * Continues a {@link GraffitiStream} from a given `cursor` string.
+     * 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 return objects that
-     * have been deleted but with a `tombstone` property set to `true`.
+     * 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
@@ -425,8 +431,9 @@ export declare abstract class Graffiti {
      * 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. To preserve typing, the
-     * use the `continue` method returned with the `cursor` at the
+     * 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`}
@@ -435,7 +442,7 @@ export declare abstract class Graffiti {
      *
      * @group Query Methods
      */
-    abstract continueStream(cursor: string, session?: GraffitiSession | null): GraffitiStream<unknown>;
+    abstract continueObjectStream(cursor: string, session?: GraffitiSession | null): GraffitiObjectStreamContinue<{}>;
     /**
      * Begins the login process. Depending on the implementation, this may
      * involve redirecting the user to a login page or opening a popup,

package/dist/src/1-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1-api.d.ts","sourceRoot":"","sources":["../../src/1-api.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"1-api.d.ts","sourceRoot":"","sources":["../../src/1-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EAEpB,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+KG;AACH,8BAAsB,QAAQ;IAC5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,GAAG,CAAC,MAAM,SAAS,UAAU;IACpC;;;;;OAKG;IACH,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC;IACjC;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,GAAG,CAAC,MAAM,SAAS,UAAU;IACpC;;OAEG;IACH,GAAG,EAAE,MAAM,GAAG,iBAAiB;IAC/B;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAElC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAK;IACZ;;;OAGG;IACH,KAAK,EAAE,aAAa;IACpB;;OAEG;IACH,GAAG,EAAE,MAAM,GAAG,iBAAiB;IAC/B;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,MAAM;IACb;;OAEG;IACH,GAAG,EAAE,MAAM,GAAG,iBAAiB;IAC/B;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,QAAQ,CAAC,QAAQ,CAAC,MAAM,SAAS,UAAU;IACzC;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE;IAClB;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,oBAAoB,CAAC,MAAM,CAAC;IAE/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,cAAc,CAAC,MAAM,SAAS,UAAU;IAC/C;;OAEG;IACH,MAAM,EAAE,MAAM;IACd;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,oBAAoB,CAAC,MAAM,CAAC;IAE/B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,YAAY;IACnB;;;OAGG;IACH,OAAO,EAAE,eAAe,GACvB,0BAA0B;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,oBAAoB,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,4BAA4B,CAAC,EAAE,CAAC;IAEnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK;IACZ;;;;OAIG;IACH,QAAQ,CAAC,EAAE;QACT;;;;;;;;WAQG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QACf;;;;;;;;;;WAUG;QACH,KAAK,CAAC,EAAE,EAAE,CAAC;KACZ,GACA,OAAO,CAAC,IAAI,CAAC;IAEhB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM;IACb;;OAEG;IACH,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,IAAI,CAAC;IAEhB;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC;CAC9C"}

package/dist/src/2-types.d.ts

@@ -282,8 +282,7 @@ export interface GraffitiPatch {
     allowed?: JSONPatchOperation[];
 }
 /**
- * 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
@@ -291,38 +290,143 @@ 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 `continue` function and a `cursor` string,
+ * 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.
- * The `continue` function preserves the typing of the original stream,
- * where as the `cursor` string can be serialized for use after a user
- * has closed and reopened an application.
- * Use {@link Graffiti.continueStream} to resume a stream from the `cursor` string.
+ */
+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}.
  *
- * Unlike the original stream, the continued stream also includes a `tombstone`
- * boolean to indicate whether a stream element previously returned has been deleted.
- * 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.
+ * @internal
  */
-export type GraffitiStream<TValue> = AsyncGenerator<{
-    error?: undefined;
-    value: TValue;
-    tombstone?: boolean;
-} | {
+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;
-}, {
-    continue: () => GraffitiStream<TValue>;
+}
+/**
+ * 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
@@ -345,6 +449,14 @@ export type ChannelStats = {
      */
     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/dist/src/2-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2-types.d.ts","sourceRoot":"","sources":["../../src/2-types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"2-types.d.ts","sourceRoot":"","sources":["../../src/2-types.ts"],"names":[],"mappings":"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"}

package/dist/tests/crud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../tests/crud.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAGhB,MAAM,sBAAsB,CAAC;AAW9B,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,EACrE,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SA+f9D,CAAC"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../tests/crud.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAGhB,MAAM,sBAAsB,CAAC;AAW9B,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,EACrE,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAugB9D,CAAC"}

package/dist/tests/discover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../tests/discover.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAEhB,MAAM,sBAAsB,CAAC;AAG9B,eAAO,MAAM,qBAAqB,GAChC,aAAa,MAAM,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,EAC1E,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAqlB9D,CAAC"}
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../tests/discover.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EAGR,eAAe,EAEhB,MAAM,sBAAsB,CAAC;AAG9B,eAAO,MAAM,qBAAqB,GAChC,aAAa,MAAM,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,EAC1E,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SA2oB9D,CAAC"}

package/dist/tests/orphans.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orphans.d.ts","sourceRoot":"","sources":["../../tests/orphans.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGtE,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,IAAI,CACrB,QAAQ,EACR,gBAAgB,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAC9C,EACD,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAsG9D,CAAC"}
+{"version":3,"file":"orphans.d.ts","sourceRoot":"","sources":["../../tests/orphans.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGtE,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,IAAI,CACrB,QAAQ,EACR,gBAAgB,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAC9C,EACD,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAqG9D,CAAC"}

package/dist/tests/utils.d.ts

@@ -1,8 +1,8 @@
-import type { GraffitiPutObject, GraffitiStream } from "@graffiti-garden/api";
+import type { GraffitiPutObject, GraffitiObjectStream, JSONSchema, GraffitiObject } from "@graffiti-garden/api";
 export declare function randomString(): string;
 export declare function randomValue(): {
     [x: string]: string;
 };
 export declare function randomPutObject(): GraffitiPutObject<{}>;
-export declare function nextStreamValue<S>(iterator: GraffitiStream<S>): Promise<S>;
+export declare function nextStreamValue<Schema extends JSONSchema>(iterator: GraffitiObjectStream<Schema>): Promise<GraffitiObject<Schema>>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/tests/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../tests/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE9E,wBAAgB,YAAY,IAAI,MAAM,CASrC;AAED,wBAAgB,WAAW;;EAI1B;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CAAC,EAAE,CAAC,CAKvD;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,cAKnE"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../tests/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,UAAU,EACV,cAAc,EACf,MAAM,sBAAsB,CAAC;AAE9B,wBAAgB,YAAY,IAAI,MAAM,CASrC;AAED,wBAAgB,WAAW;;EAI1B;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CAAC,EAAE,CAAC,CAKvD;AAED,wBAAsB,eAAe,CAAC,MAAM,SAAS,UAAU,EAC7D,QAAQ,EAAE,oBAAoB,CAAC,MAAM,CAAC,GACrC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAKjC"}

package/dist/tests.mjs

@@ -32,7 +32,7 @@ async function nextStreamValue(iterator) {
   const result = await iterator.next();
   assert(!result.done && !result.value.error, "result has no value");
   assert(!result.value.tombstone, "result has been deleted!");
-  return result.value.value;
+  return result.value.object;
 }
 
 // tests/crud.ts
@@ -101,6 +101,12 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
         await expect(graffiti.delete(beforeDeleted, session)).rejects.toThrow(
           GraffitiErrorNotFound
         );
+        await expect(
+          graffiti.put(
+            { url: beforeDeleted.url, value: {}, channels: [] },
+            session
+          )
+        ).rejects.toThrow(GraffitiErrorNotFound);
       });
       it("put, delete, patch with wrong actor", async () => {
         await expect(
@@ -523,7 +529,11 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       const object = randomPutObject();
       object.allowed = [randomString(), randomString()];
       const putted = await graffiti.put(object, session1);
-      const iteratorSession1 = graffiti.discover(object.channels, {}, session1);
+      const iteratorSession1 = graffiti.discover(
+        object.channels,
+        {},
+        session1
+      );
       const value = await nextStreamValue(iteratorSession1);
       expect2(value.value).toEqual(object.value);
       expect2(value.channels).toEqual(object.channels);
@@ -539,7 +549,11 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
       const putted = await graffiti.put(object, session1);
-      const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
+      const iteratorSession2 = graffiti.discover(
+        object.channels,
+        {},
+        session2
+      );
       const value = await nextStreamValue(iteratorSession2);
       expect2(value.value).toEqual(object.value);
       expect2(value.allowed).toEqual([session2.actor]);
@@ -733,7 +747,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
+      const value2 = await nextStreamValue(
+        iteratorSession2SmallAllowPeekSelf
+      );
       expect2(value2.value).toEqual(object.value);
       await expect2(
         iteratorSession2SmallAllowPeekSelf.next()
@@ -822,7 +838,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
+      const value2 = await nextStreamValue(
+        iteratorSession2SmallAllowPeekSelf
+      );
       expect2(value2.value).toEqual(object.value);
       await expect2(
         iteratorSession2SmallAllowPeekSelf.next()
@@ -878,7 +896,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         })) {
           assert2(!result.error, "result has error");
-          if (property in result.value.value) {
+          if (property in result.object.value) {
             count++;
           }
         }
@@ -902,11 +920,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       const tombIterator = returnValue.value.continue();
       const value = await tombIterator.next();
       assert2(!value.done && !value.value.error, "value is done");
-      expect2(value.value.tombstone).toBe(true);
-      expect2(value.value.value.value).toEqual(object.value);
-      expect2(value.value.value.channels).toEqual(object.channels);
-      expect2(value.value.value.actor).toEqual(session.actor);
-      expect2(value.value.value.lastModified).toEqual(deleted.lastModified);
+      assert2(value.value.tombstone, "value is not tombstone");
+      expect2(value.value.object.url).toEqual(putted.url);
       await expect2(tombIterator.next()).resolves.toHaveProperty("done", true);
     });
     it2("discover for replaced channels", async () => {
@@ -940,18 +955,43 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           expect2(value32.value.tombstone && value22.done).toBe(false);
           continue;
         }
-        await expect2(iterator1.next()).resolves.toHaveProperty("done", true);
+        const value5 = await iterator1.next();
+        assert2(value5.done, "value5 is not done");
         const value4 = await tombIterator.next();
         assert2(!value4.done && !value4.value.error, "value is done");
-        expect2(value4.value.tombstone).toBe(true);
-        expect2(value4.value.value.value).toEqual(object1.value);
-        expect2(value4.value.value.channels).toEqual(object1.channels);
-        expect2(value4.value.value.lastModified).toEqual(replaced.lastModified);
+        assert2(value4.value.tombstone, "value is not tombstone");
+        expect2(value4.value.object.url).toEqual(putted.url);
+        expect2(value4.value.object.lastModified).toEqual(replaced.lastModified);
         const value2 = await nextStreamValue(iterator2);
         await expect2(iterator2.next()).resolves.toHaveProperty("done", true);
         expect2(value2.value).toEqual(object2.value);
         expect2(value2.channels).toEqual(object2.channels);
         expect2(value2.lastModified).toEqual(replaced.lastModified);
+        const patched = await graffiti.patch(
+          {
+            channels: [{ op: "replace", path: "", value: object1.channels }]
+          },
+          replaced,
+          session
+        );
+        const tombIterator2 = value5.value.continue();
+        let result;
+        for await (const value of tombIterator2) {
+          if (value.error) continue;
+          if (!result) {
+            result = value;
+            continue;
+          }
+          if (value.object.lastModified > result.object.lastModified || value.object.lastModified === result.object.lastModified && !value.tombstone && result.tombstone) {
+            result = value;
+          }
+        }
+        assert2(result, "result is not defined");
+        assert2(!result.tombstone, "result is tombstone");
+        expect2(result.object.url).toEqual(replaced.url);
+        expect2(result.object.lastModified).toEqual(patched.lastModified);
+        expect2(result.object.channels).toEqual(object1.channels);
+        expect2(result.object.value).toEqual(object2.value);
       }
     });
     it2("discover for patched allowed", async () => {
@@ -974,10 +1014,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       const iterator = returnValue.value.continue();
       const value = await iterator.next();
       assert2(!value.done && !value.value.error, "value is done");
-      expect2(value.value.tombstone).toBe(true);
-      expect2(value.value.value.value).toEqual(object.value);
-      expect2(value.value.value.channels).toEqual(object.channels);
-      expect2(value.value.value.allowed).toBeUndefined();
+      assert2(value.value.tombstone, "value is not tombstone");
+      expect2(value.value.object.url).toEqual(putted.url);
       await expect2(iterator.next()).resolves.toHaveProperty("done", true);
     });
     it2("put concurrently and discover one", async () => {
@@ -1029,7 +1067,7 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
       const orphanIterator1 = graffiti.recoverOrphans({}, session);
       for await (const orphan of orphanIterator1) {
         if (orphan.error) continue;
-        existingOrphans.push(orphan.value.url);
+        existingOrphans.push(orphan.object.url);
       }
       const object = randomPutObject();
       object.channels = [];
@@ -1039,9 +1077,9 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
       for await (const orphan of orphanIterator2) {
         if (orphan.error) continue;
         assert3(!orphan.tombstone, "orphan is tombstone");
-        if (orphan.value.url === putted.url) {
+        if (orphan.object.url === putted.url) {
           numResults++;
-          expect3(orphan.value.lastModified).toBe(putted.lastModified);
+          expect3(orphan.object.lastModified).toBe(putted.lastModified);
         }
       }
       expect3(numResults).toBe(1);
@@ -1086,7 +1124,7 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
       let numResults = 0;
       for await (const orphan of orphanIterator) {
         if (orphan.error) continue;
-        if (orphan.value.url === putOrphan.url) {
+        if (orphan.object.url === putOrphan.url) {
           numResults++;
         }
       }
@@ -1097,9 +1135,8 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
         !value2.done && !value2.value.error,
         "value2 is done or has error"
       );
-      expect3(value2.value.tombstone).toBe(true);
-      expect3(value2.value.value.lastModified).toBe(putNotOrphan.lastModified);
-      expect3(value2.value.value.channels).toEqual([]);
+      assert3(value2.value.tombstone, "value2 is not tombstone");
+      expect3(value2.value.object.url).toBe(putOrphan.url);
       await expect3(iterator2.next()).resolves.toHaveProperty("done", true);
     });
   });