jazz-tools 0.19.22 → 0.20.1

package/src/tools/coValues/coList.ts

@@ -549,7 +549,7 @@ export class CoListJazzApi<L extends CoList> extends CoValueJazzApi<L> {
       "private",
     );
 
-    return this.raw.entries().length;
+    return this.raw.length();
   }
 
   /**
@@ -567,7 +567,7 @@ export class CoListJazzApi<L extends CoList> extends CoValueJazzApi<L> {
       this.raw.prepend(item);
     }
 
-    return this.raw.entries().length;
+    return this.raw.length();
   }
 
   /**
@@ -936,40 +936,65 @@ function toRawItems<Item>(
   return rawItems;
 }
 
+function getCoListItemValue(target: CoList, key: string) {
+  const rawValue = target.$jazz.raw.get(Number(key));
+
+  if (rawValue === undefined) {
+    return undefined;
+  }
+
+  const itemDescriptor: Schema = target.$jazz.schema[ItemsSym];
+
+  if (itemDescriptor === "json") {
+    return rawValue;
+  } else if ("encoded" in itemDescriptor) {
+    return itemDescriptor.encoded.decode(rawValue);
+  } else if (isRefEncoded(itemDescriptor)) {
+    if (rawValue === null) {
+      return undefined;
+    }
+
+    return accessChildByKey(target, rawValue as string, key);
+  }
+
+  return undefined;
+}
+
 const CoListProxyHandler: ProxyHandler<CoList> = {
   get(target, key, receiver) {
-    if (typeof key === "string" && !isNaN(+key)) {
-      const itemDescriptor = target.$jazz.schema[ItemsSym] as Schema;
-      const rawValue = target.$jazz.raw.get(Number(key));
-      if (itemDescriptor === "json") {
-        return rawValue;
-      } else if ("encoded" in itemDescriptor) {
-        return rawValue === undefined
-          ? undefined
-          : itemDescriptor.encoded.decode(rawValue);
-      } else if (isRefEncoded(itemDescriptor)) {
-        return rawValue === undefined || rawValue === null
-          ? undefined
-          : accessChildByKey(target, rawValue as string, key);
-      }
-    } else if (key === "length") {
-      return target.$jazz.raw.entries().length;
-    } else {
+    if (typeof key === "symbol") {
       return Reflect.get(target, key, receiver);
     }
+
+    if (!isNaN(+key)) {
+      return getCoListItemValue(target, key);
+    } else if (key === "length") {
+      return target.$jazz.raw.length();
+    }
+
+    return Reflect.get(target, key, receiver);
   },
   set(target, key, value, receiver) {
+    if (typeof key === "symbol") {
+      return Reflect.set(target, key, value, receiver);
+    }
+
     if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
-      (target.constructor as typeof CoList)._schema ||= {};
-      (target.constructor as typeof CoList)._schema[ItemsSym] =
-        value[SchemaInit];
+      const constructor = target.constructor as typeof CoList;
+
+      if (!constructor._schema) {
+        constructor._schema = {};
+      }
+
+      constructor._schema[ItemsSym] = value[SchemaInit];
       return true;
     }
-    if (typeof key === "string" && !isNaN(+key)) {
+
+    if (!isNaN(+key)) {
       throw Error("Cannot update a CoList directly. Use `$jazz.set` instead.");
-    } else {
-      return Reflect.set(target, key, value, receiver);
     }
+
+    return Reflect.set(target, key, value, receiver);
   },
   defineProperty(target, key, descriptor) {
     if (
@@ -978,9 +1003,13 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
       typeof descriptor.value === "object" &&
       SchemaInit in descriptor.value
     ) {
-      (target.constructor as typeof CoList)._schema ||= {};
-      (target.constructor as typeof CoList)._schema[ItemsSym] =
-        descriptor.value[SchemaInit];
+      const constructor = target.constructor as typeof CoList;
+
+      if (!constructor._schema) {
+        constructor._schema = {};
+      }
+
+      constructor._schema[ItemsSym] = descriptor.value[SchemaInit];
       return true;
     } else {
       return Reflect.defineProperty(target, key, descriptor);
@@ -988,7 +1017,7 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
   },
   has(target, key) {
     if (typeof key === "string" && !isNaN(+key)) {
-      return Number(key) < target.$jazz.raw.entries().length;
+      return Number(key) < target.$jazz.raw.length();
     } else {
       return Reflect.has(target, key);
     }
@@ -996,11 +1025,17 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
   ownKeys(target) {
     const keys = Reflect.ownKeys(target);
     // Add numeric indices for all entries in the list
-    const indexKeys = target.$jazz.raw.entries().map((_entry, i) => String(i));
-    keys.push(...indexKeys);
+    const length = target.$jazz.raw.length();
+    for (let i = 0; i < length; i++) {
+      keys.push(String(i));
+    }
     return keys;
   },
   getOwnPropertyDescriptor(target, key) {
+    if (typeof key === "symbol") {
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
+
     if (key === TypeSym) {
       // Make TypeSym non-enumerable so it doesn't show up in Object.keys()
       return {
@@ -1009,23 +1044,24 @@ const CoListProxyHandler: ProxyHandler<CoList> = {
         writable: false,
         value: target[TypeSym],
       };
-    } else if (key in target) {
-      return Reflect.getOwnPropertyDescriptor(target, key);
-    } else if (typeof key === "string" && !isNaN(+key)) {
+    } else if (!isNaN(+key)) {
       const index = Number(key);
-      if (index >= 0 && index < target.$jazz.raw.entries().length) {
+      if (index >= 0 && index < target.$jazz.raw.length()) {
         return {
           enumerable: true,
           configurable: true,
-          writable: true,
+          writable: false,
+          value: getCoListItemValue(target, key),
         };
       }
     } else if (key === "length") {
       return {
         enumerable: false,
         configurable: false,
-        writable: false,
+        writable: true, // Must be writable, otherwise JS complains
+        value: target.$jazz.raw.length(),
       };
     }
+    return Reflect.getOwnPropertyDescriptor(target, key);
   },
 };

package/src/tools/coValues/deepLoading.ts

@@ -46,6 +46,7 @@ export type NotLoaded<T> = {
     id: ID<T>;
     loadingState:
       | typeof CoValueLoadingState.LOADING
+      | typeof CoValueLoadingState.DELETED
       | typeof CoValueLoadingState.UNAVAILABLE
       | typeof CoValueLoadingState.UNAUTHORIZED;
   };
@@ -70,6 +71,7 @@ export type Inaccessible<T> = {
   $jazz: {
     id: ID<T>;
     loadingState:
+      | typeof CoValueLoadingState.DELETED
       | typeof CoValueLoadingState.UNAVAILABLE
       | typeof CoValueLoadingState.UNAUTHORIZED;
   };

package/src/tools/coValues/interfaces.ts

@@ -32,6 +32,7 @@ import {
 } from "../internal.js";
 import type { BranchDefinition } from "../subscribe/types.js";
 import { CoValueHeader } from "cojson";
+import { JazzError } from "../subscribe/JazzError.js";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -177,8 +178,7 @@ export function loadCoValue<
         loadAs: options.loadAs,
         syncResolution: true,
         skipRetry: options.skipRetry,
-        onUnavailable: resolve,
-        onUnauthorized: resolve,
+        onError: resolve,
         unstable_branch: options.unstable_branch,
       },
       (value, unsubscribe) => {
@@ -223,13 +223,22 @@ type SubscribeListener<V extends CoValue, R extends RefsToResolve<V>> = (
   unsubscribe: () => void,
 ) => void;
 
+export type SubscribeCallback<V> = (value: V, unsubscribe: () => void) => void;
+
 export type SubscribeListenerOptions<
   V extends CoValue,
   R extends RefsToResolve<V>,
 > = {
   resolve?: RefsToResolveStrict<V, R>;
   loadAs?: Account | AnonymousJazzAgent;
+  onError?: (value: NotLoaded<V>) => void;
+  /**
+   * @deprecated Use `onError` instead. This callback will be removed in a future version.
+   */
   onUnauthorized?: (value: NotLoaded<V>) => void;
