@dittolive/ditto 4.7.4 → 4.7.5-rc.2

package/react-native/src/sources/store.ts

@@ -1,630 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-import * as Environment from './@environment'
-
-import * as FFI from './ffi'
-import { Bridge } from './bridge'
-
-import { desugarJSObject } from './augment'
-import { Attachment, validateAttachmentMetadata } from './attachment'
-import { AttachmentFetcher } from './attachment-fetcher'
-import { AttachmentToken } from './attachment-token'
-import { CBOR } from './cbor'
-import { Collection } from './collection'
-import { StoreObserver } from './store-observer'
-import { DocumentID } from './document-id'
-import { DittoError, mapFFIErrors, mapFFIErrorsAsync } from './error'
-import { performAsyncToWorkaroundNonAsyncFFIAPI, step, validateQuery } from './internal'
-import { Logger } from './logger'
-import { PendingCollectionsOperation } from './pending-collections-operation'
-import { QueryResult } from './query-result'
-import { WriteTransaction } from './write-transaction'
-
-import type { TypedAttachmentToken } from './attachment-token'
-import type { StoreObservationHandlerWithSignalNext, StoreObservationHandler } from './store-observer'
-import type { Ditto } from './ditto'
-import type { Document } from './document'
-import type { DQLQueryArguments } from './essentials'
-import type { QueryResultItem } from './query-result-item'
-import type { WriteTransactionResult } from './write-transaction'
-import type { AttachmentMetadata } from './attachment'
-import type { AttachmentFetchEvent } from './attachment-fetch-event'
-
-/**
- * The entrypoint for all actions that relate to data stored by Ditto. Provides
- * access to collections, a write transaction API, and a query hash API.
- *
- * You don't create one directly but can access it from a particular
- * {@link Ditto} instance via its {@link Ditto.store | store} property.
- */
-export class Store {
-  /** The {@link Ditto} instance this store belongs to. */
-  readonly ditto: Ditto
-
-  /**
-   * All currently active store observers.
-   *
-   * **Note:** Manage store observers using
-   * {@link registerObserver | registerObserver()} to register a new store
-   * observer and {@link StoreObserver.cancel | StoreObserver.cancel()} to
-   * remove an existing store observer.
-   */
-  readonly observers: Readonly<Array<StoreObserver>> = Object.freeze([])
-
-  /**
-   * All currently active attachment fetchers.
-   *
-   * **Note:** Manage attachment fetchers using
-   * {@link fetchAttachment | fetchAttachment()} to start a new attachment fetch
-   * and {@link AttachmentFetcher.stop | AttachmentFetcher.stop()} to cancel
-   * an existing attachment fetch.
-   */
-  readonly attachmentFetchers: Readonly<Array<AttachmentFetcher>> = Object.freeze([])
-
-  /**
-   * Register a handler to be called whenever a query's results change in the
-   * local store.
-   *
-   * Convenience method, same as
-   * {@link registerObserverWithSignalNext | registerObserverWithSignalNext()},
-   * except that here, the next invocation of the observation handler is
-   * triggered automatically instead of having to call the passed in
-   * `signalNext` function.
-   *
-   * @param query a string containing a valid query expressed in DQL.
-   * @param observationHandler a function that is called whenever the query's results
-   * change. The function is passed a {@link QueryResult} containing a
-   * {@link QueryResultItem} for each match.
-   * @param queryArguments an object of values keyed by the placeholder name
-   * without the leading `:`. Example: `{ "name": "Joanna" }` for a query like
-   * `SELECT * FROM people WHERE name = :name`.
-   * @returns a {@link StoreObserver} that can be used to cancel the
-   * observation.
-   * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
-   * string or not valid DQL.
-   * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
-   * argument is invalid (e.g. contains unsupported types).
-   * @throws {@link DittoError} `query/unsupported`: if the query is not a
-   * `SELECT` query.
-   * @throws {@link DittoError} may throw other errors.
-   */
-  registerObserver(query: string, observationHandler: StoreObservationHandler, queryArguments?: DQLQueryArguments): StoreObserver {
-    const changeHandlerWithSignalNext: StoreObservationHandlerWithSignalNext = (queryResult: QueryResult, signalNext: () => void) => {
-      try {
-        observationHandler(queryResult)
-      } finally {
-        signalNext()
-      }
-    }
-    return this.registerObserverWithSignalNext(query, changeHandlerWithSignalNext, queryArguments)
-  }
-
-  /**
-   * Registers and returns a store observer for a query, configuring Ditto to
-   * trigger the passed in observation handler whenever documents in the local
-   * store change such that the result of the matching query changes. The passed
-   * in query must be a `SELECT` query.
-   *
-   * Here, a function is passed as an additional argument to the observation
-   * handler. Call this function as soon as the observation handler is ready to
-   * process the the next change event. This allows the observation handler to
-   * control how frequently it is called. See
-   * {@link registerObserver | registerObserver()} for a convenience method that
-   * automatically signals the next invocation.
-   *
-   * The first invocation of `observationHandler` will always happen after this
-   * method has returned.
-   *
-   * @param query a string containing a valid query expressed in DQL.
-   * @param observationHandler an observation handler function that is called
-   * whenever the query's results change. The function is passed a
-   * {@link QueryResult} containing a {@link QueryResultItem} for each match.
-   * @param queryArguments an object of values keyed by the placeholder name
-   * without the leading `:`. Example: `{ "name": "Joanna" }` for a query like
-   * `SELECT * FROM people WHERE name = :name`.
-   * @returns a {@link StoreObserver} that can be used to cancel the
-   * observation.
-   * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
-   * string or not valid DQL.
-   * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
-   * argument is invalid (e.g. contains unsupported types).
-   * @throws {@link DittoError} `query/unsupported`: if the query is not a
-   * `SELECT` query.
-   * @throws {@link DittoError} may throw other errors.
-   */
-  registerObserverWithSignalNext(query: string, observationHandler: StoreObservationHandlerWithSignalNext, queryArguments?: DQLQueryArguments): StoreObserver {
-    if (typeof query !== 'string') {
-      throw new DittoError('query/invalid', `Expected parameter 'query' to be of type 'string', found: ${typeof query}`)
-    }
-
-    const storeObserver = new StoreObserver(this.ditto, query, queryArguments ?? null, observationHandler)
-
-    // @ts-expect-error modifying readonly property
-    this.observers = Object.freeze([...this.observers, storeObserver])
-
-    // We have two requirements for this step: (1) we want to be able to wait
-    // for the call to FFI to finish while closing ditto and (2) we want to
-    // return from this function without waiting for the call to FFI to finish.
-    // If we would await the call here, we could end up in a situation where
-    // the first callback to the event handler is emitted before we return from
-    // the method call that started the observer.
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    void this.ditto.deferCloseAsync(async () => {
-      return new Promise<void>((resolve) => {
-        void step(async () => {
-          try {
-            // prettier-ignore
-            await mapFFIErrorsAsync(
-              async () => await FFI.liveQueryStart(dittoHandle.deref(), storeObserver.liveQueryID)
-            )
-          } catch (error: any) {
-            // As this closure executes after the surrounding method has returned we don't throw
-            // the error here. Instead we log the error.
-            Logger.error(`Failed to start live query: ${error.message}`)
-          }
-          resolve()
-        })
-      })
-    })
-
-    return storeObserver
-  }
-
-  /**
-   * Returns the collection for the given name. If the collection doesn't
-   * exist yet, it will be created automatically as soon as the first
-   * entry is inserted.
-   * A collection name is valid if:
-   * * its length is less than 100
-   * * it is not empty
-   * * it does not contain the char '\0'
-   * * it does not begin with "$TS_"
-   */
-  collection(name: string): Collection {
-    return new Collection(name, this)
-  }
-
-  /**
-   * Returns an object that lets you fetch or observe the collections in the
-   * store.
-   *
-   * @return A {@link PendingCollectionsOperation} object that you can use to
-   * fetch or observe the collections in the store
-   */
-  collections(): PendingCollectionsOperation {
-    return new PendingCollectionsOperation(this)
-  }
-
-  /**
-   * Returns the names of all available collections in the store of the
-   * related {@link Ditto} instance.
-   */
-  collectionNames(): Promise<string[]> {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    return ditto.deferClose(() => {
-      return mapFFIErrors(() => FFI.dittoGetCollectionNames(dittoHandle.deref()))
-    })
-  }
-
-  /**
-   * Executes a DQL query and returns matching items as a query result.
-   *
-   * @param query a string containing a valid query expressed in DQL.
-   * @param queryArguments an object of values keyed by the placeholder name
-   * without the leading `:`. Example: `{ "name": "John" }` for a query like
-   * `SELECT * FROM people WHERE name = :name`.
-   * @returns a promise for a {@link QueryResult} containing a
-   * {@link QueryResultItem} for each match.
-   * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
-   * string or not valid DQL.
-   * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
-   * argument is invalid (e.g. contains unsupported types).
-   * @throws {@link DittoError} may throw other errors.
-   */
-  async execute(query: string, queryArguments?: DQLQueryArguments): Promise<QueryResult> {
-    if (typeof query !== 'string') {
-      throw new DittoError('query/invalid', `Expected parameter 'query' to be of type 'string', found: ${typeof query}`)
-    }
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferCloseAsync(async () => {
-      // A one-off query execution uses a transaction internally but a
-      // transaction API is not implemented yet.
-      const writeTransaction = null
-
-      let queryArgumentsCBOR: Uint8Array | null = null
-      if (queryArguments != null) {
-        try {
-          const queryArgumentsJSON = desugarJSObject(queryArguments)
-          queryArgumentsCBOR = CBOR.encode(queryArgumentsJSON)
-        } catch (error: any) {
-          throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`)
-        }
-      }
-
-      // prettier-ignore
-      const queryResultPointer: FFI.Pointer<FFI.FFIQueryResult> = await mapFFIErrorsAsync(
-        async () => await performAsyncToWorkaroundNonAsyncFFIAPI(
-          () => FFI.tryExecStatement(dittoHandle.deref(), writeTransaction, query, queryArgumentsCBOR)
-        )
-      )
-
-      return Bridge.queryResult.bridge(queryResultPointer, () => new QueryResult(queryResultPointer))
-    })
-  }
-
-  /**
-   * Initiate a write transaction in a callback.
-   *
-   * Allows you to group multiple operations together that affect multiple documents, potentially across multiple collections.
-   *
-   * @param callback is given access to a {@link WriteTransaction | write transaction object} that can be used to perform operations on the store.
-   * @returns a list of `WriteTransactionResult`s. There is a result for each operation performed as part of the write transaction.
-   */
-  async write(callback: (transaction: WriteTransaction) => Promise<void>): Promise<WriteTransactionResult[]> {
-    // Run caller's callback, rolling back if needed.
-    return this.ditto.deferCloseAsync(async () => {
-      const transaction = await WriteTransaction.init(this.ditto)
-
-      try {
-        await callback(transaction)
-      } catch (error: any) {
-        await transaction.rollback()
-        Logger.warning(`Transaction rolled back due to an error: ${error?.message}`)
-        throw error
-      }
-      await transaction.commit()
-
-      return transaction.results
-    })
-  }
-
-  /**
-   * Creates a new {@link Attachment} object, which can then be inserted into a
-   * document.
-   *
-   * The file residing at the provided path will be copied into
-   * Ditto's store.
-   * The {@link Attachment} object that is returned is what you can then use to
-   * insert an attachment into a document.
-   *
-   * **Note**: Relative paths for file sources are resolved from the current working
-   * directory.
-   *
-   * You can provide metadata about the attachment, which will be replicated to
-   * other peers alongside the file attachment.
-   *
-   * @example Inserting an attachment into a document
-   * ```JavaScript
-   * // Copy the file into Ditto's store and create an attachment object.
-   * const attachment = await ditto.store.newAttachment(
-   *   '/path/to/my/file.pdf',
-   *   { my_field: 'optional metadata' }
-   * )
-   *
-   * // Prepare the document value including the attachment.
-   * const doc = {
-   *   _id: '123',
-   *   my_attachment: attachment,
-   *   other: 'some-string'
-   * }
-   *
-   * // Insert the document into the collection, marking `my_attachment` as an
-   * // attachment field.
-   * await ditto.store.execute(
-   *   `INSERT INTO my_collection (my_attachment ATTACHMENT)
-   *    VALUES (:doc)`,
-   *   { doc }
-   * )
-   * ```
-   *
-   * @param pathOrData The path to the file that you want to create an
-   * attachment with or the raw data.
-   *
-   * @param metadata Optional metadata that will be stored alongside the
-   * attachment.
-   *
-   * @returns A promise for an {@link Attachment} object that can be used to
-   * insert the attachment into a document.
-   *
-   * @throws {@link DittoError} `store/attachment-file-permission-denied` when
-   * the file at the given path could not be read because of insufficient
-   * permissions.
-   *
-   * @throws {@link DittoError} `store/attachment-file-not-found` when the file
-   * at the given path could not be found.
-   *
-   * @throws {@link DittoError} `store/failed-to-create-attachment` when the
-   * attachment could not be created for other reasons.
-   *
-   * @throws {@link DittoError} `sdk/unsupported` when trying to create an
-   * attachment from a file path in a web browser.
-   */
-  async newAttachment(pathOrData: string | Uint8Array, metadata?: AttachmentMetadata): Promise<Attachment> {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-
-    if (metadata != null) {
-      validateAttachmentMetadata(metadata)
-    }
-
-    return ditto.deferCloseAsync(async () => {
-      //
-      // Create inputs for the attachment token from either a file path or raw data.
-      //
-      const { id, len, handle } = await (async () => {
-        if (typeof pathOrData === 'string') {
-          if (Environment.isWebBuild) {
-            throw new DittoError('sdk/unsupported', `Can't create attachment from file when running in the browser. Please pass the raw data (as a Uint8Array) instead.`)
-          }
-
-          if (Environment.isNodeBuild || Environment.isReactNativeBuild) {
-            return mapFFIErrors(() => FFI.dittoNewAttachmentFromFile(dittoHandle.deref(), pathOrData as string, 'Copy'), {
-              1: ['store/failed-to-create-attachment'],
-              2: ['store/attachment-file-not-found'],
-              3: ['store/attachment-file-permission-denied'],
-            })
-          }
-        }
-
-        if (pathOrData instanceof Uint8Array) {
-          return mapFFIErrorsAsync(async () => await FFI.dittoNewAttachmentFromBytes(dittoHandle.deref(), pathOrData), {
-            1: ['store/failed-to-create-attachment'],
-          })
-        }
-
-        throw new Error(`Can't create new attachment, only file path as string or raw data as Uint8Array are supported, but got: ${typeof pathOrData}, ${pathOrData}`)
-      })()
-
-      const attachmentTokenJSON: TypedAttachmentToken = { _id: id, _len: len, _meta: { ...metadata }, [FFI.DittoCRDTTypeKey]: FFI.DittoCRDTType.attachment }
-
-      const attachmentToken = new AttachmentToken(attachmentTokenJSON)
-      const attachment = new Attachment(ditto, attachmentToken)
-
-      return Bridge.attachment.bridge(handle, () => attachment)
-    })
-  }
-
-  /**
-   * Trigger an attachment to be downloaded locally to the device and observe
-   * its progress as it does so.
-   *
-   * When you encounter a document that contains an attachment, the attachment
-   * will not automatically be downloaded along with the document. You trigger
-   * an attachment to be downloaded locally to a device by calling this method.
-   * It will report events relating to the attachment fetch attempt as it tries
-   * to download it. The `eventHandler` block may be called multiple times with
-   * progress events. It will then be called with either a  `Completed` event or
-   * a `Deleted` event. If downloading the attachment succeeds then the
-   * `Completed` event that the `eventHandler` will be called with will hold a
-   * reference to the downloaded attachment.
-   *
-   * The attachment to be fetched is identified by the `token` parameter. This
-   * may either be an {@link AttachmentToken} instance received from a
-   * {@link Document} or a plain object as is returned in a
-   * {@link QueryResultItem} (see example below).
-   *
-   * @example Fetch an attachment from a document in the store
-   *
-   * ```js
-   * // Fetch the attachment token from a document in the store
-   * const result = await ditto.store.execute(`
-   *   SELECT *
-   *   FROM COLLECTION cars (my_attachment ATTACHMENT)
-   *   WHERE my_attachment.id = :id`,
-   *   { id: "123" }
-   * )
-   * const attachmentToken = result.items[0].my_attachment
-   *
-   * // Trigger the attachment to be downloaded
-   * const attachment = await ditto.store.fetchAttachment(attachmentToken)
-   *
-   * // Extract the attachment data
-   * const attachmentData = await attachment.data()
-   * ```
-   *
-   * @param token The {@link AttachmentToken} instance or plain object
-   * representation of the attachment to be downloaded.
-   *
-   * @param eventHandler An optional callback that will be called when there is
-   * an update to the status of the attachment fetch attempt.
-   *
-   * @returns An {@link AttachmentFetcher} object, which is `PromiseLike` so
-   * that you can `await` it to wait for the attachment to be downloaded. It
-   * also provides a {@link AttachmentFetcher.stop | stop()} method to cancel
-   * the fetch attempt.
-   *
-   * @throws {@link DittoError} `store/attachment-not-found` when the attachment
-   * could not be found.
-   *
-   * @throws {@link DittoError} `store/attachment-token-invalid` when the given
-   * attachment token is invalid.
-   *
-   * @throws {@link DittoError} `store/failed-to-fetch-attachment` when fetching
-   * the attachment fails for other reasons.
-   */
-  fetchAttachment(token: AttachmentToken | { id: string; len: number | BigInt; metadata: AttachmentMetadata }, eventHandler?: (event: AttachmentFetchEvent) => void): AttachmentFetcher {
-    if (token == null) {
-      throw new Error("Missing required parameter 'token'")
-    }
-
-    let attachmentToken: AttachmentToken
-    if (token instanceof AttachmentToken) {
-      attachmentToken = token
-    } else {
-      attachmentToken = new AttachmentToken(token)
-    }
-
-    const ditto = this.ditto
-    return ditto.deferClose(() => {
-      const attachmentFetcher = new AttachmentFetcher(ditto, attachmentToken, null, eventHandler)
-
-      // @ts-expect-error modifying readonly property
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      this.attachmentFetchers = Object.freeze([...this.attachmentFetchers, attachmentFetcher])
-
-      return attachmentFetcher
-    })
-  }
-
-  // ----------------------------------------------------------- Internal ------
-
-  /** @internal */
-  constructor(ditto: Ditto) {
-    this.ditto = ditto
-  }
-
-  /**
-   * Registers a URL to be called whenever the given `SELECT` query observes
-   * changes.
-   *
-   * No validation is performed on the URL, so it is up to the caller to ensure
-   * that the URL is valid and can be reached.
-   *
-   * @internal
-   * @returns a promise for a document id that acts as a webhook id
-   * @throws {@link DittoError} `store/query-invalid`: if the query is invalid
-   * @throws {@link DittoError} `store/query-arguments-invalid`: if the query arguments
-   * are invalid
-   * @throws {@link DittoError} `store/query-unsupported`: if the query is not a
-   * `SELECT` query
-   * @throws {@link DittoError} for any other error that occurs during query execution
-   */
-  async registerObserverWebhook(query: string, url: string, queryArguments?: DQLQueryArguments): Promise<DocumentID> {
-    let queryArgumentsCBOR: Uint8Array | null = null
-    if (queryArguments != null) {
-      try {
-        const queryArgumentsJSON = desugarJSObject(queryArguments)
-        queryArgumentsCBOR = CBOR.encode(queryArgumentsJSON)
-      } catch (error: any) {
-        throw new DittoError('query/arguments-invalid', `Invalid query arguments: ${error.message}`)
-      }
-    }
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    // prettier-ignore
-    return this.ditto.deferCloseAsync(async () => {
-      const webhookIDCBOR = await mapFFIErrorsAsync(
-        async () => await FFI.tryRegisterStoreObserverWebhook(dittoHandle.deref(), query, queryArgumentsCBOR, url),
-      )
-      return new DocumentID(webhookIDCBOR, true)
-    })
-  }
-
-  /**
-   * Unregister a store observer. No-op if the change observer has already
-   * been removed.
-   *
-   * This must only be called by the store observer itself.
-   *
-   * @param changeObserver the store observer to unregister
-   * @returns true if the store observer was found and removed, false otherwise
-   * @throws {@link DittoError} `internal`: if the store observer does not belong to
-   * this store
-   * @throws {@link DittoError} `internal`: if the store observer has not been
-   * cancelled yet
-   * @throws {@link DittoError} `internal`: for any other error that occurs while
-   * trying to unregister the store observer
-   * @internal
-   */
-  unregisterObserver(storeObserver: StoreObserver): boolean {
-    if (storeObserver.ditto !== this.ditto) {
-      throw new DittoError('internal', `Internal inconsistency, can't remove store observer that does not belong to this store`)
-    }
-
-    if (!storeObserver.isCancelled) {
-      throw new DittoError('internal', "Internal inconsistency, can't remove store observer that has not been cancelled")
-    }
-
-    // Return early if the store observer has already been removed.
-    const indexToDelete = this.observers.findIndex((observer) => observer === storeObserver)
-    if (indexToDelete === -1) {
-      return false
-    }
-
-    const newObservers = [...this.observers]
-    newObservers.splice(indexToDelete, 1)
-    // @ts-expect-error modifying readonly property
-    this.observers = Object.freeze(newObservers)
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      // prettier-ignore
-      mapFFIErrors(
-        () => FFI.liveQueryStop(dittoHandle.deref(), storeObserver.liveQueryID)
-      )
-    })
-    return true
-  }
-
-  /**
-   * Remove an attachment fetcher that is owned by this store. No-op if the
-   * attachment fetcher has already been removed.
-   *
-   * This must only be called by the attachment fetcher itself.
-   *
-   * @param attachmentFetcher the attachment fetcher to finalize
-   * @returns true if the attachment fetcher was found and removed, false
-   * otherwise
-   * @internal
-   */
-  removeAttachmentFetcher(attachmentFetcher: AttachmentFetcher): boolean {
-    if (attachmentFetcher.ditto !== this.ditto) {
-      throw new DittoError('internal', `Internal inconsistency, can't finalize attachment fetcher that does not belong to this store`)
-    }
-
-    if (attachmentFetcher.manager != null) {
-      throw new DittoError('internal', "Internal inconsistency, store can't remove attachment fetcher that is owned by the attachment fetcher manager")
-    }
-
-    if (!attachmentFetcher.isStopped) {
-      throw new DittoError('internal', "Internal inconsistency, can't remove attachment fetcher that has not stopped")
-    }
-
-    const indexToDelete = this.attachmentFetchers.findIndex((fetcher) => fetcher === attachmentFetcher)
-    if (indexToDelete === -1) {
-      return false
-    }
-
-    const newAttachmentFetchers = [...this.attachmentFetchers]
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    newAttachmentFetchers.splice(indexToDelete, 1)
-    // @ts-expect-error modifying readonly property
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.attachmentFetchers = Object.freeze(newAttachmentFetchers)
-
-    return true
-  }
-
-  /** @internal */
-  close() {
-    for (const observer of this.observers) {
-      observer.cancel()
-    }
-
-    for (const fetcher of this.attachmentFetchers) {
-      fetcher.stop()
-    }
-
-    // NOTE: live query webhook is taken care of by the FFI's
-    // `ditto_shutdown()`, no need to unregister it here.
-  }
-
-  /**
-   * Private method, used only by the Portal https://github.com/getditto/ditto/pull/3652
-   * @internal
-   */
-  async registerLiveQueryWebhook(collectionName: string, query: string, url: string): Promise<DocumentID> {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    return ditto.deferCloseAsync(async () => {
-      const validatedQuery = validateQuery(query)
-      const idCBOR = await FFI.liveQueryWebhookRegister(dittoHandle.deref(), collectionName, validatedQuery, [], 0, 0, url)
-      return new DocumentID(idCBOR, true)
-    })
-  }
-}