@dittolive/ditto 4.6.0 → 4.7.0-rc.3

package/node/ditto.cjs.js

@@ -407,15 +407,23 @@ function ditto_start_tcp_server(...args) { return ditto.ditto_start_tcp_server(.
 function ditto_stop_http_server(...args) { return ditto.ditto_stop_http_server(...args) }
 function ditto_stop_tcp_server(...args) { return ditto.ditto_stop_tcp_server(...args) }
 function ditto_validate_document_id(...args) { return ditto.ditto_validate_document_id(...args) }
-function ditto_verify_license(...args) { return ditto.ditto_verify_license(...args) }
 function ditto_write_transaction(...args) { return ditto.ditto_write_transaction(...args) }
 function ditto_write_transaction_commit(...args) { return ditto.ditto_write_transaction_commit(...args) }
 function ditto_write_transaction_rollback(...args) { return ditto.ditto_write_transaction_rollback(...args) }
 function dittoffi_base64_encode(...args) { return ditto.dittoffi_base64_encode(...args) }
+function dittoffi_connection_request_authorize(...args) { return ditto.dittoffi_connection_request_authorize(...args) }
+function dittoffi_connection_request_connection_type(...args) { return ditto.dittoffi_connection_request_connection_type(...args) }
+function dittoffi_connection_request_free(...args) { return ditto.dittoffi_connection_request_free(...args) }
+function dittoffi_connection_request_identity_service_metadata_json(...args) { return ditto.dittoffi_connection_request_identity_service_metadata_json(...args) }
+function dittoffi_connection_request_peer_key_string(...args) { return ditto.dittoffi_connection_request_peer_key_string(...args) }
+function dittoffi_connection_request_peer_metadata_json(...args) { return ditto.dittoffi_connection_request_peer_metadata_json(...args) }
 function dittoffi_error_code(...args) { return ditto.dittoffi_error_code(...args) }
 function dittoffi_error_description(...args) { return ditto.dittoffi_error_description(...args) }
 function dittoffi_error_free(...args) { return ditto.dittoffi_error_free(...args) }
 function dittoffi_get_sdk_semver(...args) { return ditto.dittoffi_get_sdk_semver(...args) }
+function dittoffi_presence_peer_metadata_json(...args) { return ditto.dittoffi_presence_peer_metadata_json(...args) }
+function dittoffi_presence_set_connection_request_handler(...args) { return ditto.dittoffi_presence_set_connection_request_handler(...args) }
+function dittoffi_presence_try_set_peer_metadata_json(...args) { return ditto.dittoffi_presence_try_set_peer_metadata_json(...args) }
 function dittoffi_query_result_free(...args) { return ditto.dittoffi_query_result_free(...args) }
 function dittoffi_query_result_item_at(...args) { return ditto.dittoffi_query_result_item_at(...args) }
 function dittoffi_query_result_item_cbor(...args) { return ditto.dittoffi_query_result_item_cbor(...args) }
@@ -430,16 +438,17 @@ function dittoffi_try_exec_statement(...args) { return ditto.dittoffi_try_exec_s
 function dittoffi_try_experimental_register_change_observer_str_detached(...args) { return ditto.dittoffi_try_experimental_register_change_observer_str_detached(...args) }
 function dittoffi_try_register_store_observer_webhook(...args) { return ditto.dittoffi_try_register_store_observer_webhook(...args) }
 function dittoffi_try_remove_sync_subscription(...args) { return ditto.dittoffi_try_remove_sync_subscription(...args) }
+function dittoffi_try_verify_license(...args) { return ditto.dittoffi_try_verify_license(...args) }
 function getDeadlockTimeout$1(...args) { return ditto.getDeadlockTimeout(...args) }
 function jsDocsToCDocs(...args) { return ditto.jsDocsToCDocs(...args) }
 function mdns_client_free_handle(...args) { return ditto.mdns_client_free_handle(...args) }
 function mdns_server_free_handle(...args) { return ditto.mdns_server_free_handle(...args) }
+function refCBytesIntoBuffer(...args) { return ditto.refCBytesIntoBuffer(...args) }
 function refCStringToString(...args) { return ditto.refCStringToString(...args) }
 function setDeadlockTimeout$1(...args) { return ditto.setDeadlockTimeout(...args) }
 function static_tcp_client_free_handle(...args) { return ditto.static_tcp_client_free_handle(...args) }
 function websocket_client_free_handle(...args) { return ditto.websocket_client_free_handle(...args) }
 function withOutBoxCBytes(...args) { return ditto.withOutBoxCBytes(...args) }
-function withOutPtr$1(...args) { return ditto.withOutPtr(...args) }
 
 const isWebBuild = false;
 
@@ -704,8 +713,11 @@ async function collectionInsertValue(ditto, collectionName, doc_cbor, writeStrat
         case 'insertDefaultIfAbsent':
             strategy = 'InsertDefaultIfAbsent';
             break;
+        case 'updateDifferentValues':
+            strategy = 'UpdateDifferentValues';
+            break;
         default:
-            throw new Error('Invalid write strategy provided');
+            throw new Error(`Unsupported write strategy '${writeStrategy}' provided.`);
     }
     const { status_code: errorCode, id } = await ditto_collection_insert_value(ditto, collectionNameX, doc_cbor, strategy, null, writeTransaction !== null && writeTransaction !== void 0 ? writeTransaction : null);
     if (errorCode !== 0)
@@ -778,7 +790,7 @@ async function collectionEvictQueryStr(ditto, collectionName, writeTransaction,
  *
  * @internal
  */
-async function tryExperimentalExecQueryStr(ditto, writeTransaction, query, queryArgsCBOR) {
+async function tryExecStatement(ditto, writeTransaction, query, queryArgsCBOR) {
     ensureInitialized();
     const queryBytesPointer = bytesFromString(query);
     const result = await dittoffi_try_exec_statement(ditto, writeTransaction, queryBytesPointer, queryArgsCBOR);
@@ -800,7 +812,7 @@ function removeSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy
     return ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
 }
 /** @internal */
-function tryExperimentalAddDQLSubscription(dittoPointer, query, queryArgsCBOR) {
+function tryAddSyncSubscription(dittoPointer, query, queryArgsCBOR) {
     ensureInitialized();
     const queryBuffer = bytesFromString(query);
     const result = dittoffi_try_add_sync_subscription(dittoPointer, queryBuffer, queryArgsCBOR);
@@ -808,42 +820,42 @@ function tryExperimentalAddDQLSubscription(dittoPointer, query, queryArgsCBOR) {
     return;
 }
 /** @internal */
-function tryExperimentalRemoveDQLSubscription(dittoPointer, query, queryArgsCBOR) {
+function tryRemoveSyncSubscription(dittoPointer, query, queryArgsCBOR) {
     ensureInitialized();
     const queryBuffer = bytesFromString(query);
     const result = dittoffi_try_remove_sync_subscription(dittoPointer, queryBuffer, queryArgsCBOR);
     throwOnErrorResult(result.error, 'dittoffi_try_remove_sync_subscription');
     return;
 }
-// ----------------------------------------------------------- DqlResponse ------
+// ----------------------------------------------------------- QueryResult ------
 /**
  * Doesn't error
  *
  * @internal
  */
-function dqlResponseFree(responsePointer) {
+function queryResultFree(queryResultPointer) {
     ensureInitialized();
-    dittoffi_query_result_free(responsePointer);
+    dittoffi_query_result_free(queryResultPointer);
 }
 /**
  * Doesn't error
  *
  * @internal
  */
-function dqlResultFree(resultPointer) {
+function queryResultItemFree(queryResultItemPointer) {
     ensureInitialized();
-    dittoffi_query_result_item_free(resultPointer);
+    dittoffi_query_result_item_free(queryResultItemPointer);
 }
 /**
  * Can error only on internal bug.
  *
  * @internal */
-function dqlResponseResults(responsePointer) {
+function queryResultItems(queryResultPointer) {
     ensureInitialized();
     const rv = [];
-    const resultCount = dittoffi_query_result_item_count(responsePointer);
+    const resultCount = dittoffi_query_result_item_count(queryResultPointer);
     for (let i = 0; i < resultCount; i++) {
-        rv.push(dittoffi_query_result_item_at(responsePointer, i));
+        rv.push(dittoffi_query_result_item_at(queryResultPointer, i));
     }
     return rv;
 }
@@ -852,44 +864,42 @@ function dqlResponseResults(responsePointer) {
  *
  * @internal
  */
-function dqlMutatedDocumentIDs(responsePointer) {
+function queryResultMutatedDocumentIDs(queryResultPointer) {
     ensureInitialized();
     const rv = [];
-    const resultCount = dittoffi_query_result_mutated_document_id_count(responsePointer);
+    const resultCount = dittoffi_query_result_mutated_document_id_count(queryResultPointer);
     for (let i = 0; i < resultCount; i++) {
-        const cborBytes = dittoffi_query_result_mutated_document_id_at(responsePointer, i);
+        const cborBytes = dittoffi_query_result_mutated_document_id_at(queryResultPointer, i);
         rv.push(boxCBytesIntoBuffer(cborBytes));
     }
     return rv;
 }
 /**
- * The result CBOR contains a map/object with fields and values.
- * No CRDTs are present there as they are not needed. Currently
- * only values from registers are returned and non-register fields are
- * ignored. Reading values from other CRDTs will be supported with
- * definition support.
+ * The result CBOR contains a map/object with fields and values. No CRDTs are
+ * present there as they are not needed. By default only values from registers
+ * are returned and non-register fields are ignored.
  *
  * Doesn't error
  *
  * @internal
  */
-function dqlResultCBOR(resultPointer) {
+function queryResultItemCBOR(queryResultItemPointer) {
     ensureInitialized();
-    const cborBytes = dittoffi_query_result_item_cbor(resultPointer);
+    const cborBytes = dittoffi_query_result_item_cbor(queryResultItemPointer);
     return boxCBytesIntoBuffer(cborBytes);
 }
 /**
- * Returns JSON-encoded results given a DQL result pointer.
+ * Returns JSON-encoded results given a DQL result item pointer.
  *
- * Compare for {@link dqlResultCBOR} above.
+ * Compare for {@link queryResultItemCBOR} above.
  *
  * Doesn't error
  *
  * @internal
  */
-function dqlResultJSON(resultPointer) {
+function queryResultItemJSON(queryResultItemPointer) {
     ensureInitialized();
-    const jsonBytes = dittoffi_query_result_item_json(resultPointer);
+    const jsonBytes = dittoffi_query_result_item_json(queryResultItemPointer);
     return boxCStringIntoString(jsonBytes);
 }
 // ------------------------------------------------------------ LiveQuery ------
@@ -954,7 +964,7 @@ async function liveQueryWebhookRegister(ditto, collectionName, query, orderBy, l
     return boxCBytesIntoBuffer(id);
 }
 /** @internal */
-async function tryExperimentalWebhookRegisterDqlLiveQuery(ditto, query, queryArgsCBOR, url) {
+async function tryRegisterStoreObserverWebhook(ditto, query, queryArgsCBOR, url) {
     ensureInitialized();
     const queryBuffer = bytesFromString(query);
     const urlBuffer = bytesFromString(url);
@@ -1248,6 +1258,69 @@ async function dittoClearPresenceV3Callback(self) {
     ditto_clear_presence_v3_callback(self);
 }
 /** @internal */
+function presencePeerMetadataJSON(self) {
+    ensureInitialized();
+    const result = dittoffi_presence_peer_metadata_json(self);
+    const typedArray = boxCBytesIntoBuffer(result);
+    const textDecoder = new TextDecoder();
+    return textDecoder.decode(typedArray);
+}
+/** @internal */
+async function presenceTrySetPeerMetadataJSON(self, jsonString) {
+    ensureInitialized();
+    const jsonDataCString = bytesFromString(jsonString);
+    const result = await dittoffi_presence_try_set_peer_metadata_json(self, jsonDataCString);
+    throwOnErrorResult(result.error, 'dittoffi_presence_try_set_peer_metadata_json');
+}
+/** @internal */
+function connectionRequestPeerKeyString(connectionRequest) {
+    ensureInitialized();
+    const cString = dittoffi_connection_request_peer_key_string(connectionRequest);
+    return boxCStringIntoString(cString);
+}
+/** @internal */
+function connectionRequestPeerMetadataJSON(connectionRequest) {
+    ensureInitialized();
+    const jsonByteRef = dittoffi_connection_request_peer_metadata_json(connectionRequest);
+    const jsonBuffer = refCBytesIntoBuffer(jsonByteRef);
+    const textDecoder = new TextDecoder();
+    return textDecoder.decode(jsonBuffer);
+}
+/** @internal */
+function connectionRequestIdentityServiceMetadataJSON(connectionRequest) {
+    ensureInitialized();
+    const jsonBytesRef = dittoffi_connection_request_identity_service_metadata_json(connectionRequest);
+    const jsonBuffer = refCBytesIntoBuffer(jsonBytesRef);
+    const textDecoder = new TextDecoder();
+    return textDecoder.decode(jsonBuffer);
+}
+/** @internal */
+function connectionRequestConnectionType(connectionRequest) {
+    ensureInitialized();
+    return dittoffi_connection_request_connection_type(connectionRequest);
+}
+/** @internal */
+function connectionRequestAuthorize(connectionRequest, authorization) {
+    ensureInitialized();
+    dittoffi_connection_request_authorize(connectionRequest, authorization);
+}
+/** @internal */
+function connectionRequestFree(connectionRequest) {
+    ensureInitialized();
+    dittoffi_connection_request_free(connectionRequest);
+}
+/** @internal */
+function presenceSetConnectionRequestHandler(ditto, connectionRequestHandler, onError) {
+    ensureInitialized();
+    if (connectionRequestHandler == null) {
+        dittoffi_presence_set_connection_request_handler(ditto, null);
+    }
+    else {
+        const wrappedCallback = wrapAsyncBackgroundCbForFFI(onError, connectionRequestHandler);
+        dittoffi_presence_set_connection_request_handler(ditto, wrappedCallback);
+    }
+}
+/** @internal */
 function dittoSmallPeerInfoGetIsEnabled(dittoPointer) {
     ensureInitialized();
     return ditto_small_peer_info_get_is_enabled(dittoPointer);
@@ -1312,8 +1385,9 @@ function dittoRegisterTransportConditionChangedCallback(self, cb) {
 /** @internal */
 function dittoSetDeviceName(dittoPointer, deviceName) {
     ensureInitialized();
-    let deviceNameCString = bytesFromString(deviceName);
-    return ditto_set_device_name(dittoPointer, deviceNameCString);
+    const deviceNameCString = bytesFromString(deviceName);
+    const truncatedDeviceNameCString = ditto_set_device_name(dittoPointer, deviceNameCString);
+    return boxCStringIntoString(truncatedDeviceNameCString);
 }
 /** @internal */
 function dittoSetConnectRetryInterval(dittoPointer, retryInterval) {
@@ -1361,7 +1435,10 @@ async function dittoResolveAttachment(ditto, id, namedCallbacks,
 onError) {
     ensureInitialized();
     const { onComplete, onProgress, onDelete } = namedCallbacks;
-    const { status_code: errorCode, cancel_token: cancelToken } = await ditto_resolve_attachment(ditto, id, wrapBackgroundCbForFFI(onError, onComplete), wrapBackgroundCbForFFI(onError, onProgress), wrapBackgroundCbForFFI(onError, onDelete));
+    const wrappedOnComplete = wrapBackgroundCbForFFI(onError, onComplete);
+    const wrappedOnProgress = wrapBackgroundCbForFFI(onError, onProgress);
+    const wrappedOnDelete = wrapBackgroundCbForFFI(onError, onDelete);
+    const { status_code: errorCode, cancel_token: cancelToken } = await ditto_resolve_attachment(ditto, id, wrappedOnComplete, wrappedOnProgress, wrappedOnDelete);
     if (errorCode !== 0) {
         throw new DittoFFIError(errorCode, null, `ditto_resolve_attachment() failed with error code: ${errorCode}`);
     }
@@ -1676,11 +1753,8 @@ function withTransportsError(ffiFunction, ...args) {
 // ---------------------------------------------------------------- Other ------
 /** @internal */
 let isInitialized = false;
-/** @internal */
-let withOutPtr;
 {
     isInitialized = true;
-    withOutPtr = wrapFFIOutFunction(withOutPtr$1);
 }
 /** @internal */
 function initSDKVersion(platform, language, semVer) {
@@ -1693,16 +1767,11 @@ function initSDKVersion(platform, language, semVer) {
         throw new Error(errorMessage() || `ditto_init_sdk_version() failed with error code: ${errorCode}`);
 }
 /** @internal */
-function verifyLicense(license) {
+function tryVerifyLicense(license) {
     ensureInitialized();
     const licenseBuffer = bytesFromString(license);
-    let result;
-    const errorMessageCString = withOutPtr('char *', (outErrorMessage) => {
-        result = ditto_verify_license(licenseBuffer, outErrorMessage);
-        return outErrorMessage;
-    });
-    const errorMessage = boxCStringIntoString(errorMessageCString);
-    return { result, errorMessage };
+    const result = dittoffi_try_verify_license(licenseBuffer);
+    throwOnErrorResult(result.error, 'dittoffi_try_verify_license');
 }
 // -------------------------------------------------------------- Private ------
 // HACK: this is a left-over error code still in use which will be removed
@@ -1712,11 +1781,9 @@ function verifyLicense(license) {
 /** @internal */
 const NOT_FOUND_ERROR_CODE = -30798;
 /** @internal */
+// prettier-ignore
 function wrapBackgroundCbForFFI(onError, cb) {
-    // Basic fallback based off: https://stackoverflow.com/a/3390635
-    if (onError === undefined) {
-        onError = (err) => log('Error', `The registered callback failed with ${err}`);
-    }
+    const errorHandler = onError !== null && onError !== void 0 ? onError : ((err) => log('Error', `The registered callback failed with ${err}`));
     return (ret_sender, ...args) => {
         let ret;
         try {
@@ -1724,7 +1791,7 @@ function wrapBackgroundCbForFFI(onError, cb) {
         }
         catch (err) {
             try {
-                onError(err);
+                errorHandler(err);
             }
             catch (nested_error) {
                 log('Error', `Internal error: \`onError()\` handler oughtn't throw, but it did throw ${nested_error}`);
@@ -1734,26 +1801,23 @@ function wrapBackgroundCbForFFI(onError, cb) {
     };
 }
 /** @internal */
-function wrapFFIOutFunction(ffiOutFunction) {
-    return function (...args) {
-        let occurredError = undefined;
-        let callbackResult = undefined;
-        let isCallbackResultOutParameter = false;
-        const callback = args[args.length - 1];
-        const previous_args = args.splice(0, args.length - 1);
-        const dittoCoreResult = ffiOutFunction(...previous_args, (outParameter) => {
+// prettier-ignore
+function wrapAsyncBackgroundCbForFFI(onError, cb) {
+    const errorHandler = onError !== null && onError !== void 0 ? onError : ((err) => log('Error', `The registered callback failed with ${err}`));
+    return async (ret_sender, ...args) => {
+        let ret;
+        try {
+            ret = await cb(...args);
+        }
+        catch (err) {
             try {
-                callbackResult = callback(outParameter);
-                isCallbackResultOutParameter = callbackResult === outParameter;
+                errorHandler(err);
             }
-            catch (error) {
-                occurredError = error;
+            catch (nested_error) {
+                log('Error', `Internal error: \`onError()\` handler oughtn't throw, but it did throw ${nested_error}`);
             }
-        });
-        if (occurredError) {
-            throw occurredError;
         }
-        return isCallbackResultOutParameter ? dittoCoreResult : callbackResult;
+        return ret_sender(ret);
     };
 }
 /** @internal */
@@ -1801,9 +1865,9 @@ function ensureInitialized() {
  */
 const ERROR_CODES = {
     /** Internal error for unexpected system states */
-    internal: 'An unexpected internal error occured. Please get in touch with Ditto customer service to report this incident.',
-    /** Internal error with an unknown error cause **/
-    'internal/unknown-error': 'An unexpected internal error occured. Please get in touch with Ditto customer service to report this incident.',
+    internal: 'An unexpected internal error occurred. Please get in touch with Ditto customer service to report this incident.',
+    /** Internal error with an unknown error cause */
+    'internal/unknown-error': 'An unexpected internal error occurred. Please get in touch with Ditto customer service to report this incident.',
     //
     // Errors originating in the SDK
     //
@@ -1843,6 +1907,29 @@ const ERROR_CODES = {
     'store/failed-to-create-attachment': 'The attachment could not be created.',
     /** An unclassified error while fetching an attachment. */
     'store/failed-to-fetch-attachment': 'The attachment could not be fetched.',
+    //
+    // Activation errors
+    //
+    /** An error representing an invalid license token. */
+    'activation/license-token-verification-failed': 'Please provide a valid license token.',
+    /** An error representing an expired license token.  */
+    'activation/license-token-expired': 'The license token expired. Please renew it.',
+    /** An error representing a token is in an unsupported future format. */
+    'activation/license-token-unsupported-future-version': 'The provided license token is in an unsupported future format.',
+    /** The operation failed because it requires an activated Ditto instance. */
+    'activation/not-activated': 'The operation failed because the Ditto instance has not yet been activated.',
+    /** A validation error where the maximum depth limit was exceeded. */
+    'validation/depth-limit-exceeded': 'The maximum depth limit has been exceeded.',
+    /** A validation error where the value is not valid CBOR. */
+    'validation/invalid-cbor': 'The value provided is not valid CBOR.',
+    /** A validation error where the value is not valid JSON. */
+    'validation/invalid-json': 'The value provided is not valid JSON.',
+    /** A validation error where a value is required to be a JavaScript object */
+    'validation/not-an-object': 'The value provided is not of type object.',
+    /** The value provided can not be serialized as JSON. */
+    'validation/not-json-compatible': 'Value is not serializable as JSON.',
+    /** A validation error where a size limit was exceeded. */
+    'validation/size-limit-exceeded': 'The size limit has been exceeded.',
 };
 
 //
@@ -1850,6 +1937,13 @@ const ERROR_CODES = {
 //
 /** @see {@link FFIErrorMapping} */
 const DEFAULT_STATUS_CODE_MAPPING = {
+    //
+    // Activation errors
+    //
+    ActivationLicenseTokenExpired: ['activation/license-token-expired'],
+    ActivationLicenseTokenInvalid: ['activation/license-token-verification-failed'],
+    ActivationLicenseUnsupportedFutureVersion: ['activation/license-token-unsupported-future-version'],
+    ActivationNotActivated: ['activation/not-activated'],
     //
     // SDK-specific errors
     //
@@ -1874,6 +1968,11 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     // This gets mapped to `internal` by default but depending on the context,
     // it should be mapped to a more specific error code.
     Base64Invalid: ['internal', 'Invalid base64 encoding.'],
+    ValidationDepthLimitExceeded: ['validation/depth-limit-exceeded'],
+    ValidationInvalidCbor: ['validation/invalid-cbor'],
+    ValidationInvalidJson: ['validation/invalid-json'],
+    ValidationNotAMap: ['validation/not-an-object'],
+    ValidationSizeLimitExceeded: ['validation/size-limit-exceeded'],
     default: ['internal/unknown-error'],
 };
 /**
@@ -1883,6 +1982,22 @@ const DEFAULT_STATUS_CODE_MAPPING = {
  *
  * Please reference {@link ERROR_CODES} for a comprehensive list of
  * possible error codes in this SDK version.
+ *
+ * @example
+ * Handling a specific error code:
+ * ```typescript
+ * import { Attachment, DittoError } from '@dittolive/ditto'
+ *
+ * let attachment: Attachment
+ * try {
+ *   attachment = await ditto.store.newAttachment(filePath)
+ * } catch (error) {
+ *   if (error instanceof DittoError && error.code === 'store/attachment-file-not-found') {
+ *     // Handle a non-existing file
+ *   }
+ *   throw error // Rethrow any other error
+ * }
+ * ```
  */
 class DittoError extends Error {
     // --------------------------------------- Internal ------------------------
@@ -1897,7 +2012,7 @@ class DittoError extends Error {
         if (ERROR_CODES[code] == null) {
             throw new DittoError('internal', `Invalid error code: ${code}`);
         }
-        super(`<${code}> ${message || ERROR_CODES[code]}`);
+        super(message || ERROR_CODES[code]);
         /**
          * Use the error code to identify a specific error programatically.
          *
@@ -2103,7 +2218,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.6.0';
+const fullBuildVersionString = '4.7.0-rc.3';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
@@ -3884,13 +3999,15 @@ Bridge.all = [];
 /** @internal */
 Bridge.attachment = new _a(freeAttachmentHandle);
 /** @internal */
+Bridge.connectionRequest = new _a(connectionRequestFree);
+/** @internal */
 Bridge.document = new _a(documentFree);
 /** @internal */
 Bridge.mutableDocument = new _a(documentFree);
 /** @internal */
-Bridge.dqlResponse = new _a(dqlResponseFree);
+Bridge.queryResult = new _a(queryResultFree);
 /** @internal */
-Bridge.dqlResult = new _a(dqlResultFree);
+Bridge.queryResultItem = new _a(queryResultItemFree);
 /** @internal */
 Bridge.staticTCPClient = new _a(staticTCPClientFreeHandle);
 /** @internal */
@@ -5143,6 +5260,106 @@ class BasePendingIDSpecificOperation {
     }
 }
 
+//
+// Copyright © 2024 DittoLive Incorporated. All rights reserved.
+//
+/**
+ * Contains information about a remote peer that has requested a connection.
+ *
+ * Connection requests and their authorization are scoped to a specific Ditto
+ * peer and connection type.
+ */
+class ConnectionRequest {
+    /**
+     * The unique peer key of the remote peer.
+     *
+     * @see field `peerKeyString` on {@link Peer} for more information on peer
+     * keys.
+     */
+    get peerKeyString() {
+        return connectionRequestPeerKeyString(this.deref());
+    }
+    /**
+     * Metadata associated with the remote peer.
+     *
+     * This is an empty object if the remote peer has not set any metadata.
+     *
+     * Set peer metadata for the local peer using {@link Presence.peerMetadata}
+     * or {@link Presence.peerMetadataJSONString}.
+     *
+     * This is a convenience property that wraps
+     * {@link peerMetadataJSONString | `peerMetadataJSONString()`}.
+     */
+    get peerMetadata() {
+        return JSON.parse(this.peerMetadataJSONString);
+    }
+    /**
+     * JSON-encoded metadata associated with the remote peer.
+     *
+     * This is a JSON string representing an empty dictionary if the remote peer
+     * has not set any metadata.
+     *
+     * Set peer metadata for the local peer using {@link Presence.peerMetadata} or
+     * {@link Presence.peerMetadataJSONString}.
+     *
+     * Uses UTF-8 encoding.
+     */
+    get peerMetadataJSONString() {
+        return connectionRequestPeerMetadataJSON(this.deref());
+    }
+    /**
+     * Metadata for the remote peer that is provided by the identity service.
+     *
+     * Use an authentication webhook to set this value. See Ditto's online
+     * documentation for more information on how to configure an authentication
+     * webhook.
+     *
+     * Convenience property that wraps {@link identityServiceMetadataJSONString}.
+     */
+    get identityServiceMetadata() {
+        return JSON.parse(this.identityServiceMetadataJSONString);
+    }
+    /**
+     * JSON-encoded metadata for the remote peer that is provided by the
+     * identity service.
+     *
+     * Use an authentication webhook to set this value. See Ditto's online
+     * documentation for more information on how to configure an authentication
+     * webhook.
+     *
+     * Uses UTF-8 encoding.
+     */
+    get identityServiceMetadataJSONString() {
+        return connectionRequestIdentityServiceMetadataJSON(this.deref());
+    }
+    /**
+     * The network transport of this connection request.
+     *
+     * Expect to receive separate connection requests for each network
+     * transport that connects the local and remote peer.
+     */
+    get connectionType() {
+        return connectionRequestConnectionType(this.deref());
+    }
+    /** @internal */
+    toString() {
+        return `ConnectionRequest(${this.peerKeyString} via ${this.connectionType})`;
+    }
+    /**
+     * Defines a custom inspect function for Node.js that will be used when the
+     * object is inspected with console.log() or util.inspect().
+     *
+     * @internal
+     */
+    [Symbol.for('nodejs.util.inspect.custom')](_depth, _inspectOptions, inspect) {
+        return this.toString();
+    }
+    // --------------------------------------------------------------------------
+    deref() {
+        return Bridge.connectionRequest.handleFor(this).deref();
+    }
+}
+
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
@@ -6776,18 +6993,18 @@ class QueryResult {
      * @returns an array of document IDs
      */
     mutatedDocumentIDs() {
-        const responseHandle = Bridge.dqlResponse.handleFor(this);
-        const affectedCBORIDs = dqlMutatedDocumentIDs(responseHandle.deref());
+        const queryResultHandle = Bridge.queryResult.handleFor(this);
+        const affectedCBORIDs = queryResultMutatedDocumentIDs(queryResultHandle.deref());
         return affectedCBORIDs.map((id) => new DocumentID(id, true));
     }
     // ----------------------------------------------------- Internal ------------
     /** @internal */
-    constructor(responsePointer) {
-        if (responsePointer == null) {
+    constructor(queryResultPointer) {
+        if (queryResultPointer == null) {
             throw new Error('Internal inconsistency, failed to initialize query result without a response pointer');
         }
-        const results = dqlResponseResults(responsePointer);
-        this.items = results.map((r) => Bridge.dqlResult.bridge(r));
+        const resultItems = queryResultItems(queryResultPointer);
+        this.items = resultItems.map((r) => Bridge.queryResultItem.bridge(r));
     }
 }
 
@@ -6857,19 +7074,15 @@ class StoreObserver {
                     Logger.debug(`Ignoring change event received by store observer ${storeObserverID} after it was cancelled`);
                     return;
                 }
-                const response = Bridge.dqlResponse.bridge(cCBParams.query_result, () => new QueryResult(cCBParams.query_result));
+                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(response, () => {
+                observationHandler(result, () => {
                     strongThis.signalNext();
                 });
             }
-            const errorContext = {
-                query,
-                queryArguments,
-            };
             mapFFIErrors(() => {
                 storeObserverID = tryExperimentalRegisterChangeObserver(dittoHandle.deref(), query, queryArgumentsCBOR, wrappedObservationHandler);
-            }, undefined, errorContext);
+            });
         });
         if (storeObserverID == null) {
             throw new DittoError('internal', 'Internal inconsistency, store observer ID is undefined after registering');
@@ -7594,10 +7807,9 @@ class Store {
                     throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`);
                 }
             }
-            const errorContext = { query, queryArguments };
             // prettier-ignore
-            const responsePointer = await mapFFIErrorsAsync(async () => await performAsyncToWorkaroundNonAsyncFFIAPI(() => tryExperimentalExecQueryStr(dittoHandle.deref(), writeTransaction, query, queryArgumentsCBOR)), undefined, errorContext);
-            return Bridge.dqlResponse.bridge(responsePointer, () => new QueryResult(responsePointer));
+            const queryResultPointer = await mapFFIErrorsAsync(async () => await performAsyncToWorkaroundNonAsyncFFIAPI(() => tryExecStatement(dittoHandle.deref(), writeTransaction, query, queryArgumentsCBOR)));
+            return Bridge.queryResult.bridge(queryResultPointer, () => new QueryResult(queryResultPointer));
         });
     }
     /**
@@ -7845,11 +8057,10 @@ class Store {
                 throw new DittoError('query/arguments-invalid', `Invalid query arguments: ${error.message}`);
             }
         }
-        const errorContext = { query, queryArguments };
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
         // prettier-ignore
         return this.ditto.deferCloseAsync(async () => {
-            const webhookIDCBOR = await mapFFIErrorsAsync(async () => await tryExperimentalWebhookRegisterDqlLiveQuery(dittoHandle.deref(), query, queryArgumentsCBOR, url), undefined, errorContext);
+            const webhookIDCBOR = await mapFFIErrorsAsync(async () => await tryRegisterStoreObserverWebhook(dittoHandle.deref(), query, queryArgumentsCBOR, url));
             return new DocumentID(webhookIDCBOR, true);
         });
     }
@@ -7970,6 +8181,61 @@ function addressToString(address) {
  * instance via its `presence` property.
  */
 class Presence {
+    /**
+     * Set this handler to control which peers in a Ditto mesh can connect to the
+     * current peer.
+     *
+     * Each peer in a Ditto mesh will attempt to connect to other peers that it
+     * can reach. By default, the mesh will try and establish connections that
+     * optimize for the best overall connectivity between peers. However, you can
+     * set this handler to assert some control over which peers you connect to.
+     *
+     * If set, this handler is called for every incoming connection request from a
+     * remote peer and is passed the other peer's `peerKey`, `peerMetadata`, and
+     * `identityServiceMetadata`. The handler can then accept or reject the
+     * request by returning an according {@link ConnectionRequestAuthorization}
+     * value. When the connection request is rejected, the remote peer may retry
+     * the connection request after a short delay.
+     *
+     * Connection request handlers must reliably respond to requests within a
+     * short time. If a handler takes too long to respond or throws an exception,
+     * the connection request will be denied. The response timeout is currently 10
+     * seconds but may be subject to change in future releases.
+     *
+     * @see {@link peerMetadata | peerMetadata()}
+     */
+    get connectionRequestHandler() {
+        return this._connectionRequestHandler;
+    }
+    /**
+     * @throws TypeError: if the given handler is not a function.
+     */
+    set connectionRequestHandler(handler) {
+        let wrappedHandler = null;
+        if (handler != null) {
+            if (typeof handler !== 'function') {
+                throw new TypeError(`Expected parameter 'handler' to be a function but got ${typeof handler} instead`);
+            }
+            wrappedHandler = async (connectionRequest) => {
+                const request = Bridge.connectionRequest.bridge(connectionRequest);
+                // Any errors will be caught by ffi.ts and passed to `handleError` below
+                const authorization = await handler(request);
+                if (authorization !== 'allow' && authorization !== 'deny') {
+                    Logger.error(`The connection request handler must return "allow" or "deny" but returned "${authorization}" instead. The connection request will be denied.`);
+                    return 'Deny';
+                }
+                connectionRequestAuthorize(connectionRequest, authorization === 'allow' ? 'Allow' : 'Deny');
+            };
+        }
+        this._connectionRequestHandler = handler;
+        const handleError = (error) => {
+            Logger.error(`The connection request handler threw an error while handling a connection request, the connection request will be denied. ${error}`);
+        };
+        const dittoHandle = Bridge.ditto.handleFor(this.ditto);
+        this.ditto.deferClose(() => {
+            presenceSetConnectionRequestHandler(dittoHandle.deref(), wrappedHandler, handleError);
+        });
+    }
     /**
      * Returns the current presence graph capturing all known peers and
      * connections between them.
@@ -7982,6 +8248,87 @@ class Presence {
             return JSON.parse(graphJSONString);
         });
     }
+    /**
+     * Metadata associated with the current peer. Other peers in the same mesh can
+     * access this user-provided object of metadata via the presence {@link graph}
+     * and when evaluating connection requests using
+     * {@link connectionRequestHandler | connectionRequestHandler()}.
+     *
+     * Uses UTF-8 encoding.
+     *
+     * @see {@link peerMetadata | peerMetadata()} for a convenience property that
+     * provides access to parsed metadata.
+     */
+    get peerMetadataJSONString() {
+        const dittoHandle = Bridge.ditto.handleFor(this.ditto);
+        return this.ditto.deferClose(() => {
+            return mapFFIErrors(() => {
+                return presencePeerMetadataJSON(dittoHandle.deref());
+            });
+        });
+    }
+    /**
+     * Set arbitrary metadata to be associated with the current peer.
+     *
+     * The metadata must not exceed 4 KB in size when JSON-encoded.
+     *
+     * @param {string} jsonString: JSON-encoded metadata.
+     *
+     * @throws {@link DittoError} `validation/invalid-json`: if `jsonString` does
+     * not contain valid JSON.
+     *
+     * @throws {@link DittoError} `validation/not-an-object`: if `jsonString` does
+     * not contain an object.
+     *
+     * @throws {@link DittoError} `validation/size-limit-exceeded`: if the size
+     *  limit for `jsonString` has been exceeded.
+     *
+     * @see {@link peerMetadataJSONString | peerMetadataJSONString()} for details
+     * on usage of metadata.
+     */
+    async setPeerMetadataJSONString(jsonString) {
+        const dittoHandle = Bridge.ditto.handleFor(this.ditto);
+        await this.ditto.deferClose(() => {
+            return mapFFIErrorsAsync(async () => {
+                await presenceTrySetPeerMetadataJSON(dittoHandle.deref(), jsonString);
+            });
+        });
+    }
+    /**
+     * This is a convenience property that wraps
+     * {@link peerMetadataJSONString | peerMetadataJSONString()}.
+     *
+     * @see {@link peerMetadataJSONString | peerMetadataJSONString()} for details.
+     */
+    get peerMetadata() {
+        return JSON.parse(this.peerMetadataJSONString);
+    }
+    /**
+     * This is a convenience method that wraps
+     * {@link setPeerMetadataJSONString | setPeerMetadataJSONString()}.
+     *
+     * @throws {@link DittoError} `validation/not-an-object`: if `peerMetadata` is
+     * not an object.
+     *
+     * @throws {@link DittoError} `validation/not-json-compatible`: if
+     * `peerMetadata` is not JSON serializable.
+     *
+     * @throws {@link DittoError} `validation/size-limit-exceeded`: if the size
+     *  limit for `peerMetadata` has been exceeded.
+     *
+     * @see {@link setPeerMetadataJSONString | setPeerMetadataJSONString()} for
+     * details.
+     */
+    async setPeerMetadata(peerMetadata) {
+        let jsonString;
+        try {
+            jsonString = JSON.stringify(peerMetadata);
+        }
+        catch (error) {
+            throw new DittoError('validation/not-json-compatible', `Failed encoding peer metadata to JSON. ${error}`);
+        }
+        await this.setPeerMetadataJSONString(jsonString);
+    }
     /**
      * Request information about Ditto peers in range of this device.
      *
@@ -8001,8 +8348,10 @@ class Presence {
         didChangeHandler(this.graph);
         return observer;
     }
+    // -----------------------------------------------------------------------------
     /** @internal */
     constructor(ditto) {
+        this._connectionRequestHandler = null;
         this.ditto = ditto;
         this.observerManager = new ObserverManager('PresenceObservation', {
             keepAlive: ditto.keepAlive,
@@ -8440,10 +8789,9 @@ class Sync {
                 throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`);
             }
         }
-        const errorContext = { query, queryArguments };
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
         this.ditto.deferClose(() => {
-            mapFFIErrors(() => tryExperimentalAddDQLSubscription(dittoHandle.deref(), query, queryArgumentsCBOR), undefined, errorContext);
+            mapFFIErrors(() => tryAddSyncSubscription(dittoHandle.deref(), query, queryArgumentsCBOR));
         });
         const subscription = new SyncSubscription(this.ditto, query, queryArguments || null, queryArgumentsCBOR);
         // @ts-expect-error modifying readonly property
@@ -8513,7 +8861,7 @@ class Sync {
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
         this.ditto.deferClose(() => {
             // prettier-ignore
-            mapFFIErrors(() => tryExperimentalRemoveDQLSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR));
+            mapFFIErrors(() => tryRemoveSyncSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR));
         });
         return true;
     }
@@ -9086,7 +9434,7 @@ class SmallPeerInfo {
      *
      * - Must be a JSON object (not an array, string, number, etc.)
      * - The size when encoded as JSON must be less than 128 KB
-     * - May only be nested up to 2 levels deep
+     * - May only be nested up to 64 levels deep
      *
      * @example <caption>Valid metadata</caption>
      * ditto.smallPeerInfo.metadata = {
@@ -9096,17 +9444,6 @@ class SmallPeerInfo {
      *   }
      * }
      *
-     * @example <caption>Invalid metadata</caption>
-     * // This is invalid and results in an error.
-     * ditto.smallPeerInfo.metadata = {
-     *   "foo": "bar",
-     *   "nested": {
-     *     "illegal": {
-     *       "inner": "value"
-     *     }
-     *   }
-     * }
-     *
      * @throws when set to a value that violates any of the constraints listed
      * above.
      */
@@ -9191,6 +9528,27 @@ class Ditto {
         // Requires having called FFI.initSDKVersion() first.
         return dittoGetSDKSemver();
     }
+    /**
+     * Configure a custom identifier for this peer.
+     *
+     * When using {@link Presence.observe | presence.observe()}, each remote peer
+     * is represented by a short UTF-8 "device name". By default this will be a
+     * truncated version of the device's hostname.
+     *
+     * Changes to this property after {@link startSync | startSync()} was called
+     * will only take effect after the next restart of sync. The value does not
+     * need to be unique among peers. Device names longer than 24 bytes will be
+     * truncated once {@link startSync | startSync()} is called.
+     */
+    get deviceName() {
+        return this._deviceName;
+    }
+    set deviceName(value) {
+        if (this.isSyncActive) {
+            Logger.warning('Changes to the device name take effect when sync is restarted.');
+        }
+        this._deviceName = value;
+    }
     /** Returns a string identifying the version of the Ditto SDK. */
     get sdkVersion() {
         const dittoHandle = Bridge.ditto.handleFor(this);
@@ -9274,7 +9632,7 @@ class Ditto {
         // Check if device name stays the same on sdk and core levels (#10729).
         {
             const os = require('os');
-            this.deviceName = os.hostname();
+            this._deviceName = os.hostname();
         }
         this.keepAlive = new KeepAlive();
         // WORKAROUND: the login provider triggers the registered callback right
@@ -9538,24 +9896,15 @@ class Ditto {
      *
      * @param licenseToken the license token to activate the `Ditto` instance
      * with. You can find yours on the [Ditto portal](https://portal.ditto.live).
-     *
-     * @throws {Error} if called in a React Native environment.
      */
     setOfflineOnlyLicenseToken(licenseToken) {
-        {
-            if (IdentityTypesRequiringOfflineLicenseToken.includes(this.identity.type)) {
-                const { result, errorMessage } = verifyLicense(licenseToken);
-                if (result !== 'LicenseOk') {
-                    this._isActivated = false;
-                    throw new Error(errorMessage);
-                }
-                else {
-                    this._isActivated = true;
-                }
-            }
-            else {
-                throw new Error('Offline license tokens should only be used for manual, sharedKey or offlinePlayground identities');
-            }
+        if (IdentityTypesRequiringOfflineLicenseToken.includes(this.identity.type)) {
+            this._isActivated = false;
+            mapFFIErrors(() => tryVerifyLicense(licenseToken));
+            this._isActivated = true;
+        }
+        else {
+            Logger.error(`The identity type '${this.identity.type}' does not require an offline license token.`);
         }
     }
     /**
@@ -9862,7 +10211,7 @@ class Ditto {
             const isX509Valid = this.isX509Valid;
             const identity = this.identity;
             const transportConfig = this.transportConfig;
-            dittoSetDeviceName(dittoHandle.deref(), this.deviceName);
+            this._deviceName = dittoSetDeviceName(dittoHandle.deref(), this.deviceName);
             this.sync.update({ identity, transportConfig, isWebValid, isX509Valid, isSyncActive: !!flag, ditto: this });
         });
     }
@@ -10056,8 +10405,8 @@ class QueryResultItem {
      * method once and keep it for as long as needed.
      */
     cborData() {
-        const resultHandle = Bridge.dqlResult.handleFor(this);
-        return dqlResultCBOR(resultHandle.deref());
+        const resultItemHandle = Bridge.queryResultItem.handleFor(this);
+        return queryResultItemCBOR(resultItemHandle.deref());
     }
     /**
      * Returns the content of the item as a JSON string.
@@ -10066,8 +10415,8 @@ class QueryResultItem {
      * method once and keep it for as long as needed.
      */
     jsonString() {
-        const resultHandle = Bridge.dqlResult.handleFor(this);
-        return dqlResultJSON(resultHandle.deref());
+        const resultItemHandle = Bridge.queryResultItem.handleFor(this);
+        return queryResultItemJSON(resultItemHandle.deref());
     }
     // ----------------------------------------------------------- Internal ------
     /**
@@ -10132,9 +10481,10 @@ class WebsocketClient {
 // bridges, because anything that would require a certain bridge would
 // immediately require the bridged type, oftentimes leading to an import cycle.
 Bridge.attachment.registerType(Attachment);
+Bridge.connectionRequest.registerType(ConnectionRequest);
 Bridge.document.registerType(Document);
-Bridge.dqlResult.registerType(QueryResultItem);
-Bridge.dqlResponse.registerType(QueryResult);
+Bridge.queryResultItem.registerType(QueryResultItem);
+Bridge.queryResult.registerType(QueryResult);
 Bridge.mutableDocument.registerType(MutableDocument);
 Bridge.staticTCPClient.registerType(StaticTCPClient);
 Bridge.websocketClient.registerType(WebsocketClient);
@@ -10149,6 +10499,7 @@ exports.BasePendingIDSpecificOperation = BasePendingIDSpecificOperation;
 exports.CBOR = CBOR;
 exports.Collection = Collection;
 exports.CollectionsEvent = CollectionsEvent;
+exports.ConnectionRequest = ConnectionRequest;
 exports.Counter = Counter;
 exports.Ditto = Ditto;
 exports.DittoError = DittoError;