@graffiti-garden/api 0.2.0 → 0.2.1

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

@@ -14,6 +14,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
@@ -27,22 +28,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
@@ -222,19 +229,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 declare abstract class Graffiti {
     /**
@@ -297,14 +302,26 @@ export declare abstract class Graffiti {
     session: GraffitiSession): Promise<GraffitiObjectBase>;
     /**
      * 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>(
@@ -395,7 +412,7 @@ export declare 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
@@ -460,121 +477,60 @@ export declare abstract class Graffiti {
         tombstoneRetention: number;
     }>;
     /**
-     * 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
-     */
-    abstract synchronizeGet<Schema extends JSONSchema4>(
-    /**
-     * The location of the object to get.
+     * @group Query Methods
      */
-    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 all {@link GraffitiObjectBase.channels | `channel`}s
      * 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.
+     * {@link GraffitiObjectBase.tombstone | `tombstone`}d objects are not included
+     * in either the `count` or `lastModified` fields.
      */
-    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;
+        lastModified: 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.
-     */
     /**
      * Begins the login process. Depending on the implementation, this may
      * involve redirecting the user to a login page or opening a popup,
@@ -642,6 +598,96 @@ export declare 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>>;
 }
 /**
  * This is a factory function that produces an instance of

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":"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"}

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

@@ -221,7 +221,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
@@ -273,8 +273,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/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/index.js

@@ -1,2 +1,2 @@
-import{assert as e,describe as a,it as t,expect as o}from"vitest";import{GraffitiErrorInvalidUri as n,GraffitiErrorNotFound as l,GraffitiErrorForbidden as s,GraffitiErrorInvalidSchema as i,GraffitiErrorSchemaMismatch as r,GraffitiErrorPatchTestFailed as c,GraffitiErrorPatchError as u}from"@graffiti-garden/api";function d(){const e=new Uint8Array(16);return crypto.getRandomValues(e),Array.from(e).map((e=>e.toString(16).padStart(2,"0"))).join("")}function v(){return{value:{[d()]:d()},channels:[d(),d()]}}async function h(a){const t=await a.next();return e(!t.done&&!t.value.error,"result has no value"),t.value.value}const w=e=>{a("URI and location conversion",(()=>{t("location to uri and back",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()},n=a.locationToUri(t),l=a.uriToLocation(n);o(t).toEqual(l)})),t("collision resistance",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()};for(const e of["name","actor","source"]){const n={...t,[e]:d()},l=a.locationToUri(t),s=a.locationToUri(n);o(l).not.toEqual(s)}})),t("random URI should not be a valid location",(async()=>{const a=e();o((()=>a.uriToLocation(""))).toThrow(n)}))}))},p=(e,n,h)=>{a("CRUD",{timeout:2e4},(()=>{t("put, get, delete",(async()=>{const a=e(),t=n(),s={something:"hello, world~ c:"},i=[d(),d()],r=await a.put({value:s,channels:i},t);o(r.value).toEqual({}),o(r.channels).toEqual([]),o(r.allowed).toBeUndefined(),o(r.actor).toEqual(t.actor);const c=await a.get(r,{});o(c.value).toEqual(s),o(c.channels).toEqual([]),o(c.allowed).toBeUndefined(),o(c.name).toEqual(r.name),o(c.actor).toEqual(r.actor),o(c.source).toEqual(r.source),o(c.lastModified).toEqual(r.lastModified);const u={something:"goodbye, world~ :c"},v=await a.put({...r,value:u,channels:[]},t);o(v.value).toEqual(s),o(v.tombstone).toEqual(!0),o(v.name).toEqual(r.name),o(v.actor).toEqual(r.actor),o(v.source).toEqual(r.source),o(v.lastModified).toBeGreaterThanOrEqual(c.lastModified);const h=await a.get(r,{});o(h.value).toEqual(u),o(h.lastModified).toEqual(v.lastModified),o(h.tombstone).toEqual(!1);const w=await a.delete(h,t);o(w.tombstone).toEqual(!0),o(w.value).toEqual(u),o(w.lastModified).toBeGreaterThanOrEqual(v.lastModified),await o(a.get(h,{})).rejects.toThrow(l)})),t("put, get, delete with wrong actor",(async()=>{const a=e(),t=n(),l=h();await o(a.put({value:{},channels:[],actor:l.actor},t)).rejects.toThrow(s);const i=await a.put({value:{},channels:[]},l);await o(a.delete(i,t)).rejects.toThrow(s),await o(a.patch({},i,t)).rejects.toThrow(s)})),t("put and get with schema",(async()=>{const a=e(),t=n(),l={something:"hello",another:42},s=await a.put({value:l,channels:[]},t),i=await a.get(s,{properties:{value:{properties:{something:{type:"string"},another:{type:"integer"}}}}});o(i.value.something).toEqual(l.something),o(i.value.another).toEqual(l.another)})),t("put and get with invalid schema",(async()=>{const a=e(),t=n(),l=await a.put({value:{},channels:[]},t);await o(a.get(l,{properties:{value:{type:"asdf"}}})).rejects.toThrow(i)})),t("put and get with wrong schema",(async()=>{const a=e(),t=n(),l=await a.put({value:{hello:"world"},channels:[]},t);await o(a.get(l,{properties:{value:{properties:{hello:{type:"number"}}}}})).rejects.toThrow(r)})),t("put and get with empty access control",(async()=>{const a=e(),t=n(),l=h(),s={um:"hi"},i=[d()],r=[d()],c=await a.put({value:s,allowed:i,channels:r},t),u=await a.get(c,{},t);o(u.value).toEqual(s),o(u.allowed).toEqual(i),o(u.channels).toEqual(r),await o(a.get(c,{})).rejects.toThrow(),await o(a.get(c,{},l)).rejects.toThrow()})),t("put and get with specific access control",(async()=>{const a=e(),t=n(),l=h(),s={um:"hi"},i=[d(),l.actor,d()],r=[d()],c=await a.put({value:s,allowed:i,channels:r},t),u=await a.get(c,{},t);o(u.value).toEqual(s),o(u.allowed).toEqual(i),o(u.channels).toEqual(r),await o(a.get(c,{})).rejects.toThrow();const v=await a.get(c,{},l);o(v.value).toEqual(s),o(v.allowed).toEqual([l.actor]),o(v.channels).toEqual([])})),t("patch value",(async()=>{const a=e(),t=n(),l={something:"hello, world~ c:"},s=await a.put({value:l,channels:[]},t),i=await a.patch({value:[{op:"replace",path:"/something",value:"goodbye, world~ :c"}]},s,t);o(i.value).toEqual(l),o(i.tombstone).toBe(!0);const r=await a.get(s,{});o(r.value).toEqual({something:"goodbye, world~ :c"}),o(i.lastModified).toBe(r.lastModified),await a.delete(s,t)})),t("deep patch",(async()=>{const a=e(),t=n(),l={something:{another:{somethingElse:"hello"}}},s=await a.put({value:l,channels:[]},t),i=await a.patch({value:[{op:"replace",path:"/something/another/somethingElse",value:"goodbye"}]},s,t),r=await a.get(s,{});o(i.value).toEqual(l),o(r.value).toEqual({something:{another:{somethingElse:"goodbye"}}})})),t("patch channels",(async()=>{const a=e(),t=n(),l=[d()],s=[d()],i=await a.put({value:{},channels:l},t),r={channels:[{op:"replace",path:"/0",value:s[0]}]},c=await a.patch(r,i,t);o(c.channels).toEqual(l);const u=await a.get(i,{},t);o(u.channels).toEqual(s),await a.delete(i,t)})),t("patch 'increment' with test",(async()=>{const a=e(),t=n(),l=await a.put({value:{counter:1},channels:[]},t),s=await a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:2}]},l,t);o(s.value).toEqual({counter:1});const i=await a.get(s,{properties:{value:{properties:{counter:{type:"integer"}}}}});o(i.value.counter).toEqual(2),await o(a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:3}]},l,t)).rejects.toThrow(c)})),t("invalid patch",(async()=>{const a=e(),t=n(),l=v(),s=await a.put(l,t);await o(a.patch({value:[{op:"add",path:"/root",value:[]},{op:"add",path:"/root/2",value:2}]},s,t)).rejects.toThrow(u)})),t("patch channels to be wrong",(async()=>{const a=e(),t=n(),l=v();l.allowed=[d()];const s=await a.put(l,t),i=[{channels:[{op:"replace",path:"",value:null}]},{channels:[{op:"replace",path:"",value:{}}]},{channels:[{op:"replace",path:"",value:["hello",["hi"]]}]},{channels:[{op:"add",path:"/0",value:1}]},{value:[{op:"replace",path:"",value:"not an object"}]},{value:[{op:"replace",path:"",value:null}]},{value:[{op:"replace",path:"",value:[]}]},{allowed:[{op:"replace",path:"",value:{}}]},{allowed:[{op:"replace",path:"",value:["hello",["hi"]]}]}];for(const e of i)await o(a.patch(e,s,t)).rejects.toThrow(u);const r=await a.get(s,{},t);o(r.value).toEqual(l.value),o(r.channels).toEqual(l.channels),o(r.allowed).toEqual(l.allowed),o(r.lastModified).toEqual(s.lastModified)}))}))},m=(n,l,s)=>{a("synchronizeDiscover",(()=>{t("get",(async()=>{const e=n(),a=l(),t=v(),s=t.channels.slice(1),i=await e.put(t,a),r=n(),c=r.synchronizeDiscover(s,{}).next(),u=await r.get(i,{},a),d=(await c).value;if(!d||d.error)throw new Error("Error in synchronize");o(d.value.value).toEqual(t.value),o(d.value.channels).toEqual(s),o(d.value.tombstone).toBe(!1),o(d.value.lastModified).toEqual(u.lastModified)})),t("put",(async()=>{const e=n(),a=l(),t=d(),s=d(),i=d(),r={hello:"world"},c=[t,i],u=await e.put({value:r,channels:c},a),v=e.synchronizeDiscover([t],{}).next(),h=e.synchronizeDiscover([s],{}).next(),w=e.synchronizeDiscover([i],{}).next(),p={goodbye:"world"},m=[s,i];await e.put({...u,value:p,channels:m},a);const E=(await v).value,q=(await h).value,y=(await w).value;if(!E||E.error||!q||q.error||!y||y.error)throw new Error("Error in synchronize");o(E.value.value).toEqual(r),o(E.value.channels).toEqual([t]),o(E.value.tombstone).toBe(!0),o(q.value.value).toEqual(p),o(q.value.channels).toEqual([s]),o(q.value.tombstone).toBe(!1),o(y.value.value).toEqual(p),o(y.value.channels).toEqual([i]),o(y.value.tombstone).toBe(!1),o(E.value.lastModified).toEqual(q.value.lastModified),o(y.value.lastModified).toEqual(q.value.lastModified)})),t("patch",(async()=>{const e=n(),a=l(),t=d(),s=d(),i=d(),r={hello:"world"},c=[t,i],u=await e.put({value:r,channels:c},a),v=e.synchronizeDiscover([t],{}).next(),h=e.synchronizeDiscover([s],{}).next(),w=e.synchronizeDiscover([i],{}).next();await e.patch({value:[{op:"add",path:"/something",value:"new value"}],channels:[{op:"add",path:"/-",value:s},{op:"remove",path:`/${c.indexOf(t)}`}]},u,a);const p=(await v).value,m=(await h).value,E=(await w).value;if(!p||p.error||!m||m.error||!E||E.error)throw new Error("Error in synchronize");const q={...r,something:"new value"};o(p.value.value).toEqual(r),o(p.value.channels).toEqual([t]),o(p.value.tombstone).toBe(!0),o(m.value.value).toEqual(q),o(m.value.channels).toEqual([s]),o(m.value.tombstone).toBe(!1),o(E.value.value).toEqual(q),o(E.value.channels).toEqual([i]),o(E.value.tombstone).toBe(!1),o(p.value.lastModified).toEqual(m.value.lastModified),o(E.value.lastModified).toEqual(m.value.lastModified)})),t("delete",(async()=>{const e=n(),a=l(),t=[d(),d(),d()],s={hello:"world"},i=[d(),...t.slice(1)],r=await e.put({value:s,channels:i},a),c=e.synchronizeDiscover(t,{}).next();e.delete(r,a);const u=(await c).value;if(!u||u.error)throw new Error("Error in synchronize");o(u.value.tombstone).toBe(!0),o(u.value.value).toEqual(s),o(u.value.channels).toEqual(t.filter((e=>i.includes(e))))})),t("not allowed",(async()=>{const e=n(),a=l(),t=s(),i=[d(),d(),d()],r=i.slice(1),c=e.synchronizeDiscover(r,{},a).next(),u=e.synchronizeDiscover(r,{},t).next(),v=e.synchronizeDiscover(r,{}).next(),h={hello:"world"},w=[d(),t.actor];await e.put({value:h,channels:i,allowed:w},a),await o(Promise.race([v,new Promise(((e,a)=>setTimeout(a,100,"Timeout")))])).rejects.toThrow("Timeout");const p=(await c).value,m=(await u).value;if(!p||p.error||!m||m.error)throw new Error("Error in synchronize");o(p.value.value).toEqual(h),o(p.value.allowed).toEqual(w),o(p.value.channels).toEqual(i),o(m.value.value).toEqual(h),o(m.value.allowed).toEqual([t.actor]),o(m.value.channels).toEqual(r)}))})),a("synchronizeGet",(()=>{t("replace, delete",(async()=>{const a=n(),t=l(),s=v(),i=await a.put(s,t),r=a.synchronizeGet(i,{}),c=r.next(),u={goodbye:"world"},d=await a.put({...i,value:u},t),h=(await c).value;e(h&&!h.error),o(h.value.value).toEqual(u),o(h.value.actor).toEqual(t.actor),o(h.value.channels).toEqual([]),o(h.value.tombstone).toBe(!1),o(h.value.lastModified).toEqual(d.lastModified),o(h.value.allowed).toBeUndefined();const w=await a.delete(d,t),p=(await r.next()).value;e(p&&!p.error),o(p.value.tombstone).toBe(!0),o(p.value.lastModified).toEqual(w.lastModified),await a.put(v(),t),await o(Promise.race([r.next(),new Promise(((e,a)=>setTimeout(a,100,"Timeout")))])).rejects.toThrow("Timeout")})),t("not allowed",(async()=>{const a=n(),t=l(),i=s(),r=v(),c=await a.put(r,t),u=a.synchronizeGet(c,{},t),d=a.synchronizeGet(c,{},i),h=u.next(),w=d.next(),p={goodbye:"world"},m=await a.put({...c,...r,allowed:[],value:p},t),E=(await h).value,q=(await w).value;e(E&&!E.error),e(q&&!q.error),o(E.value.value).toEqual(p),o(q.value.value).toEqual(r.value),o(E.value.actor).toEqual(t.actor),o(q.value.actor).toEqual(t.actor),o(E.value.channels).toEqual(r.channels),o(q.value.channels).toEqual([]),o(E.value.tombstone).toBe(!1),o(q.value.tombstone).toBe(!0),o(E.value.lastModified).toEqual(m.lastModified),o(q.value.lastModified).toEqual(m.lastModified)}))}))},E=(n,l,s)=>{a("discover",{timeout:2e4},(()=>{t("discover nothing",(async()=>{const e=n().discover([],{});o(await e.next()).toHaveProperty("done",!0)})),t("discover single",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),i=[d(),t.channels[0]],r=e.discover(i,{}),c=await h(r);o(c.value).toEqual(t.value),o(c.channels).toEqual([t.channels[0]]),o(c.allowed).toBeUndefined(),o(c.actor).toEqual(a.actor),o(c.tombstone).toBe(!1),o(c.lastModified).toEqual(s.lastModified);const u=await r.next();o(u.done).toBe(!0)})),t("discover wrong channel",(async()=>{const e=n(),a=l(),t=v();await e.put(t,a);const s=e.discover([d()],{});await o(s.next()).resolves.toHaveProperty("done",!0)})),t("discover not allowed",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),d()];const r=await e.put(i,a),c=e.discover(i.channels,{},a),u=await h(c);o(u.value).toEqual(i.value),o(u.channels).toEqual(i.channels),o(u.allowed).toEqual(i.allowed),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(r.lastModified);const w=e.discover(i.channels,{},t);o(await w.next()).toHaveProperty("done",!0);const p=e.discover(i.channels,{});o(await p.next()).toHaveProperty("done",!0)})),t("discover allowed",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),t.actor,d()];const r=await e.put(i,a),c=e.discover(i.channels,{},t),u=await h(c);o(u.value).toEqual(i.value),o(u.allowed).toEqual([t.actor]),o(u.channels).toEqual(i.channels),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(r.lastModified)}));for(const e of["name","actor","lastModified"])t(`discover for ${e}`,(async()=>{const a=n(),t=l(),i=s(),r=v(),c=await a.put(r,t),u=v();u.channels=r.channels,await new Promise((e=>setTimeout(e,20)));const d=await a.put(u,i),w=a.discover(r.channels,{properties:{[e]:{enum:[c[e]]}}}),p=await h(w);o(p.name).toEqual(c.name),o(p.name).not.toEqual(d.name),o(p.value).toEqual(r.value),await o(w.next()).resolves.toHaveProperty("done",!0)}));t("discover with lastModified range",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await new Promise((e=>setTimeout(e,20)));const i=await e.put(t,a);o(s.name).not.toEqual(i.name),o(s.lastModified).toBeLessThan(i.lastModified);const r=e.discover([t.channels[0]],{properties:{lastModified:{minimum:i.lastModified,exclusiveMinimum:!0}}});o(await r.next()).toHaveProperty("done",!0);const c=e.discover([t.channels[0]],{properties:{lastModified:{minimum:i.lastModified-.1,exclusiveMinimum:!0}}}),u=await h(c);o(u.name).toEqual(i.name),o(await c.next()).toHaveProperty("done",!0);const d=e.discover(t.channels,{properties:{value:{},lastModified:{minimum:i.lastModified}}}),w=await h(d);o(w.name).toEqual(i.name),o(await d.next()).toHaveProperty("done",!0);const p=e.discover(t.channels,{properties:{lastModified:{minimum:i.lastModified+.1}}});o(await p.next()).toHaveProperty("done",!0);const m=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified,exclusiveMaximum:!0}}});o(await m.next()).toHaveProperty("done",!0);const E=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified+.1,exclusiveMaximum:!0}}}),q=await h(E);o(q.name).toEqual(s.name),o(await E.next()).toHaveProperty("done",!0);const y=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified}}}),f=await h(y);o(f.name).toEqual(s.name),o(await y.next()).toHaveProperty("done",!0);const g=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified-.1}}});o(await g.next()).toHaveProperty("done",!0)})),t("discover schema allowed, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),t.actor,d()],await e.put(i,a);const r=e.discover(i.channels,{properties:{allowed:{minItems:3,not:{items:{not:{enum:[t.actor]}}}}}},a),c=await h(r);o(c.value).toEqual(i.value),await o(r.next()).resolves.toHaveProperty("done",!0);const u=e.discover(i.channels,{properties:{allowed:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const w=e.discover(i.channels,{properties:{allowed:{not:{items:{not:{enum:[i.channels[0]]}}}}}},t);await o(w.next()).resolves.toHaveProperty("done",!0);const p=e.discover(i.channels,{properties:{allowed:{maxItems:1,not:{items:{not:{enum:[t.actor]}}}}}},t),m=await h(p);o(m.value).toEqual(i.value),await o(p.next()).resolves.toHaveProperty("done",!0)})),t("discover schema channels, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),i=v();i.channels=[d(),d(),d()],await e.put(i,a);const r=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{minItems:3,not:{items:{not:{enum:[i.channels[1]]}}}}}},a),c=await h(r);o(c.value).toEqual(i.value),await o(r.next()).resolves.toHaveProperty("done",!0);const u=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const w=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{not:{items:{not:{enum:[i.channels[1]]}}}}}},t);await o(w.next()).resolves.toHaveProperty("done",!0);const p=e.discover([i.channels[0],i.channels[2]],{properties:{allowed:{maxItems:2,not:{items:{not:{enum:[i.channels[2]]}}}}}},t),m=await h(p);o(m.value).toEqual(i.value),await o(p.next()).resolves.toHaveProperty("done",!0)})),t("discover query for empty allowed",(async()=>{const e=n(),a=l(),t=v(),s={not:{required:["allowed"]}};await e.put(t,a);const i=e.discover(t.channels,s,a),r=await h(i);o(r.value).toEqual(t.value),o(r.allowed).toBeUndefined(),await o(i.next()).resolves.toHaveProperty("done",!0);const c=v();c.allowed=[],await e.put(c,a);const u=e.discover(c.channels,s,a);await o(u.next()).resolves.toHaveProperty("done",!0)})),t("discover query for values",(async()=>{const a=n(),t=l(),s=v();s.value={test:d()},await a.put(s,t);const i=v();i.channels=s.channels,i.value={test:d(),something:d()},await a.put(i,t);const r=v();r.channels=s.channels,r.value={other:d(),something:d()},await a.put(r,t);const c=new Map;for(const t of["test","something","other"]){let o=0;for await(const n of a.discover(s.channels,{properties:{value:{required:[t]}}}))e(!n.error,"result has error"),t in n.value.value&&o++;c.set(t,o)}o(c.get("test")).toBe(2),o(c.get("something")).toBe(2),o(c.get("other")).toBe(1)})),t("discover for deleted content",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),i=await e.delete(s,a),r=e.discover(t.channels,{}),c=await h(r);o(c.tombstone).toBe(!0),o(c.value).toEqual(t.value),o(c.channels).toEqual(t.channels),o(c.actor).toEqual(a.actor),o(c.lastModified).toEqual(i.lastModified),await o(r.next()).resolves.toHaveProperty("done",!0)})),t("discover for replaced channels",(async()=>{for(let e=0;e<10;e++){const e=n(),a=l(),t=v(),s=await e.put(t,a),i=v(),r=await e.put({...s,...i},a),c=e.discover(t.channels,{}),u=await h(c);await o(c.next()).resolves.toHaveProperty("done",!0);const d=e.discover(i.channels,{}),w=await h(d);await o(d.next()).resolves.toHaveProperty("done",!0),s.lastModified===r.lastModified?(o(u.tombstone||w.tombstone).toBe(!0),o(u.tombstone&&w.tombstone).toBe(!1)):(o(u.tombstone).toBe(!0),o(u.value).toEqual(t.value),o(u.channels).toEqual(t.channels),o(u.lastModified).toEqual(r.lastModified),o(w.tombstone).toBe(!1),o(w.value).toEqual(i.value),o(w.channels).toEqual(i.channels),o(w.lastModified).toEqual(r.lastModified))}})),t("discover for patched allowed",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await e.patch({allowed:[{op:"add",path:"",value:[]}]},s,a);const i=e.discover(t.channels,{}),r=await h(i);o(r.tombstone).toBe(!0),o(r.value).toEqual(t.value),o(r.channels).toEqual(t.channels),o(r.allowed).toBeUndefined(),await o(i.next()).resolves.toHaveProperty("done",!0)})),t("put concurrently and discover one",(async()=>{const a=n(),t=l(),s=v();s.name=d();const i=Array(100).fill(0).map((()=>a.put(s,t)));await Promise.all(i);const r=a.discover(s.channels,{});let c=0,u=0;for await(const a of r)e(!a.error,"result has error"),a.value.tombstone?c++:u++;o(c).toBe(99),o(u).toBe(1)}))}))};export{p as graffitiCRUDTests,E as graffitiDiscoverTests,w as graffitiLocationTests,m as graffitiSynchronizeTests};
+import{assert as e,describe as a,it as t,expect as o}from"vitest";import{GraffitiErrorInvalidUri as n,GraffitiErrorNotFound as l,GraffitiErrorForbidden as s,GraffitiErrorInvalidSchema as i,GraffitiErrorSchemaMismatch as c,GraffitiErrorPatchTestFailed as r,GraffitiErrorPatchError as u}from"@graffiti-garden/api";function d(){const e=new Uint8Array(16);crypto.getRandomValues(e);return Array.from(e).map((e=>e.toString(16).padStart(2,"0"))).join("")+"👩🏽‍❤️‍💋‍👩🏻🫱🏼‍🫲🏿"}function v(){return{value:{[d()]:d()},channels:[d(),d()]}}async function h(a){const t=await a.next();return e(!t.done&&!t.value.error,"result has no value"),t.value.value}const w=e=>{a("URI and location conversion",(()=>{t("location to uri and back",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()},n=a.locationToUri(t),l=a.uriToLocation(n);o(t).toEqual(l)})),t("collision resistance",(async()=>{const a=e(),t={name:d(),actor:d(),source:d()};for(const e of["name","actor","source"]){const n={...t,[e]:d()},l=a.locationToUri(t),s=a.locationToUri(n);o(l).not.toEqual(s)}})),t("random URI should not be a valid location",(async()=>{const a=e();o((()=>a.uriToLocation(""))).toThrow(n)}))}))},p=(e,n,h)=>{a("CRUD",{timeout:2e4},(()=>{t("put, get, delete",(async()=>{const a=e(),t=n(),l={something:"hello, world~ c:"},s=[d(),d()],i=await a.put({value:l,channels:s},t);o(i.value).toEqual({}),o(i.channels).toEqual([]),o(i.allowed).toBeUndefined(),o(i.actor).toEqual(t.actor);const c=await a.get(i,{});o(c.value).toEqual(l),o(c.channels).toEqual([]),o(c.allowed).toBeUndefined(),o(c.name).toEqual(i.name),o(c.actor).toEqual(i.actor),o(c.source).toEqual(i.source),o(c.lastModified).toEqual(i.lastModified);const r={something:"goodbye, world~ :c"},u=await a.put({...i,value:r,channels:[]},t);o(u.value).toEqual(l),o(u.tombstone).toEqual(!0),o(u.name).toEqual(i.name),o(u.actor).toEqual(i.actor),o(u.source).toEqual(i.source),o(u.lastModified).toBeGreaterThan(c.lastModified);const v=await a.get(i,{});o(v.value).toEqual(r),o(v.lastModified).toEqual(u.lastModified),o(v.tombstone).toEqual(!1);const h=await a.delete(v,t);o(h.tombstone).toEqual(!0),o(h.value).toEqual(r),o(h.lastModified).toBeGreaterThan(u.lastModified);const w=await a.get(v,{});o(w).toEqual(h)})),t("get non-existant",(async()=>{const a=e(),t=n(),s=await a.put(v(),t);await o(a.get({...s,name:d()},{})).rejects.toBeInstanceOf(l)})),t("put, get, delete with wrong actor",(async()=>{const a=e(),t=n(),l=h();await o(a.put({value:{},channels:[],actor:l.actor},t)).rejects.toThrow(s);const i=await a.put({value:{},channels:[]},l);await o(a.delete(i,t)).rejects.toThrow(s),await o(a.patch({},i,t)).rejects.toThrow(s)})),t("put and get with schema",(async()=>{const a=e(),t=n(),l={something:"hello",another:42},s=await a.put({value:l,channels:[]},t),i=await a.get(s,{properties:{value:{properties:{something:{type:"string"},another:{type:"integer"}}}}});o(i.value.something).toEqual(l.something),o(i.value.another).toEqual(l.another)})),t("put and get with invalid schema",(async()=>{const a=e(),t=n(),l=await a.put({value:{},channels:[]},t);await o(a.get(l,{properties:{value:{type:"asdf"}}})).rejects.toThrow(i)})),t("put and get with wrong schema",(async()=>{const a=e(),t=n(),l=await a.put({value:{hello:"world"},channels:[]},t);await o(a.get(l,{properties:{value:{properties:{hello:{type:"number"}}}}})).rejects.toThrow(c)})),t("put and get with empty access control",(async()=>{const a=e(),t=n(),s=h(),i={um:"hi"},c=[d()],r=[d()],u=await a.put({value:i,allowed:c,channels:r},t),v=await a.get(u,{},t);o(v.value).toEqual(i),o(v.allowed).toEqual(c),o(v.channels).toEqual(r),await o(a.get(u,{})).rejects.toBeInstanceOf(l),await o(a.get(u,{},s)).rejects.toBeInstanceOf(l)})),t("put and get with specific access control",(async()=>{const a=e(),t=n(),s=h(),i={um:"hi"},c=[d(),s.actor,d()],r=[d()],u=await a.put({value:i,allowed:c,channels:r},t),v=await a.get(u,{},t);o(v.value).toEqual(i),o(v.allowed).toEqual(c),o(v.channels).toEqual(r),await o(a.get(u,{})).rejects.toBeInstanceOf(l);const w=await a.get(u,{},s);o(w.value).toEqual(i),o(w.allowed).toEqual([s.actor]),o(w.channels).toEqual([])})),t("patch value",(async()=>{const a=e(),t=n(),l={something:"hello, world~ c:"},s=await a.put({value:l,channels:[]},t),i=await a.patch({value:[{op:"replace",path:"/something",value:"goodbye, world~ :c"}]},s,t);o(i.value).toEqual(l),o(i.tombstone).toBe(!0);const c=await a.get(s,{});o(c.value).toEqual({something:"goodbye, world~ :c"}),o(i.lastModified).toBe(c.lastModified),await a.delete(s,t)})),t("patch deleted object",(async()=>{const a=e(),t=n(),s=await a.put(v(),t);await a.delete(s,t),await o(a.patch({},s,t)).rejects.toBeInstanceOf(l)})),t("deep patch",(async()=>{const a=e(),t=n(),l={something:{another:{somethingElse:"hello"}}},s=await a.put({value:l,channels:[]},t),i=await a.patch({value:[{op:"replace",path:"/something/another/somethingElse",value:"goodbye"}]},s,t),c=await a.get(s,{});o(i.value).toEqual(l),o(c.value).toEqual({something:{another:{somethingElse:"goodbye"}}})})),t("patch channels",(async()=>{const a=e(),t=n(),l=[d()],s=[d()],i=await a.put({value:{},channels:l},t),c={channels:[{op:"replace",path:"/0",value:s[0]}]},r=await a.patch(c,i,t);o(r.channels).toEqual(l);const u=await a.get(i,{},t);o(u.channels).toEqual(s),await a.delete(i,t)})),t("patch 'increment' with test",(async()=>{const a=e(),t=n(),l=await a.put({value:{counter:1},channels:[]},t),s=await a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:2}]},l,t);o(s.value).toEqual({counter:1});const i=await a.get(s,{properties:{value:{properties:{counter:{type:"integer"}}}}});o(i.value.counter).toEqual(2),await o(a.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:3}]},l,t)).rejects.toThrow(r)})),t("invalid patch",(async()=>{const a=e(),t=n(),l=v(),s=await a.put(l,t);await o(a.patch({value:[{op:"add",path:"/root",value:[]},{op:"add",path:"/root/2",value:2}]},s,t)).rejects.toThrow(u)})),t("patch channels to be wrong",(async()=>{const a=e(),t=n(),l=v();l.allowed=[d()];const s=await a.put(l,t),i=[{channels:[{op:"replace",path:"",value:null}]},{channels:[{op:"replace",path:"",value:{}}]},{channels:[{op:"replace",path:"",value:["hello",["hi"]]}]},{channels:[{op:"add",path:"/0",value:1}]},{value:[{op:"replace",path:"",value:"not an object"}]},{value:[{op:"replace",path:"",value:null}]},{value:[{op:"replace",path:"",value:[]}]},{allowed:[{op:"replace",path:"",value:{}}]},{allowed:[{op:"replace",path:"",value:["hello",["hi"]]}]}];for(const e of i)await o(a.patch(e,s,t)).rejects.toThrow(u);const c=await a.get(s,{},t);o(c.value).toEqual(l.value),o(c.channels).toEqual(l.channels),o(c.allowed).toEqual(l.allowed),o(c.lastModified).toEqual(s.lastModified)}))}))},m=(n,l,s)=>{a("synchronizeDiscover",(()=>{t("get",(async()=>{const e=n(),a=l(),t=v(),s=t.channels.slice(1),i=await e.put(t,a),c=n(),r=c.synchronizeDiscover(s,{}).next(),u=await c.get(i,{},a),d=(await r).value;if(!d||d.error)throw new Error("Error in synchronize");o(d.value.value).toEqual(t.value),o(d.value.channels).toEqual(s),o(d.value.tombstone).toBe(!1),o(d.value.lastModified).toEqual(u.lastModified)})),t("put",(async()=>{const e=n(),a=l(),t=d(),s=d(),i=d(),c={hello:"world"},r=[t,i],u=await e.put({value:c,channels:r},a),v=e.synchronizeDiscover([t],{}).next(),h=e.synchronizeDiscover([s],{}).next(),w=e.synchronizeDiscover([i],{}).next(),p={goodbye:"world"},m=[s,i];await e.put({...u,value:p,channels:m},a);const E=(await v).value,f=(await h).value,q=(await w).value;if(!E||E.error||!f||f.error||!q||q.error)throw new Error("Error in synchronize");o(E.value.value).toEqual(c),o(E.value.channels).toEqual([t]),o(E.value.tombstone).toBe(!0),o(f.value.value).toEqual(p),o(f.value.channels).toEqual([s]),o(f.value.tombstone).toBe(!1),o(q.value.value).toEqual(p),o(q.value.channels).toEqual([i]),o(q.value.tombstone).toBe(!1),o(E.value.lastModified).toEqual(f.value.lastModified),o(q.value.lastModified).toEqual(f.value.lastModified)})),t("patch",(async()=>{const e=n(),a=l(),t=d(),s=d(),i=d(),c={hello:"world"},r=[t,i],u=await e.put({value:c,channels:r},a),v=e.synchronizeDiscover([t],{}).next(),h=e.synchronizeDiscover([s],{}).next(),w=e.synchronizeDiscover([i],{}).next();await e.patch({value:[{op:"add",path:"/something",value:"new value"}],channels:[{op:"add",path:"/-",value:s},{op:"remove",path:`/${r.indexOf(t)}`}]},u,a);const p=(await v).value,m=(await h).value,E=(await w).value;if(!p||p.error||!m||m.error||!E||E.error)throw new Error("Error in synchronize");const f={...c,something:"new value"};o(p.value.value).toEqual(c),o(p.value.channels).toEqual([t]),o(p.value.tombstone).toBe(!0),o(m.value.value).toEqual(f),o(m.value.channels).toEqual([s]),o(m.value.tombstone).toBe(!1),o(E.value.value).toEqual(f),o(E.value.channels).toEqual([i]),o(E.value.tombstone).toBe(!1),o(p.value.lastModified).toEqual(m.value.lastModified),o(E.value.lastModified).toEqual(m.value.lastModified)})),t("delete",(async()=>{const e=n(),a=l(),t=[d(),d(),d()],s={hello:"world"},i=[d(),...t.slice(1)],c=await e.put({value:s,channels:i},a),r=e.synchronizeDiscover(t,{}).next();e.delete(c,a);const u=(await r).value;if(!u||u.error)throw new Error("Error in synchronize");o(u.value.tombstone).toBe(!0),o(u.value.value).toEqual(s),o(u.value.channels).toEqual(t.filter((e=>i.includes(e))))})),t("not allowed",(async()=>{const e=n(),a=l(),t=s(),i=[d(),d(),d()],c=i.slice(1),r=e.synchronizeDiscover(c,{},a).next(),u=e.synchronizeDiscover(c,{},t).next(),v=e.synchronizeDiscover(c,{}).next(),h={hello:"world"},w=[d(),t.actor];await e.put({value:h,channels:i,allowed:w},a),await o(Promise.race([v,new Promise(((e,a)=>setTimeout(a,100,"Timeout")))])).rejects.toThrow("Timeout");const p=(await r).value,m=(await u).value;if(!p||p.error||!m||m.error)throw new Error("Error in synchronize");o(p.value.value).toEqual(h),o(p.value.allowed).toEqual(w),o(p.value.channels).toEqual(i),o(m.value.value).toEqual(h),o(m.value.allowed).toEqual([t.actor]),o(m.value.channels).toEqual(c)}))})),a("synchronizeGet",(()=>{t("replace, delete",(async()=>{const a=n(),t=l(),s=v(),i=await a.put(s,t),c=a.synchronizeGet(i,{}),r=c.next(),u={goodbye:"world"},d=await a.put({...i,value:u},t),h=(await r).value;e(h&&!h.error),o(h.value.value).toEqual(u),o(h.value.actor).toEqual(t.actor),o(h.value.channels).toEqual([]),o(h.value.tombstone).toBe(!1),o(h.value.lastModified).toEqual(d.lastModified),o(h.value.allowed).toBeUndefined();const w=await a.delete(d,t),p=(await c.next()).value;e(p&&!p.error),o(p.value.tombstone).toBe(!0),o(p.value.lastModified).toEqual(w.lastModified),await a.put(v(),t),await o(Promise.race([c.next(),new Promise(((e,a)=>setTimeout(a,100,"Timeout")))])).rejects.toThrow("Timeout")})),t("not allowed",(async()=>{const a=n(),t=l(),i=s(),c=v(),r=await a.put(c,t),u=a.synchronizeGet(r,{},t),d=a.synchronizeGet(r,{},i),h=u.next(),w=d.next(),p={goodbye:"world"},m=await a.put({...r,...c,allowed:[],value:p},t),E=(await h).value,f=(await w).value;e(E&&!E.error),e(f&&!f.error),o(E.value.value).toEqual(p),o(f.value.value).toEqual(c.value),o(E.value.actor).toEqual(t.actor),o(f.value.actor).toEqual(t.actor),o(E.value.channels).toEqual(c.channels),o(f.value.channels).toEqual([]),o(E.value.tombstone).toBe(!1),o(f.value.tombstone).toBe(!0),o(E.value.lastModified).toEqual(m.lastModified),o(f.value.lastModified).toEqual(m.lastModified)}))}))},E=(n,l,s)=>{a("discover",{timeout:2e4},(()=>{t("discover nothing",(async()=>{const e=n().discover([],{});o(await e.next()).toHaveProperty("done",!0)})),t("discover single",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),i=[d(),t.channels[0]],c=e.discover(i,{}),r=await h(c);o(r.value).toEqual(t.value),o(r.channels).toEqual([t.channels[0]]),o(r.allowed).toBeUndefined(),o(r.actor).toEqual(a.actor),o(r.tombstone).toBe(!1),o(r.lastModified).toEqual(s.lastModified);const u=await c.next();o(u.done).toBe(!0)})),t("discover wrong channel",(async()=>{const e=n(),a=l(),t=v();await e.put(t,a);const s=e.discover([d()],{});await o(s.next()).resolves.toHaveProperty("done",!0)})),t("discover not allowed",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),d()];const c=await e.put(i,a),r=e.discover(i.channels,{},a),u=await h(r);o(u.value).toEqual(i.value),o(u.channels).toEqual(i.channels),o(u.allowed).toEqual(i.allowed),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(c.lastModified);const w=e.discover(i.channels,{},t);o(await w.next()).toHaveProperty("done",!0);const p=e.discover(i.channels,{});o(await p.next()).toHaveProperty("done",!0)})),t("discover allowed",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),t.actor,d()];const c=await e.put(i,a),r=e.discover(i.channels,{},t),u=await h(r);o(u.value).toEqual(i.value),o(u.allowed).toEqual([t.actor]),o(u.channels).toEqual(i.channels),o(u.actor).toEqual(a.actor),o(u.tombstone).toBe(!1),o(u.lastModified).toEqual(c.lastModified)}));for(const e of["name","actor","lastModified"])t(`discover for ${e}`,(async()=>{const a=n(),t=l(),i=s(),c=v(),r=await a.put(c,t),u=v();u.channels=c.channels,await new Promise((e=>setTimeout(e,20)));const d=await a.put(u,i),w=a.discover(c.channels,{properties:{[e]:{enum:[r[e]]}}}),p=await h(w);o(p.name).toEqual(r.name),o(p.name).not.toEqual(d.name),o(p.value).toEqual(c.value),await o(w.next()).resolves.toHaveProperty("done",!0)}));t("discover with lastModified range",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await new Promise((e=>setTimeout(e,20)));const i=await e.put(t,a);o(s.name).not.toEqual(i.name),o(s.lastModified).toBeLessThan(i.lastModified);const c=e.discover([t.channels[0]],{properties:{lastModified:{minimum:i.lastModified,exclusiveMinimum:!0}}});o(await c.next()).toHaveProperty("done",!0);const r=e.discover([t.channels[0]],{properties:{lastModified:{minimum:i.lastModified-.1,exclusiveMinimum:!0}}}),u=await h(r);o(u.name).toEqual(i.name),o(await r.next()).toHaveProperty("done",!0);const d=e.discover(t.channels,{properties:{value:{},lastModified:{minimum:i.lastModified}}}),w=await h(d);o(w.name).toEqual(i.name),o(await d.next()).toHaveProperty("done",!0);const p=e.discover(t.channels,{properties:{lastModified:{minimum:i.lastModified+.1}}});o(await p.next()).toHaveProperty("done",!0);const m=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified,exclusiveMaximum:!0}}});o(await m.next()).toHaveProperty("done",!0);const E=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified+.1,exclusiveMaximum:!0}}}),f=await h(E);o(f.name).toEqual(s.name),o(await E.next()).toHaveProperty("done",!0);const q=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified}}}),y=await h(q);o(y.name).toEqual(s.name),o(await q.next()).toHaveProperty("done",!0);const M=e.discover(t.channels,{properties:{lastModified:{maximum:s.lastModified-.1}}});o(await M.next()).toHaveProperty("done",!0)})),t("discover schema allowed, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),i=v();i.allowed=[d(),t.actor,d()],await e.put(i,a);const c=e.discover(i.channels,{properties:{allowed:{minItems:3,not:{items:{not:{enum:[t.actor]}}}}}},a),r=await h(c);o(r.value).toEqual(i.value),await o(c.next()).resolves.toHaveProperty("done",!0);const u=e.discover(i.channels,{properties:{allowed:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const w=e.discover(i.channels,{properties:{allowed:{not:{items:{not:{enum:[i.channels[0]]}}}}}},t);await o(w.next()).resolves.toHaveProperty("done",!0);const p=e.discover(i.channels,{properties:{allowed:{maxItems:1,not:{items:{not:{enum:[t.actor]}}}}}},t),m=await h(p);o(m.value).toEqual(i.value),await o(p.next()).resolves.toHaveProperty("done",!0)})),t("discover schema channels, as and not as owner",(async()=>{const e=n(),a=l(),t=s(),i=v();i.channels=[d(),d(),d()],await e.put(i,a);const c=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{minItems:3,not:{items:{not:{enum:[i.channels[1]]}}}}}},a),r=await h(c);o(r.value).toEqual(i.value),await o(c.next()).resolves.toHaveProperty("done",!0);const u=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{minItems:3}}},t);await o(u.next()).resolves.toHaveProperty("done",!0);const w=e.discover([i.channels[0],i.channels[2]],{properties:{channels:{not:{items:{not:{enum:[i.channels[1]]}}}}}},t);await o(w.next()).resolves.toHaveProperty("done",!0);const p=e.discover([i.channels[0],i.channels[2]],{properties:{allowed:{maxItems:2,not:{items:{not:{enum:[i.channels[2]]}}}}}},t),m=await h(p);o(m.value).toEqual(i.value),await o(p.next()).resolves.toHaveProperty("done",!0)})),t("discover query for empty allowed",(async()=>{const e=n(),a=l(),t=v(),s={not:{required:["allowed"]}};await e.put(t,a);const i=e.discover(t.channels,s,a),c=await h(i);o(c.value).toEqual(t.value),o(c.allowed).toBeUndefined(),await o(i.next()).resolves.toHaveProperty("done",!0);const r=v();r.allowed=[],await e.put(r,a);const u=e.discover(r.channels,s,a);await o(u.next()).resolves.toHaveProperty("done",!0)})),t("discover query for values",(async()=>{const a=n(),t=l(),s=v();s.value={test:d()},await a.put(s,t);const i=v();i.channels=s.channels,i.value={test:d(),something:d()},await a.put(i,t);const c=v();c.channels=s.channels,c.value={other:d(),something:d()},await a.put(c,t);const r=new Map;for(const t of["test","something","other"]){let o=0;for await(const n of a.discover(s.channels,{properties:{value:{required:[t]}}}))e(!n.error,"result has error"),t in n.value.value&&o++;r.set(t,o)}o(r.get("test")).toBe(2),o(r.get("something")).toBe(2),o(r.get("other")).toBe(1)})),t("discover for deleted content",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a),i=await e.delete(s,a),c=e.discover(t.channels,{}),r=await h(c);o(r.tombstone).toBe(!0),o(r.value).toEqual(t.value),o(r.channels).toEqual(t.channels),o(r.actor).toEqual(a.actor),o(r.lastModified).toEqual(i.lastModified),await o(c.next()).resolves.toHaveProperty("done",!0)})),t("discover for replaced channels",(async()=>{for(let e=0;e<10;e++){const e=n(),a=l(),t=v(),s=await e.put(t,a),i=v(),c=await e.put({...s,...i},a),r=e.discover(t.channels,{}),u=await h(r);await o(r.next()).resolves.toHaveProperty("done",!0);const d=e.discover(i.channels,{}),w=await h(d);await o(d.next()).resolves.toHaveProperty("done",!0),s.lastModified===c.lastModified?(o(u.tombstone||w.tombstone).toBe(!0),o(u.tombstone&&w.tombstone).toBe(!1)):(o(u.tombstone).toBe(!0),o(u.value).toEqual(t.value),o(u.channels).toEqual(t.channels),o(u.lastModified).toEqual(c.lastModified),o(w.tombstone).toBe(!1),o(w.value).toEqual(i.value),o(w.channels).toEqual(i.channels),o(w.lastModified).toEqual(c.lastModified))}})),t("discover for patched allowed",(async()=>{const e=n(),a=l(),t=v(),s=await e.put(t,a);await e.patch({allowed:[{op:"add",path:"",value:[]}]},s,a);const i=e.discover(t.channels,{}),c=await h(i);o(c.tombstone).toBe(!0),o(c.value).toEqual(t.value),o(c.channels).toEqual(t.channels),o(c.allowed).toBeUndefined(),await o(i.next()).resolves.toHaveProperty("done",!0)})),t("put concurrently and discover one",(async()=>{const a=n(),t=l(),s=v();s.name=d();const i=Array(100).fill(0).map((()=>a.put(s,t)));await Promise.all(i);const c=a.discover(s.channels,{});let r=0,u=0;for await(const a of c)e(!a.error,"result has error"),a.value.tombstone?r++:u++;o(r).toBe(99),o(u).toBe(1)}))}))},f=(e,n,l)=>{a("recoverOrphans",(()=>{t("list orphans",(async()=>{const a=e(),t=n(),l=[],s=a.recoverOrphans({},t);for await(const e of s)e.error||l.push(e.value.name);const i=v();i.channels=[];const c=await a.put(i,t),r=a.recoverOrphans({},t);let u=0;for await(const e of r)e.error||e.value.name===c.name&&(u++,o(e.value.source).toBe(c.source),o(e.value.lastModified).toBe(c.lastModified));o(u).toBe(1)})),t("replaced orphan, no longer",(async()=>{const a=e(),t=n(),l=v();l.channels=[];const s=await a.put(l,t),i=await a.put({...s,...l,channels:[d()]},t);o(i.name).toBe(s.name);const c=a.recoverOrphans({},t);let r=0;for await(const e of c)e.error||e.value.name===s.name&&(r++,o(e.value.tombstone).toBe(!0),o(e.value.lastModified).toBe(i.lastModified),o(e.value.channels).toEqual([]));o(r).toBe(1)}))}))},q=(n,l,s)=>{a("channel stats",(()=>{t("list channels",(async()=>{const e=n(),a=l(),t=new Map,s=e.channelStats(a);for await(const e of s)e.error||t.set(e.value.channel,e.value.count);const i=[d(),d(),d()];for(let t=0;t<3;t++)for(let o=0;o<t+1;o++)await e.put({value:{index:o},channels:i.slice(0,t+1)},a);await e.put({value:{index:3},channels:[i[2]]},a);const c=e.channelStats(a);let r=new Map;for await(const e of c)e.error||r.set(e.value.channel,e.value.count);r=new Map(Array.from(r).filter((([e,a])=>!t.has(e)))),o(r.size).toBe(3),o(r.get(i[0])).toBe(6),o(r.get(i[1])).toBe(5),o(r.get(i[2])).toBe(4)})),t("list channels with deleted channel",(async()=>{const a=n(),t=l(),s=[d(),d(),d()],i=await a.put({value:{index:2},channels:s.slice(1)},t),c=await a.put({value:{index:0},channels:s},t);await a.delete(c,t);const r=await a.put({value:{index:1},channels:s.slice(2)},t),u=a.channelStats(t);let v=0,h=0;for await(const a of u){if(a.error)continue;const{channel:t,count:n,lastModified:l}=a.value;e(t!==s[0],"There should not be an object in channel[0]"),t===s[1]?(o(n).toBe(1),o(l).toBe(i.lastModified),v++):t===s[2]&&(o(n).toBe(2),o(l).toBe(r.lastModified),h++)}o(v).toBe(1),o(h).toBe(1)}))}))};export{p as graffitiCRUDTests,q as graffitiChannelStatsTests,E as graffitiDiscoverTests,w as graffitiLocationTests,f as graffitiOrphanTests,m as graffitiSynchronizeTests};
 //# sourceMappingURL=index.js.map

package/dist/tests/src/channel-stats.d.ts

@@ -0,0 +1,3 @@
+import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
+export declare const graffitiChannelStatsTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=channel-stats.d.ts.map

package/dist/tests/src/channel-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-stats.d.ts","sourceRoot":"","sources":["../../../tests/src/channel-stats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG7E,eAAO,MAAM,yBAAyB,gBACvB,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SAiHnC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../tests/src/crud.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAEhB,MAAM,sBAAsB,CAAC;AAW9B,eAAO,MAAM,iBAAiB,gBACf,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,eACxD,MAAM,eAAe,eACrB,MAAM,eAAe,SAwcnC,CAAC"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../tests/src/crud.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAEhB,MAAM,sBAAsB,CAAC;AAW9B,eAAO,MAAM,iBAAiB,gBACf,MAAM,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC,eACxD,MAAM,eAAe,eACrB,MAAM,eAAe,SAwenC,CAAC"}

package/dist/tests/src/index.d.ts

@@ -2,4 +2,6 @@ export * from "./location";
 export * from "./crud";
 export * from "./synchronize";
 export * from "./discover";
+export * from "./orphans";
+export * from "./channel-stats";
 //# sourceMappingURL=index.d.ts.map

package/dist/tests/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tests/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tests/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC"}

package/dist/tests/src/list.d.ts

@@ -0,0 +1,3 @@
+import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
+export declare const graffitiListTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=list.d.ts.map

package/dist/tests/src/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../tests/src/list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG7E,eAAO,MAAM,iBAAiB,gBACf,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SAgBnC,CAAC"}

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

@@ -0,0 +1,3 @@
+import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
+export declare const graffitiOrphanTests: (useGraffiti: GraffitiFactory, useSession1: () => GraffitiSession, useSession2: () => GraffitiSession) => void;
+//# sourceMappingURL=orphans.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orphans.d.ts","sourceRoot":"","sources":["../../../tests/src/orphans.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG7E,eAAO,MAAM,mBAAmB,gBACjB,eAAe,eACf,MAAM,eAAe,eACrB,MAAM,eAAe,SA8DnC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../tests/src/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE9E,wBAAgB,YAAY,IAAI,MAAM,CAMrC;AAED,wBAAgB,WAAW;;EAI1B;AAED,wBAAgB,eAAe,IAAI,iBAAiB,CAAC,EAAE,CAAC,CAKvD;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,cAIzE"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../tests/src/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,CAAC,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,cAIzE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiti-garden/api",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The heart of Graffiti",
   "types": "./dist/src/index.d.ts",
   "module": "./dist/index.js",

package/src/1-api.ts

@@ -23,6 +23,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 +37,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 +238,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 +318,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 +434,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,92 +504,56 @@ 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>(
+  abstract recoverOrphans<Schema extends JSONSchema4>(
     /**
-     * The location of the object to get.
-     */
-    locationOrUri: GraffitiLocation | string,
-    /**
-     * 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 all {@link GraffitiObjectBase.channels | `channel`}s
    * 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.
+   * {@link GraffitiObjectBase.tombstone | `tombstone`}d objects are not included
+   * in either the `count` or `lastModified` fields.
    */
-  abstract listChannels(
+  abstract channelStats(
     /**
      * An implementation-specific object with information to authenticate the
      * {@link GraffitiObjectBase.actor | `actor`}.
@@ -580,37 +561,10 @@ export abstract class Graffiti {
     session: GraffitiSession,
   ): GraffitiStream<{
     channel: string;
-    lastModified: number;
     count: number;
+    lastModified: 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;
-
   /**
    * Begins the login process. Depending on the implementation, this may
    * involve redirecting the user to a login page or opening a popup,
@@ -682,6 +636,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
@@ -310,8 +310,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,121 @@
+import { it, expect, describe, assert } from "vitest";
+import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
+import { randomPutObject, randomString } from "./utils";
+
+export const graffitiChannelStatsTests = (
+  useGraffiti: GraffitiFactory,
+  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";

package/tests/src/orphans.ts

@@ -0,0 +1,70 @@
+import { it, expect, describe, assert } from "vitest";
+import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
+import { randomPutObject, randomString } from "./utils";
+
+export const graffitiOrphanTests = (
+  useGraffiti: GraffitiFactory,
+  useSession1: () => GraffitiSession,
+  useSession2: () => GraffitiSession,
+) => {
+  describe("recoverOrphans", () => {
+    it("list orphans", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+
+      const existingOrphans: string[] = [];
+      const orphanIterator1 = graffiti.recoverOrphans({}, session);
+      for await (const orphan of orphanIterator1) {
+        if (orphan.error) continue;
+        existingOrphans.push(orphan.value.name);
+      }
+
+      const object = randomPutObject();
+      object.channels = [];
+      const putted = await graffiti.put(object, session);
+      const orphanIterator2 = graffiti.recoverOrphans({}, session);
+      let numResults = 0;
+      for await (const orphan of orphanIterator2) {
+        if (orphan.error) continue;
+        if (orphan.value.name === putted.name) {
+          numResults++;
+          expect(orphan.value.source).toBe(putted.source);
+          expect(orphan.value.lastModified).toBe(putted.lastModified);
+        }
+      }
+      expect(numResults).toBe(1);
+    });
+
+    it("replaced orphan, no longer", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+
+      const object = randomPutObject();
+      object.channels = [];
+      const putOrphan = await graffiti.put(object, session);
+
+      const putNotOrphan = await graffiti.put(
+        {
+          ...putOrphan,
+          ...object,
+          channels: [randomString()],
+        },
+        session,
+      );
+      expect(putNotOrphan.name).toBe(putOrphan.name);
+
+      const orphanIterator = graffiti.recoverOrphans({}, session);
+      let numResults = 0;
+      for await (const orphan of orphanIterator) {
+        if (orphan.error) continue;
+        if (orphan.value.name === putOrphan.name) {
+          numResults++;
+          expect(orphan.value.tombstone).toBe(true);
+          expect(orphan.value.lastModified).toBe(putNotOrphan.lastModified);
+          expect(orphan.value.channels).toEqual([]);
+        }
+      }
+      expect(numResults).toBe(1);
+    });
+  });
+};

package/tests/src/utils.ts

@@ -4,9 +4,12 @@ import type { GraffitiPutObject, GraffitiStream } from "@graffiti-garden/api";
 export function randomString(): string {
   const array = new Uint8Array(16);
   crypto.getRandomValues(array);
-  return Array.from(array)
+  const str = Array.from(array)
     .map((b) => b.toString(16).padStart(2, "0"))
     .join("");
+
+  // check for unicode support
+  return str + "👩🏽‍❤️‍💋‍👩🏻🫱🏼‍🫲🏿";
 }
 
 export function randomValue() {