jazz-tools 0.19.22 → 0.20.0

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

@@ -10,6 +10,7 @@ import {
   RefsToResolve,
   Resolved,
   Simplify,
+  SubscribeCallback,
   SubscribeListenerOptions,
   unstable_mergeBranchWithResolve,
 } from "../../../internal.js";
@@ -161,6 +162,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 +179,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,
     );
   }
 

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";
@@ -118,12 +118,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 +137,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,
     );
   }
 

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

@@ -9,6 +9,7 @@ import {
   RefsToResolve,
   RefsToResolveStrict,
   Resolved,
+  SubscribeCallback,
   SubscribeListenerOptions,
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
@@ -125,6 +126,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 +143,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,
     );
   }
 

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,
@@ -150,28 +156,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,
     );
   }