+  /**
+   * @deprecated Use `onError` instead. This callback will be removed in a future version.
+   */
   onUnavailable?: (value: NotLoaded<V>) => void;
   unstable_branch?: BranchDefinition;
 };
@@ -257,6 +266,7 @@ export function parseSubscribeRestArgs<
         options: {
           resolve: args[0].resolve,
           loadAs: args[0].loadAs,
+          onError: args[0].onError,
           onUnauthorized: args[0].onUnauthorized,
           onUnavailable: args[0].onUnavailable,
           unstable_branch: args[0].unstable_branch,
@@ -304,7 +314,14 @@ export function subscribeToCoValue<
   options: {
     resolve?: RefsToResolveStrict<V, R>;
     loadAs: Account | AnonymousJazzAgent;
+    onError?: (value: Inaccessible<V>) => void;
+    /**
+     * @deprecated Use `onError` instead. This callback will be removed in a future version.
+     */
     onUnavailable?: (value: Inaccessible<V>) => void;
+    /**
+     * @deprecated Use `onError` instead. This callback will be removed in a future version.
+     */
     onUnauthorized?: (value: Inaccessible<V>) => void;
     syncResolution?: boolean;
     skipRetry?: boolean;
@@ -342,6 +359,9 @@ export function subscribeToCoValue<
       return;
     }
 
+    options.onError?.(value as Inaccessible<V>);
+
+    // Backward compatibility, going to remove this in the next minor release
     switch (value.$jazz.loadingState) {
       case CoValueLoadingState.UNAVAILABLE:
         options.onUnavailable?.(value as Inaccessible<V>);
@@ -381,7 +401,14 @@ export function subscribeToExistingCoValue<
   options:
     | {
         resolve?: RefsToResolveStrict<V, R>;
+        onError?: (value: NotLoaded<V>) => void;
+        /**
+         * @deprecated Use `onError` instead. This callback will be removed in a future version.
+         */
         onUnavailable?: (value: NotLoaded<V>) => void;
+        /**
+         * @deprecated Use `onError` instead. This callback will be removed in a future version.
+         */
         onUnauthorized?: (value: NotLoaded<V>) => void;
         unstable_branch?: BranchDefinition;
       }
@@ -394,6 +421,7 @@ export function subscribeToExistingCoValue<
     {
       loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
+      onError: options?.onError,
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized,
       unstable_branch: options?.unstable_branch,
@@ -688,23 +716,11 @@ export async function exportCoValue<
     options.unstable_branch,
   );
 
-  const value = await new Promise<Loaded<S, R> | null>((resolve) => {
-    rootNode.setListener(() => {
-      const value = rootNode.getCurrentValue();
-
-      if (value.$isLoaded) {
-        resolve(value as Loaded<S, R>);
-      } else if (
-        value.$jazz.loadingState === CoValueLoadingState.UNAVAILABLE ||
-        value.$jazz.loadingState === CoValueLoadingState.UNAUTHORIZED
-      ) {
-        resolve(null);
-        rootNode.destroy();
-      }
-    });
-  });
-
-  if (!value) {
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
     return null;
   }
 
@@ -857,19 +873,141 @@ export async function unstable_mergeBranchWithResolve<
     options.branch,
   );
 
-  await new Promise<void>((resolve, reject) => {
-    rootNode.setListener((value) => {
-      if (value.type === CoValueLoadingState.UNAVAILABLE) {
-        reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === CoValueLoadingState.UNAUTHORIZED) {
-        reject(new Error("Unable to load the branch. " + value.toString()));
-      } else if (value.type === CoValueLoadingState.LOADED) {
-        resolve();
-      }
-
-      rootNode.destroy();
-    });
-  });
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
+    throw error;
+  }
 
   unstable_mergeBranch(rootNode);
 }
