jazz-tools 0.19.22 → 0.20.1

package/src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts

@@ -9,9 +9,9 @@ import {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
+  SubscribeCallback,
   SubscribeListenerOptions,
   coOptionalDefiner,
-  parseSubscribeRestArgs,
   unstable_mergeBranchWithResolve,
   withSchemaPermissions,
 } from "../../../internal.js";
@@ -42,11 +42,14 @@ export class CoFeedSchema<
    */
   resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
    * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(
     public element: T,
@@ -118,12 +121,16 @@ export class CoFeedSchema<
     );
   }
 
-  subscribe(
+  subscribe<
+    const R extends RefsToResolve<
+      CoFeedInstanceCoValuesMaybeLoaded<T>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
+  >(
     id: string,
-    listener: (
-      value: Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, true>,
-      unsubscribe: () => void,
-    ) => void,
+    listener: SubscribeCallback<
+      Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>
+    >,
   ): () => void;
   subscribe<
     const R extends RefsToResolve<
@@ -133,18 +140,33 @@ export class CoFeedSchema<
   >(
     id: string,
     options: SubscribeListenerOptions<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
-    listener: (
-      value: Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>,
-      unsubscribe: () => void,
-    ) => void,
+    listener: SubscribeCallback<
+      Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>
+    >,
   ): () => void;
-  subscribe(id: string, ...args: any) {
-    const { options, listener } = parseSubscribeRestArgs(args);
+  subscribe<
+    const R extends RefsToResolve<CoFeedInstanceCoValuesMaybeLoaded<T>>,
+  >(
+    id: string,
+    optionsOrListener:
+      | SubscribeListenerOptions<CoFeedInstanceCoValuesMaybeLoaded<T>, R>
+      | SubscribeCallback<Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>>,
+    maybeListener?: SubscribeCallback<
+      Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>
+    >,
+  ): () => void {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener,
+      );
+    }
     return this.coValueClass.subscribe(
       id,
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
       // @ts-expect-error
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener,
+      maybeListener,
     );
   }
 
@@ -190,7 +212,7 @@ export class CoFeedSchema<
       hydrateCoreCoValueSchema(coreSchema);
     // @ts-expect-error TS cannot infer that the resolveQuery type is valid
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    copy.#permissions = permissions ?? this.#permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -9,6 +9,7 @@ import {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
+  SubscribeCallback,
   SubscribeListenerOptions,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
@@ -43,11 +44,14 @@ export class CoListSchema<
    */
   resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
    * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(
     public element: T,
@@ -125,6 +129,16 @@ export class CoListSchema<
     );
   }
 
+  subscribe<
+    const R extends RefsToResolve<
+      CoListInstanceCoValuesMaybeLoaded<T>
+    > = DefaultResolveQuery,
+  >(
+    id: string,
+    listener: SubscribeCallback<
+      Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>
+    >,
+  ): () => void;
   subscribe<
     const R extends RefsToResolve<
       CoListInstanceCoValuesMaybeLoaded<T>
@@ -132,15 +146,33 @@ export class CoListSchema<
   >(
     id: string,
     options: SubscribeListenerOptions<CoListInstanceCoValuesMaybeLoaded<T>, R>,
-    listener: (
-      value: Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>,
-      unsubscribe: () => void,
-    ) => void,
+    listener: SubscribeCallback<
+      Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>
+    >,
+  ): () => void;
+  subscribe<
+    const R extends RefsToResolve<CoListInstanceCoValuesMaybeLoaded<T>>,
+  >(
+    id: string,
+    optionsOrListener:
+      | SubscribeListenerOptions<CoListInstanceCoValuesMaybeLoaded<T>, R>
+      | SubscribeCallback<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>,
+    maybeListener?: SubscribeCallback<
+      Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>
+    >,
   ): () => void {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener,
+      );
+    }
     return this.coValueClass.subscribe(
       id,
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener,
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+      maybeListener,
     );
   }
 
@@ -233,7 +265,7 @@ export class CoListSchema<
       hydrateCoreCoValueSchema(coreSchema);
     // @ts-expect-error TS cannot infer that the resolveQuery type is valid
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    copy.#permissions = permissions ?? this.#permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts

