@dittolive/ditto 4.7.0 → 4.7.1

package/README.md

@@ -3,10 +3,10 @@
 _Ditto is a cross-platform SDK that allows mobile, web, and IoT apps to sync
 with and even without connectivity._
 
-Version: **4.7.0**
+Version: **4.7.1**
 
 For more information please visit [ditto.live](https://ditto.live), as well as the
-[API Reference](https://software.ditto.live/js/Ditto/4.7.0/api-reference/) for this particular version.
+[API Reference](https://software.ditto.live/js/Ditto/4.7.1/api-reference/) for this particular version.
 
 ---
 

package/node/ditto.cjs.js

@@ -802,14 +802,18 @@ function addSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy, l
     ensureInitialized();
     const collectionNameX = bytesFromString(collectionName);
     const queryX = bytesFromString(query);
-    return ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
+    const statusCode = ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
+    if (statusCode !== 0)
+        throw new Error(errorMessage() || `ditto_add_subscription() failed with error code: ${statusCode}`);
 }
 /** @internal */
 function removeSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy, limit, offset) {
     ensureInitialized();
     const collectionNameX = bytesFromString(collectionName);
     const queryX = bytesFromString(query);
-    return ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
+    const statusCode = ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
+    if (statusCode !== 0)
+        throw new Error(errorMessage() || `ditto_remove_subscription() failed with error code: ${statusCode}`);
 }
 /** @internal */
 function tryAddSyncSubscription(dittoPointer, query, queryArgsCBOR) {
@@ -1232,7 +1236,7 @@ function setDeadlockTimeout(duration) {
     setDeadlockTimeout$1(duration);
 }
 /** @internal */
-async function dittoRegisterPresenceV1Callback(self, cb) {
+function dittoRegisterPresenceV1Callback(self, cb) {
     ensureInitialized();
     ditto_register_presence_v1_callback(self, wrapBackgroundCbForFFI((err) => log('Error', `The registered presence callback v1 errored with ${err}`), (cJsonStr) => {
         const jsonStr = refCStringToString(cJsonStr);
@@ -1242,10 +1246,10 @@ async function dittoRegisterPresenceV1Callback(self, cb) {
 /** @internal */
 async function dittoClearPresenceCallback(self) {
     ensureInitialized();
-    await ditto_clear_presence_callback(self);
+    return ditto_clear_presence_callback(self);
 }
 /** @internal */
-async function dittoRegisterPresenceV3Callback(self, cb) {
+function dittoRegisterPresenceV3Callback(self, cb) {
     ensureInitialized();
     ditto_register_presence_v3_callback(self, wrapBackgroundCbForFFI((err) => log('Error', `The registered presence callback v3 errored with ${err}`), (cJsonStr) => {
         const jsonStr = refCStringToString(cJsonStr);
@@ -1255,7 +1259,7 @@ async function dittoRegisterPresenceV3Callback(self, cb) {
 /** @internal */
 async function dittoClearPresenceV3Callback(self) {
     ensureInitialized();
-    ditto_clear_presence_v3_callback(self);
+    return ditto_clear_presence_v3_callback(self);
 }
 /** @internal */
 function presencePeerMetadataJSON(self) {
@@ -1367,7 +1371,7 @@ function dittoSmallPeerInfoSetMetadata(dittoPointer, metadata) {
     }
 }
 /** @internal */
-async function dittoSmallPeerInfoCollectionSetTransportConfigData(self, transportConfigData) {
+function dittoSmallPeerInfoCollectionSetTransportConfigData(self, transportConfigData) {
     ensureInitialized();
     ditto_small_peer_info_set_transport_config_data(self, transportConfigData);
 }
@@ -2218,7 +2222,7 @@ class AttachmentToken {
 
 // NOTE: this is patched up with the actual build version by Jake task
 // build:package and has to be a valid semantic version as defined here: https://semver.org.
-const fullBuildVersionString = '4.7.0';
+const fullBuildVersionString = '4.7.1';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
@@ -4017,7 +4021,7 @@ Bridge.ditto = new _a(async (dittoPointer) => {
     // HACK: quick and dirty, clear all presence callbacks. This covers presence
     // v1 and v2 callbacks. v3 should be cleared properly by the `Presence`
     // class itself.
-    dittoClearPresenceCallback(dittoPointer);
+    await dittoClearPresenceCallback(dittoPointer);
     await dittoShutdown(dittoPointer);
     dittoFree(dittoPointer);
 });
@@ -6002,7 +6006,7 @@ class AttachmentFetcher {
             }
             this.ditto.store.removeAttachmentFetcher(this);
             const dittoHandle = Bridge.ditto.handleFor(this.ditto);
-            this.ditto.deferCloseAsync(async () => {
+            void this.ditto.deferCloseAsync(async () => {
                 // Cancel the fetcher if it is still running.
                 const cancelToken = await this.cancelTokenPromise;
                 if (cancelToken) {
@@ -6012,7 +6016,7 @@ class AttachmentFetcher {
         }
         else {
             // Legacy case where the fetcher was started from `Collection.fetchAttachment()`.
-            step(async () => {
+            void step(async () => {
                 await this.manager.stopAttachmentFetcher(this);
                 if (this.rejectPendingFetch != null) {
                     this.rejectPendingFetch();
@@ -6414,7 +6418,8 @@ class LiveQuery {
                         moves: cCBParams.moves.map((move) => ({ from: move[0], to: move[1] })),
                     });
                 }
-                handler(documents, event, signalNext);
+                // We discard the return promise because error-handling is not supported.
+                void handler(documents, event, signalNext);
             });
         });
         if (!liveQueryID) {
@@ -6602,9 +6607,9 @@ class PendingCursorOperation extends BasePendingCursorOperation {
     }
     /** @internal */
     _observe(handler, waitForNextSignal) {
-        function wrappedHandler(documents, event, nextSignal) {
+        async function wrappedHandler(documents, event, nextSignal) {
             try {
-                return handler.call(this, documents, event);
+                return await handler.call(this, documents, event);
             }
             finally {
                 nextSignal();
@@ -6762,7 +6767,7 @@ class PendingIDSpecificOperation extends BasePendingIDSpecificOperation {
     }
     /** @internal */
     _observe(handler, waitForNextSignal) {
-        const liveQuery = new LiveQuery(this.query, null, null, [], -1, 0, this.collection, (documents, event, signalNext) => {
+        const liveQuery = new LiveQuery(this.query, null, null, [], -1, 0, this.collection, async (documents, event, signalNext) => {
             if (documents.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned more than one document. Query: ${this.query}}.`);
             }
@@ -6785,11 +6790,11 @@ class PendingIDSpecificOperation extends BasePendingIDSpecificOperation {
             const oldDocument = event.isInitial === true ? undefined : event.oldDocuments[0];
             const singleDocumentEvent = new SingleDocumentLiveQueryEvent(event.isInitial, oldDocument);
             if (waitForNextSignal) {
-                handler(document, singleDocumentEvent, signalNext);
+                void handler(document, singleDocumentEvent, signalNext);
             }
             else {
                 try {
-                    handler(document, singleDocumentEvent);
+                    await handler(document, singleDocumentEvent);
                 }
                 finally {
                     signalNext();
@@ -7080,7 +7085,7 @@ class StoreObserver {
                 const result = Bridge.queryResult.bridge(cCBParams.query_result, () => new QueryResult(cCBParams.query_result));
                 Logger.debug(`Invoking user event handler with new event for store observer ${storeObserverID}`);
                 observationHandler(result, () => {
-                    strongThis.signalNext();
+                    return strongThis.signalNext();
                 });
             }
             mapFFIErrors(() => {
@@ -7187,7 +7192,9 @@ class PendingCollectionsOperation {
      * function calls to.
      */
     sort(propertyPath, direction = 'ascending') {
-        this.pendingCursorOperation.sort(propertyPath, direction);
+        // The return value is ignored here because we don't want to await the
+        // completion of the operation at this point.
+        void this.pendingCursorOperation.sort(propertyPath, direction);
         return this;
     }
     /**
@@ -7205,7 +7212,9 @@ class PendingCollectionsOperation {
      * function calls to.
      */
     offset(offset) {
-        this.pendingCursorOperation.offset(offset);
+        // The return value is ignored here because we don't want to await the
+        // completion of the operation at this point.
+        void this.pendingCursorOperation.offset(offset);
         return this;
     }
     /**
@@ -7217,7 +7226,9 @@ class PendingCollectionsOperation {
      * function calls to.
      */
     limit(limit) {
-        this.pendingCursorOperation.limit(limit);
+        // The return value is ignored here because we don't want to await the
+        // completion of the operation at this point.
+        void this.pendingCursorOperation.limit(limit);
         return this;
     }
     /**
@@ -7322,11 +7333,13 @@ class PendingCollectionsOperation {
                     moves: event.moves,
                 });
             }
+            // The handler return promises are ignored here because we are not
+            // handling errors during handler execution.
             if (waitForNextSignal) {
-                handler(collEvent, nextSignal);
+                void handler(collEvent, nextSignal);
             }
             else {
-                handler(collEvent);
+                void handler(collEvent);
             }
         };
         return this.pendingCursorOperation._observe(collectionsObservationHandler, waitForNextSignal);
@@ -7724,9 +7737,9 @@ class Store {
         // 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);
-        this.ditto.deferCloseAsync(async () => {
+        void this.ditto.deferCloseAsync(async () => {
             return new Promise((resolve) => {
-                step(async () => {
+                void step(async () => {
                     try {
                         // prettier-ignore
                         await mapFFIErrorsAsync(async () => await liveQueryStart(dittoHandle.deref(), storeObserver.liveQueryID));
@@ -8006,6 +8019,7 @@ class Store {
         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;
         });
@@ -8132,8 +8146,10 @@ class Store {
             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;
     }
@@ -8293,9 +8309,9 @@ class Presence {
      */
     async setPeerMetadataJSONString(jsonString) {
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
-        await this.ditto.deferClose(() => {
+        await this.ditto.deferCloseAsync(async () => {
             return mapFFIErrorsAsync(async () => {
-                await presenceTrySetPeerMetadataJSON(dittoHandle.deref(), jsonString);
+                return presenceTrySetPeerMetadataJSON(dittoHandle.deref(), jsonString);
             });
         });
     }
@@ -8370,8 +8386,8 @@ class Presence {
             unregister: () => {
                 const ditto = this.ditto;
                 const dittoHandle = Bridge.ditto.handleFor(ditto);
-                ditto.deferClose(() => {
-                    dittoClearPresenceV3Callback(dittoHandle.deref());
+                void ditto.deferCloseAsync(async () => {
+                    return dittoClearPresenceV3Callback(dittoHandle.deref());
                 });
             },
             process: (presenceGraphJSONString) => {
@@ -8410,7 +8426,7 @@ class LiveQueryManager {
         // (by definition). This is a classic zalgo case. Fix by making
         // `ditto_live_query_start()` trigger the first live query callback `async`,
         // just like the subsequent ones.
-        ditto.deferCloseAsync(async () => {
+        void this.ditto.deferCloseAsync(async () => {
             const liveQueryID = liveQuery.liveQueryID;
             if (!liveQueryID) {
                 throw new Error("Internal inconsistency, tried to add a live query that doesn't have a live query ID (probably stopped).");
@@ -8428,9 +8444,8 @@ class LiveQueryManager {
                 // not awaited on purpose; let the invocation of the initial observation
                 // happen in a "fire-and-forget" / detached / escaping fashion, to be
                 // consistent with the subsequent invocations.
-                step(async () => {
+                void step(async () => {
                     await liveQueryStart(dittoHandle.deref(), liveQueryID);
-                    // @ts-ignore
                     resolve();
                 });
             });
@@ -8505,7 +8520,7 @@ class PresenceManager {
         return token;
     }
     /** @internal */
-    removeObserver(token) {
+    async removeObserver(token) {
         const callback = this.callbacksByPresenceToken[token];
         if (typeof callback === 'undefined') {
             throw new Error(`Can't remove presence observer, token '${token}' has never been registered before.`);
@@ -8521,7 +8536,7 @@ class PresenceManager {
             // the observer objects themselves and remove it from the table
             // as soon as the observer object is garbage collected.
             this.callbacksByPresenceToken[token] = null;
-            this.unregisterIfNeeded();
+            return this.unregisterIfNeeded();
         }
     }
     /** @internal */
@@ -8529,11 +8544,10 @@ class PresenceManager {
         return typeof this.callbacksByPresenceToken[token] != 'undefined';
     }
     /** @internal */
-    close() {
+    async close() {
         this.isClosed = true;
-        for (const token in this.callbacksByPresenceToken) {
-            this.removeObserver(token);
-        }
+        const tokens = Object.keys(this.callbacksByPresenceToken);
+        return Promise.all(tokens.map((token) => this.removeObserver(token)));
     }
     hasObservers() {
         return Object.keys(this.callbacksByPresenceToken).length > 0;
@@ -8554,11 +8568,11 @@ class PresenceManager {
     unregisterIfNeeded() {
         const ditto = this.ditto;
         const dittoHandle = Bridge.ditto.handleFor(ditto);
-        ditto.deferClose(() => {
+        return this.ditto.deferCloseAsync(async () => {
             const needsToUnregister = !this.hasObservers() && this.isRegistered;
             if (needsToUnregister) {
                 this.isRegistered = false;
-                dittoClearPresenceCallback(dittoHandle.deref());
+                await dittoClearPresenceCallback(dittoHandle.deref());
                 this.currentRemotePeers = [];
             }
         });
@@ -9213,12 +9227,13 @@ class SubscriptionManager {
     /**
      * Begin tracking a subscription instance and start it.
      *
-     * @internal */
+     * @internal
+     */
     add(subscription) {
         const ditto = this.ditto;
         const dittoHandle = Bridge.ditto.handleFor(ditto);
         const contextInfo = subscription.contextInfo;
-        ditto.deferClose(async () => {
+        ditto.deferClose(() => {
             this.subscriptions[contextInfo.id] = new WeakRef(subscription);
             this.finalizationRegistry.register(subscription, subscription.contextInfo, subscription);
             addSubscription(dittoHandle.deref(), contextInfo.collectionName, contextInfo.query, contextInfo.queryArgsCBOR, contextInfo.orderBys, contextInfo.limit, contextInfo.offset);
@@ -9227,7 +9242,8 @@ class SubscriptionManager {
     /**
      * Stop tracking a subscription instance and cancel it.
      *
-     * @internal */
+     * @internal
+     */
     remove(subscription) {
         if (this.subscriptions[subscription.contextInfo.id] == null) {
             throw new Error(`Internal inconsistency, tried to remove a subscription that is not tracked: ${subscription.contextInfo.id}`);
@@ -9238,16 +9254,13 @@ class SubscriptionManager {
     /**
      * Stop tracking all subscriptions and cancel them.
      *
-     * @internal */
+     * @internal
+     */
     close() {
-        this.ditto.deferClose(async () => {
+        this.ditto.deferClose(() => {
             for (const subscriptionID in this.subscriptions) {
                 const subscription = this.subscriptions[subscriptionID].deref();
-                if (subscription != null) {
-                    // This doesn't call `Subscription.cancel()` because that is not
-                    // async and we want to wait for all subscriptions to be removed.
-                    this.remove(subscription);
-                }
+                subscription === null || subscription === void 0 ? void 0 : subscription.cancel();
             }
         });
     }
@@ -9255,7 +9268,8 @@ class SubscriptionManager {
      * Remove tracked subscription without unregistering from finalization
      * registry.
      *
-     * @internal */
+     * @internal
+     */
     removeWithContextInfo(contextInfo) {
         const ditto = this.ditto;
         const dittoHandle = Bridge.ditto.handleFor(ditto);
@@ -9343,7 +9357,7 @@ class AttachmentFetcherManager {
         // for this is that the FFI function `ditto_resolve_attachment()` is
         // async but should be non-async. Refactor and make that non-async, then
         // de-async-ify the closing mechanism.
-        this.ditto.deferCloseAsync(async () => {
+        void this.ditto.deferCloseAsync(async () => {
             const contextInfos = Object.values(this.contextInfoByID);
             const stopped = contextInfos.map(async (contextInfo) => {
                 const attachmentFetcher = contextInfo.attachmentFetcher.deref();
@@ -9417,8 +9431,8 @@ class SmallPeerInfo {
             throw new TypeError(`Expected boolean, got ${typeof newValue}`);
         }
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
-        this.ditto.deferClose(() => {
-            dittoSmallPeerInfoSetEnabled(dittoHandle.deref(), newValue);
+        void this.ditto.deferCloseAsync(async () => {
+            return dittoSmallPeerInfoSetEnabled(dittoHandle.deref(), newValue);
         });
     }
     /**
@@ -9712,7 +9726,7 @@ class Ditto {
             // auth all happens in the background and so there are no guarantees we
             // need to uphold by making sure things are in a certain state before the
             // constructor finishes
-            dittoAuthSetLoginProvider(dittoPointer, loginProviderX);
+            void dittoAuthSetLoginProvider(dittoPointer, loginProviderX);
         }
         else if (validIdentity.type === 'onlinePlayground') {
             this.auth = new OnlineAuthenticator(this.keepAlive, this, {
@@ -10080,7 +10094,7 @@ class Ditto {
         this.presence.close();
         this.auth.close();
         this.sync.close();
-        this.presenceManager.close();
+        await this.presenceManager.close();
         this.liveQueryManager.close();
         this.attachmentFetcherManager.close();
         this.transportConditionsManager.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittolive/ditto",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "description": "Ditto is a cross-platform embeddable NoSQL database that can sync with or without an internet connection.",
   "homepage": "https://ditto.live",
   "license": "SEE LICENSE IN LICENSE.md",

package/react-native/android/build.gradle

@@ -150,7 +150,7 @@ repositories {
 
 // This can be moved to gradle.properties (minus the quotes) with no code changes
 // here since `version` is a default project property.
-version = "4.7.0"
+version = "4.7.1"
 
 dependencies {
   // For < 0.71, this will be from the local maven repo

package/react-native/src/sources/@ditto.core.ts

@@ -1 +1 @@
-export * from '../ditto.rn';
+export * from '@dittolive/ditto/react-native/src/ditto.rn';

package/react-native/src/sources/@environment.ts

@@ -1 +1 @@
-export * from '../environment/environment.fallback';
+export * from '@dittolive/ditto/react-native/src/environment/environment.fallback';

package/react-native/src/sources/attachment-fetcher-manager.ts

@@ -101,7 +101,7 @@ export class AttachmentFetcherManager {
    * @internal
    */
   close() {
-    this.ditto.deferCloseAsync(async () => {
+    void this.ditto.deferCloseAsync(async () => {
       const contextInfos = Object.values(this.contextInfoByID)
       const stopped = contextInfos.map(async (contextInfo) => {
         const attachmentFetcher = contextInfo.attachmentFetcher.deref()

package/react-native/src/sources/attachment-fetcher.ts

@@ -60,7 +60,7 @@ export class AttachmentFetcher implements PromiseLike<Attachment | null> {
       this.ditto.store.removeAttachmentFetcher(this)
 
       const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-      this.ditto.deferCloseAsync(async () => {
+      void this.ditto.deferCloseAsync(async () => {
         // Cancel the fetcher if it is still running.
         const cancelToken = await this.cancelTokenPromise
         if (cancelToken) {
@@ -70,7 +70,7 @@ export class AttachmentFetcher implements PromiseLike<Attachment | null> {
     } else {
       // Legacy case where the fetcher was started from `Collection.fetchAttachment()`.
 
-      step(async () => {
+      void step(async () => {
         await this.manager.stopAttachmentFetcher(this)
         if (this.rejectPendingFetch != null) {
           this.rejectPendingFetch()

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

@@ -510,7 +510,7 @@ export class Bridge<T extends object, FFIType> {
 
   /** @internal */
   static readonly ditto = new Bridge<Ditto, FFI.FFIDitto>(async (dittoPointer) => {
-    FFI.dittoClearPresenceCallback(dittoPointer)
+    await FFI.dittoClearPresenceCallback(dittoPointer)
     await FFI.dittoShutdown(dittoPointer)
     FFI.dittoFree(dittoPointer)
   })

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

@@ -301,7 +301,11 @@ export class Ditto {
     Bridge.ditto.bridge(dittoPointer, this)
 
     if (Environment.isReactNativeBuild) {
-      this.disableSyncWithV3()
+      // FIXME: disabling sync needs to be awaited but that is not possible in
+      // the constructor
+      this.disableSyncWithV3().catch((error: any) => {
+        Logger.error(`Failed to disable sync with V3: ${error?.message}`)
+      })
     }
 
     // IMPORTANT: Keeping the auth client around accumulates run-times and
@@ -331,7 +335,7 @@ export class Ditto {
       // auth all happens in the background and so there are no guarantees we
       // need to uphold by making sure things are in a certain state before the
       // constructor finishes
-      FFI.dittoAuthSetLoginProvider(dittoPointer, loginProviderX)
+      void FFI.dittoAuthSetLoginProvider(dittoPointer, loginProviderX)
     } else if (validIdentity.type === 'onlinePlayground') {
       this.auth = new OnlineAuthenticator(this.keepAlive, this, {
         authenticationRequired: function (authenticator: Authenticator) {
@@ -699,7 +703,7 @@ export class Ditto {
     this.presence.close()
     this.auth.close()
     this.sync.close()
-    this.presenceManager.close()
+    await this.presenceManager.close()
     this.liveQueryManager.close()
     this.attachmentFetcherManager.close()
     this.transportConditionsManager.close()

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

@@ -539,23 +539,25 @@ export async function tryExecStatement(ditto: Pointer<FFIDitto>, writeTransactio
 }
 
 /** @internal */
-export function addSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number) {
+export function addSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): void {
   trace()
   ensureInitialized()
 
   const collectionNameX = bytesFromString(collectionName)
   const queryX = bytesFromString(query)
-  return dittoCore.ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+  const statusCode = dittoCore.ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+  if (statusCode !== 0) throw new Error(errorMessage() || `ditto_add_subscription() failed with error code: ${statusCode}`)
 }
 
 /** @internal */
-export function removeSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number) {
+export function removeSubscription(ditto: Pointer<FFIDitto>, collectionName: string, query: string, queryArgsCBOR: Uint8Array | null, orderBy: OrderBy[], limit: number, offset: number): void {
   trace()
   ensureInitialized()
 
   const collectionNameX = bytesFromString(collectionName)
   const queryX = bytesFromString(query)
-  return dittoCore.ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+  const statusCode = dittoCore.ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset)
+  if (statusCode !== 0) throw new Error(errorMessage() || `ditto_remove_subscription() failed with error code: ${statusCode}`)
 }
 
 /** @internal */
@@ -1142,7 +1144,7 @@ export function setDeadlockTimeout(duration: number): void {
 }
 
 /** @internal */
-export async function dittoRegisterPresenceV1Callback(self: Pointer<FFIDitto>, cb: (string) => void): Promise<void> {
+export function dittoRegisterPresenceV1Callback(self: Pointer<FFIDitto>, cb: (json: string) => void): void {
   trace()
   ensureInitialized()
 
@@ -1162,11 +1164,12 @@ export async function dittoRegisterPresenceV1Callback(self: Pointer<FFIDitto>, c
 export async function dittoClearPresenceCallback(self: Pointer<FFIDitto>): Promise<void> {
   trace()
   ensureInitialized()
-  await dittoCore.ditto_clear_presence_callback(self)
+
+  return dittoCore.ditto_clear_presence_callback(self)
 }
 
 /** @internal */
-export async function dittoRegisterPresenceV3Callback(self: Pointer<FFIDitto>, cb: (string) => void) {
+export function dittoRegisterPresenceV3Callback(self: Pointer<FFIDitto>, cb: (json: string) => void): void {
   trace()
   ensureInitialized()
 
@@ -1183,10 +1186,11 @@ export async function dittoRegisterPresenceV3Callback(self: Pointer<FFIDitto>, c
 }
 
 /** @internal */
-export async function dittoClearPresenceV3Callback(self: Pointer<FFIDitto>) {
+export async function dittoClearPresenceV3Callback(self: Pointer<FFIDitto>): Promise<void> {
   trace()
   ensureInitialized()
-  dittoCore.ditto_clear_presence_v3_callback(self)
+
+  return dittoCore.ditto_clear_presence_v3_callback(self)
 }
 
 /** @internal */
@@ -1343,9 +1347,10 @@ export function dittoSmallPeerInfoSetMetadata(dittoPointer: Pointer<FFIDitto>, m
 }
 
 /** @internal */
-export async function dittoSmallPeerInfoCollectionSetTransportConfigData(self: Pointer<FFIDitto>, transportConfigData: Uint8Array) {
+export function dittoSmallPeerInfoCollectionSetTransportConfigData(self: Pointer<FFIDitto>, transportConfigData: Uint8Array): void {
   trace()
   ensureInitialized()
+
   dittoCore.ditto_small_peer_info_set_transport_config_data(self, transportConfigData)
 }
 
@@ -2105,7 +2110,7 @@ function wrapBackgroundCbForFFI<
 /** @internal */
 // prettier-ignore
 function wrapAsyncBackgroundCbForFFI<
-  F extends (...args: any[]) => (Promise<any> | any), 
+  F extends (...args: any[]) => (Promise<any> | any),
   E extends (err: any) => void | null
 >(onError: E, cb: F): (
   ret_sender: (result: ReturnType<F>) => unknown, ...args: Parameters<F>

package/react-native/src/sources/live-query-manager.ts

@@ -36,7 +36,7 @@ export class LiveQueryManager {
     // `ditto_live_query_start()` trigger the first live query callback `async`,
     // just like the subsequent ones.
 
-    ditto.deferCloseAsync(async () => {
+    void this.ditto.deferCloseAsync(async () => {
       const liveQueryID = liveQuery.liveQueryID
       if (!liveQueryID) {
         throw new Error("Internal inconsistency, tried to add a live query that doesn't have a live query ID (probably stopped).")
@@ -54,13 +54,12 @@ export class LiveQueryManager {
 
       ditto.keepAlive.retain(`LiveQuery.${liveQueryID}`)
 
-      return new Promise((resolve, reject) => {
+      return new Promise<void>((resolve, reject) => {
         // not awaited on purpose; let the invocation of the initial observation
         // happen in a "fire-and-forget" / detached / escaping fashion, to be
         // consistent with the subsequent invocations.
-        step(async () => {
+        void step(async () => {
           await FFI.liveQueryStart(dittoHandle.deref(), liveQueryID)
-          // @ts-ignore
           resolve()
         })
       })