+
+/**
+ * Permanently delete a group of coValues
+ *
+ * This operation is irreversible and will permanently delete the coValues from the local machine and the sync servers.
+ *
+ */
+export async function deleteCoValues<
+  S extends CoValueClassOrSchema,
+  const R extends ResolveQuery<S>,
+>(
+  cls: S,
+  id: ID<CoValue>,
+  options: {
+    resolve?: ResolveQueryStrict<S, R>;
+    loadAs?: Account | AnonymousJazzAgent;
+  } = {},
+) {
+  const loadAs = options.loadAs ?? activeAccountContext.get();
+  const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
+
+  const resolve = options.resolve ?? true;
+
+  const rootNode = new SubscriptionScope<CoValue>(
+    node,
+    resolve as any,
+    id,
+    {
+      ref: coValueClassFromCoValueClassOrSchema(cls),
+      optional: false,
+    },
+    false,
+    false,
+    undefined,
+  );
+
+  try {
+    await rootNode.getPromise();
+    rootNode.destroy();
+  } catch (error) {
+    rootNode.destroy();
+    throw error;
+  }
+
+  // We validate permissions to fail early if one of the loaded coValues is not deletable
+  const errors = validateDeletePermissions(rootNode);
+
+  if (errors.length > 0) {
+    const combined = new JazzError(
+      id,
+      CoValueLoadingState.DELETED,
+      errors.flatMap((e) => e.issues),
+    );
+    throw new Error(combined.toString());
+  }
+
+  const deletedValues = deleteCoValueFromSubscription(rootNode);
+
+  await Promise.allSettled(
+    Array.from(deletedValues, (value) => value.waitForSync()),
+  );
+}
+
+function validateDeletePermissions(
+  rootNode: SubscriptionScope<CoValue>,
+  path: string[] = [],
+  errors: JazzError[] = [],
+): JazzError[] {
+  for (const [key, childNode] of rootNode.childNodes.entries()) {
+    validateDeletePermissions(childNode, [...path, key], errors);
+  }
+
+  if (rootNode.value.type !== CoValueLoadingState.LOADED) {
+    return errors;
+  }
+
+  const core = rootNode.value.value.$jazz.raw.core;
+
+  // Account and Group coValues are not deletable, we skip them to make it easier to delete all coValues owned by an account
+  if (core.isGroupOrAccount()) {
+    return errors;
+  }
+
+  const result = core.validateDeletePermissions();
+  if (!result.ok) {
+    errors.push(
+      new JazzError(core.id, CoValueLoadingState.DELETED, [
+        {
+          code: "deleteError",
+          message: `Jazz Delete Error: ${result.message}`,
+          params: {},
+          path,
+        },
+      ]),
+    );
+  }
+
+  return errors;
+}
+
+function deleteCoValueFromSubscription(
+  rootNode: SubscriptionScope<CoValue>,
+  values = new Set<AvailableCoValueCore>(),
+) {
+  for (const childNode of rootNode.childNodes.values()) {
+    deleteCoValueFromSubscription(childNode, values);
+  }
+
+  if (rootNode.value.type !== CoValueLoadingState.LOADED) {
+    return values;
+  }
+
+  const core = rootNode.value.value.$jazz.raw.core;
+
+  // Account and Group coValues are not deletable, we skip them to make it easier to delete all coValues owned by an account
+  if (core.isGroupOrAccount()) {
+    return values;
+  }
+
+  try {
+    core.deleteCoValue();
+    values.add(core);
+  } catch (error) {
+    console.error("Failed to delete coValue", error);
+  }
+
+  return values;
+}