@@ -11,6 +11,7 @@ import {
   RefsToResolveStrict,
   Resolved,
   Simplify,
+  SubscribeCallback,
   SubscribeListenerOptions,
   coMapDefiner,
   coOptionalDefiner,
@@ -33,6 +34,11 @@ import {
   SchemaPermissions,
 } from "../schemaPermissions.js";
 
+type CoMapSchemaInstance<Shape extends z.core.$ZodLooseShape> = Simplify<
+  CoMapInstanceCoValuesMaybeLoaded<Shape>
+> &
+  CoMap;
+
 export class CoMapSchema<
   Shape extends z.core.$ZodLooseShape,
   CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
@@ -53,11 +59,14 @@ export class CoMapSchema<
    */
   resolveQuery: DefaultResolveQuery = true as DefaultResolveQuery;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
    * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(
     coreSchema: CoreCoMapSchema<Shape, CatchAll>,
@@ -150,28 +159,43 @@ export class CoMapSchema<
 
   subscribe<
     const R extends RefsToResolve<
-      Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap
+      CoMapSchemaInstance<Shape>
       // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
     > = DefaultResolveQuery,
   >(
     id: string,
-    options: SubscribeListenerOptions<
-      Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap,
-      R
-    >,
-    listener: (
-      value: Resolved<
-        Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap,
-        R
-      >,
-      unsubscribe: () => void,
-    ) => void,
+    listener: SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>,
+  ): () => void;
+  subscribe<
+    const R extends RefsToResolve<
+      CoMapSchemaInstance<Shape>
+      // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
+    > = DefaultResolveQuery,
+  >(
+    id: string,
+    options: SubscribeListenerOptions<CoMapSchemaInstance<Shape>, R>,
+    listener: SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>,
+  ): () => void;
+  subscribe<const R extends RefsToResolve<CoMapSchemaInstance<Shape>>>(
+    id: string,
+    optionsOrListener:
+      | SubscribeListenerOptions<CoMapSchemaInstance<Shape>, R>
+      | SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>,
+    maybeListener?: SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>,
   ): () => void {
+    if (typeof optionsOrListener === "function") {
+      // @ts-expect-error
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        optionsOrListener,
+      );
+    }
     // @ts-expect-error
     return this.coValueClass.subscribe(
       id,
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener,
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      maybeListener,
     );
   }
 
@@ -385,7 +409,7 @@ export class CoMapSchema<
     copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
     // @ts-expect-error TS cannot infer that the resolveQuery type is valid
     copy.resolveQuery = resolveQuery ?? this.resolveQuery;
-    copy.permissions = permissions ?? this.permissions;
+    copy.#permissions = permissions ?? this.#permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/CoVectorSchema.ts

@@ -36,10 +36,14 @@ export class CoVectorSchema implements CoreCoVectorSchema {
   readonly builtin = "CoVector" as const;
   readonly resolveQuery = true as const;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
+   * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(
     public dimensions: number,
@@ -119,7 +123,7 @@ export class CoVectorSchema implements CoreCoVectorSchema {
    */
   withPermissions(permissions: SchemaPermissions): CoVectorSchema {
     const copy = new CoVectorSchema(this.dimensions, this.coValueClass);
-    copy.permissions = permissions;
+    copy.#permissions = permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/FileStreamSchema.ts

@@ -32,10 +32,14 @@ export class FileStreamSchema implements CoreFileStreamSchema {
   readonly builtin = "FileStream" as const;
   readonly resolveQuery = true as const;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
+   * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(private coValueClass: typeof FileStream) {}
 
@@ -159,7 +163,7 @@ export class FileStreamSchema implements CoreFileStreamSchema {
     permissions: Omit<SchemaPermissions, "onInlineCreate">,
   ): FileStreamSchema {
     const copy = new FileStreamSchema(this.coValueClass);
-    copy.permissions = permissions;
+    copy.#permissions = permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts

@@ -34,11 +34,14 @@ export class PlainTextSchema implements CorePlainTextSchema {
   readonly builtin = "CoPlainText" as const;
   readonly resolveQuery = true as const;
 
+  #permissions: SchemaPermissions | null = null;
   /**
    * Permissions to be used when creating or composing CoValues
    * @internal
    */
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(private coValueClass: typeof CoPlainText) {}
 
@@ -111,7 +114,7 @@ export class PlainTextSchema implements CorePlainTextSchema {
    */
   withPermissions(permissions: SchemaPermissions): PlainTextSchema {
     const copy = new PlainTextSchema(this.coValueClass);
-    copy.permissions = permissions;
+    copy.#permissions = permissions;
     return copy;
   }
 }

package/src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts

@@ -33,7 +33,14 @@ export class RichTextSchema implements CoreRichTextSchema {
   readonly builtin = "CoRichText" as const;
   readonly resolveQuery = true as const;
 
-  permissions: SchemaPermissions = DEFAULT_SCHEMA_PERMISSIONS;
+  #permissions: SchemaPermissions | null = null;
+  /**
+   * Permissions to be used when creating or composing CoValues
+   * @internal
+   */
+  get permissions(): SchemaPermissions {
+    return this.#permissions ?? DEFAULT_SCHEMA_PERMISSIONS;
+  }
 
   constructor(private coValueClass: typeof CoRichText) {}
 
@@ -102,7 +109,7 @@ export class RichTextSchema implements CoreRichTextSchema {
    */
   withPermissions(permissions: SchemaPermissions): RichTextSchema {
     const copy = new RichTextSchema(this.coValueClass);
-    copy.permissions = permissions;
+    copy.#permissions = permissions;
     return copy;
   }
 }

package/src/tools/ssr/ssr.ts

@@ -1,10 +1,10 @@
 import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { createAnonymousJazzContext } from "jazz-tools";
 
 export function createSSRJazzAgent(opts: { peer: string }) {
   const ssrNode = createAnonymousJazzContext({
-    crypto: new PureJSCrypto(),
+    crypto: WasmCrypto.createSync(),
     peers: [],
   });
 

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -223,6 +223,7 @@ export class CoValueCoreSubscription {
  */
 function isCompletelyDownloaded(value: RawCoValue) {
   return (
+    value.core.isDeleted ||
     value.core.verified?.header.meta?.type === "binary" ||
     value.core.isCompletelyDownloaded()
   );

package/src/tools/subscribe/JazzError.ts

@@ -6,6 +6,7 @@ export class JazzError {
     public id: ID<CoValue> | undefined,
     public type:
       | typeof CoValueLoadingState.UNAVAILABLE
+      | typeof CoValueLoadingState.DELETED
       | typeof CoValueLoadingState.UNAUTHORIZED,
     public issues: JazzErrorIssue[],
   ) {}
@@ -49,8 +50,10 @@ export class JazzError {
 export type JazzErrorIssue = {
   code:
     | typeof CoValueLoadingState.UNAVAILABLE
+    | typeof CoValueLoadingState.DELETED
     | typeof CoValueLoadingState.UNAUTHORIZED
-    | "validationError";
+    | "validationError"
+    | "deleteError";
   message: string;
   params: Record<string, any>;
   path: string[];

package/src/tools/subscribe/SubscriptionScope.ts

@@ -171,6 +171,25 @@ export class SubscriptionScope<D extends CoValue> {
       return;
     }
 
+    if (update.core.isDeleted) {
+      if (this.value.type !== CoValueLoadingState.DELETED) {
+        const error = new JazzError(this.id, CoValueLoadingState.DELETED, [
+          {
+            code: CoValueLoadingState.DELETED,
+            message: `Jazz Deleted Error: ${this.id} has been deleted`,
+            params: {
+              id: this.id,
+            },
+            path: [],
+          },
+        ]);
+
+        this.updateValue(error);
+        this.triggerUpdate();
+      }
+      return;
+    }
+
     if (!hasAccessToCoValue(update)) {
       if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         const message = `Jazz Authorization Error: The current user (${this.node.getCurrentAgent().id}) is not authorized to access ${this.id}`;
@@ -279,6 +298,7 @@ export class SubscriptionScope<D extends CoValue> {
 
     if (
       value.type === CoValueLoadingState.UNAVAILABLE ||
+      value.type === CoValueLoadingState.DELETED ||
       value.type === CoValueLoadingState.UNAUTHORIZED
     ) {
       this.childErrors.set(id, value.prependPath(key ?? id));
@@ -414,6 +434,7 @@ export class SubscriptionScope<D extends CoValue> {
 
     if (
       rawValue === CoValueLoadingState.UNAUTHORIZED ||
+      rawValue === CoValueLoadingState.DELETED ||
       rawValue === CoValueLoadingState.UNAVAILABLE ||
       rawValue === CoValueLoadingState.LOADING
     ) {
@@ -427,6 +448,7 @@ export class SubscriptionScope<D extends CoValue> {
   private getCurrentRawValue(): D | NotLoadedCoValueState {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
+      this.value.type === CoValueLoadingState.DELETED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
     ) {
       return this.value.type;
@@ -481,6 +503,7 @@ export class SubscriptionScope<D extends CoValue> {
   private getError() {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
+      this.value.type === CoValueLoadingState.DELETED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
     ) {
       return this.value;

package/src/tools/subscribe/types.ts

@@ -16,6 +16,10 @@ export const CoValueLoadingState = {
    * The coValue is being loaded.
    */
   LOADING: "loading",
+  /**
+   * The coValue existed but has been deleted (tombstoned).
+   */
+  DELETED: "deleted",
   /**
    * The coValue was loaded but the account is not authorized to access it.
    */
@@ -31,6 +35,7 @@ export type CoValueLoadingState =
 
 export type CoValueErrorState =
   | typeof CoValueLoadingState.UNAVAILABLE
+  | typeof CoValueLoadingState.DELETED
   | typeof CoValueLoadingState.UNAUTHORIZED;
 
 export type NotLoadedCoValueState =

package/src/tools/testing.ts

@@ -1,6 +1,5 @@
 import { LocalNode } from "cojson";
 import { cojsonInternals } from "cojson";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 import {
   Account,
   AccountClass,
@@ -18,6 +17,7 @@ import {
   createJazzContext,
   MockSessionProvider,
 } from "./internal.js";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 const randomSessionProvider = new MockSessionProvider();
 
@@ -28,11 +28,11 @@ const syncServer: { current: LocalNode | null; asyncPeers: boolean } = {
   asyncPeers: false,
 };
 
-export class TestJSCrypto extends PureJSCrypto {
+export class TestJSCrypto extends WasmCrypto {
   static async create() {
     if ("navigator" in globalThis && navigator.userAgent?.includes("jsdom")) {
       // Mocking crypto seal & encrypt to make it work with JSDom. Getting "Error: Uint8Array expected" there
-      const crypto = new PureJSCrypto();
+      const crypto = await WasmCrypto.create();
 
       crypto.seal = (options) =>
         `sealed_U${cojsonInternals.stableStringify(options.message)}` as any;
@@ -47,7 +47,7 @@ export class TestJSCrypto extends PureJSCrypto {
     }
 
     // For non-jsdom environments, we use the real crypto
-    return new PureJSCrypto();
+    return await WasmCrypto.create();
   }
 }
 
@@ -188,7 +188,7 @@ export function runWithoutActiveAccount<Result>(
 
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
-    crypto: await PureJSCrypto.create(),
+    crypto: await WasmCrypto.create(),
     peers: [],
   });
 

package/src/tools/tests/PassphraseAuth.test.ts

@@ -1,7 +1,6 @@
 // @vitest-environment happy-dom
 
 import { AgentSecret } from "cojson";
-import { PureJSCrypto } from "cojson/crypto/PureJSCrypto";
 import { assert, beforeEach, describe, expect, it, vi } from "vitest";
 import { PassphraseAuth } from "../auth/PassphraseAuth";
 import {
@@ -17,6 +16,7 @@ import {
   setupJazzTestSync,
 } from "../testing";
 import { testWordlist } from "./fixtures";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 // Initialize KV store for tests
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
@@ -26,7 +26,7 @@ beforeEach(async () => {
 });
 
 describe("PassphraseAuth", () => {
-  let crypto: PureJSCrypto;
+  let crypto: WasmCrypto;
   let mockAuthenticate: any;
   let mockRegister: any;
   let authSecretStorage: AuthSecretStorage;
@@ -38,7 +38,7 @@ describe("PassphraseAuth", () => {
     KvStoreContext.getInstance().getStorage().clearAll();
 
     // Set up crypto and mocks
-    crypto = await PureJSCrypto.create();
+    crypto = await WasmCrypto.create();
     mockAuthenticate = vi.fn();
     mockRegister = vi.fn();
     authSecretStorage = new AuthSecretStorage();
@@ -201,7 +201,7 @@ describe("PassphraseAuth", () => {
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
 
 describe("PassphraseAuth with TestJazzContextManager", () => {
-  let crypto: PureJSCrypto;
+  let crypto: WasmCrypto;
   let contextManager: TestJazzContextManager<any>;
   let authSecretStorage: AuthSecretStorage;
   let passphraseAuth: PassphraseAuth;
@@ -215,7 +215,7 @@ describe("PassphraseAuth with TestJazzContextManager", () => {
     });
 
     // Set up crypto and context manager
-    crypto = await PureJSCrypto.create();
+    crypto = await WasmCrypto.create();
     contextManager = TestJazzContextManager.fromAccountOrGuest(account);
     authSecretStorage = contextManager.getAuthSecretStorage();