Merge pull request #56 from DominikZajac/get-document-metadata

fix: collection_getDocument returns only metadata

Author: azaddhirajkumar

android/src/main/java/com/cblreactnative/CblReactnativeModule.kt

@@ -20,7 +20,7 @@ import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-
+import org.json.JSONObject
 
 @OptIn(DelicateCoroutinesApi::class)
 @Suppress("FunctionName")
@@ -370,26 +370,55 @@ class CblReactnativeModule(reactContext: ReactApplicationContext) :
     scopeName: String,
     collectionName: String,
     promise: Promise
-  ){
+) {
     GlobalScope.launch(Dispatchers.IO) {
-      try {
-        if (!DataValidation.validateCollection(collectionName, scopeName, name, promise) ||
-          !DataValidation.validateDocumentId(docId, promise)
-        ) {
-          return@launch
-        }
-        val doc = CollectionManager.getDocument(docId, collectionName, scopeName, name)
-        val docMap = DataAdapter.documentToMap(doc)
-        context.runOnUiQueueThread {
-          promise.resolve(docMap)
-        }
-      } catch (e: Throwable) {
-        context.runOnUiQueueThread {
-          promise.reject("DOCUMENT_ERROR", e.message)
+        try {
+            if (!DataValidation.validateCollection(collectionName, scopeName, name, promise) ||
+                !DataValidation.validateDocumentId(docId, promise)
+            ) {
+                return@launch
+            }
+
+            val doc = CollectionManager.getDocument(docId, collectionName, scopeName, name)
+            if (doc == null) {
+                context.runOnUiQueueThread {
+                    promise.resolve(Arguments.createMap()) 
+                }
+                return@launch
+            }
+
+            val documentJson = doc.toJSON()
+            if (!documentJson.isNullOrEmpty()) {
+                try {
+                    val test = JSONObject(documentJson)
+                    val map = DataAdapter.jsonObjectToMap(test)
+                    val documentMap = Arguments.makeNativeMap(map)
+                    val writableMap = Arguments.createMap()
+                    writableMap.putMap("_data", documentMap)
+
+                    writableMap.putString("_id", doc.id)
+                    writableMap.putDouble("_sequence", doc.sequence.toDouble())
+
+                    context.runOnUiQueueThread {
+                        promise.resolve(writableMap)
+                    }
+                } catch (e: Exception) {
+                    context.runOnUiQueueThread {
+                        promise.reject("DOCUMENT_ERROR", "Failed to parse document JSON: ${e.message}")
+                    }
+                }
+            } else {
+                context.runOnUiQueueThread {
+                    promise.resolve(Arguments.createMap()) 
+                }
+            }
+        } catch (e: Throwable) {
+            context.runOnUiQueueThread {
+                promise.reject("DOCUMENT_ERROR", e.message)
+            }
         }
-      }
     }
-  }
+}
 
   @ReactMethod
   fun collection_GetDocumentExpiration(

android/src/main/java/com/cblreactnative/DataAdapter.kt

@@ -55,45 +55,6 @@ object DataAdapter {
     return format.format(date)
   }
 
-  /**
-   * Converts a `Document` to a `WritableMap`.
-   *
-   * This function is used to adapt a Couchbase Lite `Document` to a `WritableMap` that can be
-   * used in React Native to send to Javascript via the Native Bridge. It iterates through the entries
-   * of the provided `Document` and converts any nested maps that represent blobs into their properties.
-   * A developer needing the blob would need to manually call the Collection `getBlobContent` method.
-   *
-   * @param document The `Document` to be converted. If the document is `null`, an empty `WritableMap` is returned.
-   * @return A `WritableMap` representation of the provided `Document`.
-   * @throws Exception If there is an error during the conversion.
-   */
-  @Throws(Exception::class)
-  fun documentToMap(document: Document?): WritableMap {
-    if (document == null) {
-      return Arguments.createMap()
-    }
-    val map = document.toMap()
-    //fix blob - only return properties, to get the content they will have to call getBlobContent
-    for (key in map.keys) {
-      val itemValue = map[key]
-      if (itemValue is Blob) {
-        document.getBlob(key)?.let { blob ->
-          val properties = blob.properties.toMutableMap()
-          val raw = blob.content?.toTypedArray()
-          properties["raw"] = raw
-          map[key] = properties
-        }
-      }
-    }
-    map.remove("sequence")
-    val resultsMap = Arguments.createMap()
-    val documentMap: WritableMap = Arguments.makeNativeMap(map)
-    resultsMap.putString("_id", document.id)
-    resultsMap.putDouble("_sequence", document.sequence.toDouble())
-    resultsMap.putMap("_data", documentMap)
-    return resultsMap
-  }
-
   /**
    * Converts an integer value to a `MaintenanceType` enum.
    *
@@ -584,4 +545,54 @@ object DataAdapter {
     }
     return null
 }
+
+    /**
+     * Converts a `JSONObject` to a `Map<String, Any?>`.
+     *
+     * This function recursively converts a `JSONObject` into a Kotlin `Map<String, Any?>`.
+     * Nested `JSONObject` and `JSONArray` objects are also converted to `Map` and `List`, respectively.
+     *
+     * @param jsonObject The `JSONObject` to be converted.
+     * @return A `Map<String, Any?>` representation of the `JSONObject`.
+     */
+    fun jsonObjectToMap(jsonObject: JSONObject): Map<String, Any?> {
+        val map = mutableMapOf<String, Any?>()
+        val keys = jsonObject.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val value = jsonObject.get(key)
+            map[key] = when (value) {
+                is JSONObject -> jsonObjectToMap(value) 
+                is JSONArray -> jsonArrayToList(value) 
+                JSONObject.NULL -> null
+                else -> value
+            }
+        }
+        return map
+    }
+
+    /**
+     * Converts a `JSONArray` to a `List<Any?>`.
+     *
+     * This function recursively converts a `JSONArray` into a Kotlin `List<Any?>`.
+     * Nested `JSONObject` and `JSONArray` objects are also converted to `Map` and `List`, respectively.
+     *
+     * @param jsonArray The `JSONArray` to be converted.
+     * @return A `List<Any?>` representation of the `JSONArray`.
+     */
+    fun jsonArrayToList(jsonArray: JSONArray): List<Any?> {
+        val list = mutableListOf<Any?>()
+        for (i in 0 until jsonArray.length()) {
+            val value = jsonArray.get(i)
+            list.add(
+                when (value) {
+                    is JSONObject -> jsonObjectToMap(value) 
+                    is JSONArray -> jsonArrayToList(value) 
+                    JSONObject.NULL -> null
+                    else -> value
+                }
+            )
+        }
+        return list
+    }
 }