package/src/tools/exports.ts

@@ -67,6 +67,7 @@ export {
   unstable_loadUnique,
   getUnloadedCoValueWithoutId,
   setDefaultSchemaPermissions,
+  deleteCoValues,
   getJazzErrorType,
 } from "./internal.js";
 

package/src/tools/implementation/ContextManager.ts

@@ -1,5 +1,4 @@
 import { AgentSecret, LocalNode, cojsonInternals } from "cojson";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
 import { KvStore, KvStoreContext } from "../auth/KvStoreContext.js";
@@ -10,6 +9,7 @@ import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 import { createAnonymousJazzContext } from "./createContext.js";
 import { InstanceOfSchema } from "./zodSchema/typeConverters/InstanceOfSchema.js";
 import { SubscriptionCache } from "../subscribe/SubscriptionCache.js";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 export type JazzContextManagerAuthProps = {
   credentials?: AuthCredentials;
@@ -47,7 +47,7 @@ type PlatformSpecificContext<Acc extends Account> =
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
     peers: [],
-    crypto: new PureJSCrypto(),
+    crypto: WasmCrypto.createSync(),
   });
 
   return {

package/src/tools/implementation/createContext.ts

@@ -272,6 +272,10 @@ export async function createJazzContext<
 
   const credentials = options.credentials ?? (await authSecretStorage.get());
 
+  if (options.storage) {
+    options.storage.enableDeletedCoValuesErasure();
+  }
+
   if (credentials && !options.newAccountProps) {
     context = await createJazzContextFromExistingCredentials({
       credentials: {

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

@@ -1,6 +1,5 @@
 import {
   Account,
-  AccountCreationProps,
   BranchDefinition,
   CoMapSchemaDefinition,
   coOptionalDefiner,
@@ -10,12 +9,12 @@ import {
   RefsToResolve,
   Resolved,
   Simplify,
+  SubscribeCallback,
   SubscribeListenerOptions,
   unstable_mergeBranchWithResolve,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
-import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded.js";
 import { z } from "../zodReExport.js";
 import { AnyZodOrCoValueSchema, Loaded, ResolveQuery } from "../zodSchema.js";
 import {
@@ -161,6 +160,15 @@ export class AccountSchema<
     );
   }
 
+  subscribe<
+    const R extends RefsToResolve<
+      Simplify<AccountInstance<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,
+    listener: SubscribeCallback<Resolved<Simplify<AccountInstance<Shape>>, R>>,
+  ): () => void;
   subscribe<
     const R extends RefsToResolve<
       Simplify<AccountInstance<Shape>>
@@ -169,16 +177,30 @@ export class AccountSchema<
   >(
     id: string,
     options: SubscribeListenerOptions<Simplify<AccountInstance<Shape>>, R>,
-    listener: (
-      value: Resolved<Simplify<AccountInstance<Shape>>, R>,
-      unsubscribe: () => void,
-    ) => void,
+    listener: SubscribeCallback<Resolved<Simplify<AccountInstance<Shape>>, R>>,
+  ): () => void;
+  subscribe<const R extends RefsToResolve<Simplify<AccountInstance<Shape>>>>(
+    id: string,
+    optionsOrListener:
+      | SubscribeListenerOptions<Simplify<AccountInstance<Shape>>, R>
+      | SubscribeCallback<Resolved<Simplify<AccountInstance<Shape>>, R>>,
+    maybeListener?: SubscribeCallback<
+      Resolved<Simplify<AccountInstance<Shape>>, R>
+    >,
   ): () => void {
+    if (typeof optionsOrListener === "function") {
+      return this.coValueClass.subscribe(
+        id,
+        withSchemaResolveQuery({}, this.resolveQuery),
+        // @ts-expect-error
+        optionsOrListener,
+      );
+    }
     return this.coValueClass.subscribe(
       id,
       // @ts-expect-error
-      withSchemaResolveQuery(options, this.resolveQuery),
-      listener,
+      withSchemaResolveQuery(optionsOrListener, this.resolveQuery),
+      maybeListener,
     );
   }
 

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

@@ -11,6 +11,7 @@ import {
   Resolved,
   SchemaUnion,
   SchemaUnionConcreteSubclass,
+  SubscribeCallback,
   SubscribeListenerOptions,
   coOptionalDefiner,
 } from "../../../internal.js";
@@ -101,6 +102,20 @@ export class CoDiscriminatedUnionSchema<
     ) as any;
   }
 
+  subscribe<
+    const R extends RefsToResolve<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
+      // @ts-expect-error
+    > = DefaultResolveQuery,
+  >(
+    id: string,
+    listener: SubscribeCallback<
+      Resolved<
+        CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+        R
+      >
+    >,
+  ): () => void;
   subscribe<
     const R extends RefsToResolve<
       CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
@@ -112,19 +127,52 @@ export class CoDiscriminatedUnionSchema<
       CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
       R
     >,
-    listener: (
-      value: Resolved<
+    listener: SubscribeCallback<
+      Resolved<
         CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
         R
-      >,
-      unsubscribe: () => void,
-    ) => void,
+      >
+    >,
+  ): () => void;
+  subscribe<
+    const R extends RefsToResolve<
+      CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion
+    >,
+  >(
+    id: string,
+    optionsOrListener:
+      | SubscribeListenerOptions<
+          CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> &
+            SchemaUnion,
+          R
+        >
+      | SubscribeCallback<
+          Resolved<
+            CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> &
+              SchemaUnion,
+            R
+          >
+        >,
+    maybeListener?: SubscribeCallback<
+      Resolved<
+        CoDiscriminatedUnionInstanceCoValuesMaybeLoaded<Options> & SchemaUnion,
+        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,
     );
   }