expo-example/cblite-js-tests

@@ -357,7 +357,7 @@ class CblReactnative: RCTEventEmitter {
     let (isError, args) = DataAdapter.shared.adaptCollectionArgs(name: name, collectionName: collectionName, scopeName: scopeName, reject: reject)
     let (isDocumentError, documentId) = DataAdapter.shared.adaptNonEmptyString(value: docId, propertyName: "docId", reject: reject)
     let (isKeyError, keyValue) = DataAdapter.shared.adaptNonEmptyString(value: key, propertyName: "key", reject: reject)
-    
+
     if isError || isDocumentError || isKeyError {
       return
     }
@@ -521,14 +521,21 @@ class CblReactnative: RCTEventEmitter {
           resolve(dict)
           return
         }
-        //convert document to map using shared library
         var data:[String: Any] = [:]
-        let documentMap = MapHelper.documentToMap(doc)
-        data["_data"] = documentMap
+        let documentJson = doc.toJSON()
+        if !documentJson.isEmpty {
+            guard let jsonData = documentJson.data(using: .utf8),
+                  let jsonDict = try JSONSerialization.jsonObject(with: jsonData, options: []) as? [String: Any] else {
+                reject("DOCUMENT_ERROR", "Failed to parse document JSON", nil)
+                return
+            }
+            data["_data"] = jsonDict
+        } else {
+            data["_data"] = [:]
+        }
         data["_id"] = documentId
         data["_sequence"] = doc.sequence
-        
-        //React Native requires NSDictionary - type cast it and return as NSDictionary instead
+
         let dict:NSDictionary = data as NSDictionary
         resolve(dict)
       } catch let error as NSError {