Implement getting nested dictionaries in Mixed.

packages/realm/bindgen/js_opt_in_spec.yml

@@ -246,6 +246,7 @@ classes:
       - make_ssl_verify_callback
       - get_mixed_type
       - get_mixed_element_type
+      - get_mixed_element_type_from_dict
 
   LogCategoryRef:
     methods:
@@ -317,6 +318,7 @@ classes:
       - get_obj
       - get_any
       - get_list
+      - get_dictionary
       - sort_by_names
       - snapshot
       - max

packages/realm/src/Dictionary.ts

@@ -15,6 +15,7 @@
 // limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////
+
 import {
   AssertionError,
   Collection,
@@ -41,14 +42,23 @@ export type DictionaryChangeSet = {
 };
 export type DictionaryChangeCallback = (dictionary: Dictionary, changes: DictionaryChangeSet) => void;
 
+/**
+ * Helpers for getting and setting dictionary entries, as well as
+ * converting the values to and from their binding representations.
+ * @internal
+ */
+export type DictionaryHelpers = TypeHelpers & {
+  get?(dictionary: binding.Dictionary, key: string): unknown;
+};
+
 const DEFAULT_PROPERTY_DESCRIPTOR: PropertyDescriptor = { configurable: true, enumerable: true };
 const PROXY_HANDLER: ProxyHandler<Dictionary> = {
   get(target, prop, receiver) {
     const value = Reflect.get(target, prop, receiver);
     if (typeof value === "undefined" && typeof prop === "string") {
       const internal = target[INTERNAL];
-      const fromBinding = target[HELPERS].fromBinding;
-      return fromBinding(internal.tryGetAny(prop));
+      const { get: customGet, fromBinding } = target[HELPERS];
+      return fromBinding(customGet ? customGet(internal, prop) : internal.tryGetAny(prop));
     } else {
       return value;
     }
@@ -111,7 +121,7 @@ export class Dictionary<T = unknown> extends Collection<string, T, [string, T],
    * Create a `Results` wrapping a set of query `Results` from the binding.
    * @internal
    */
-  constructor(realm: Realm, internal: binding.Dictionary, helpers: TypeHelpers) {
+  constructor(realm: Realm, internal: binding.Dictionary, helpers: DictionaryHelpers) {
     if (arguments.length === 0 || !(internal instanceof binding.Dictionary)) {
       throw new IllegalConstructorError("Dictionary");
     }
@@ -182,7 +192,7 @@ export class Dictionary<T = unknown> extends Collection<string, T, [string, T],
   private declare [INTERNAL]: binding.Dictionary;
 
   /** @internal */
-  private declare [HELPERS]: TypeHelpers;
+  private declare [HELPERS]: DictionaryHelpers;
 
   /** @ts-expect-error We're exposing methods in the end-users namespace of keys */
   [key: string]: T;

packages/realm/src/OrderedCollection.ts

@@ -56,7 +56,11 @@ export type CollectionChangeCallback<T = unknown, EntryType extends [unknown, un
   changes: CollectionChangeSet,
 ) => void;
 
-/** @internal */
+/**
+ * Helpers for getting and setting ordered collection items, as well
+ * as converting the values to and from their binding representations.
+ * @internal
+ */
 export type OrderedCollectionHelpers = TypeHelpers & {
   get(results: binding.Results, index: number): unknown;
 };

packages/realm/src/TypeHelpers.ts

@@ -21,6 +21,7 @@ import {
   ClassHelpers,
   Collection,
   Dictionary,
+  DictionaryHelpers,
   INTERNAL,
   List,
   ObjCreator,
@@ -168,19 +169,15 @@ function mixedFromBinding(options: TypeOptions, value: binding.MixedArg): unknow
     const { wrapObject } = getClassHelpers(value.tableKey);
     return wrapObject(linkedObj);
   } else if (value instanceof binding.List) {
-    return new List(realm, value, getCollectionHelpersForMixed(realm, options));
+    return new List(realm, value, getListHelpersForMixed(realm, options));
   } else if (value instanceof binding.Dictionary) {
-    const typeHelpers: TypeHelpers<Realm.Mixed> = {
-      toBinding: mixedToBinding.bind(null, realm.internal),
-      fromBinding: mixedFromBinding.bind(null, options),
-    };
-    return new Dictionary(realm, value, typeHelpers);
+    return new Dictionary(realm, value, getDictionaryHelpersForMixed(realm, options));
   } else {
     return value;
   }
 }
 
-function getCollectionHelpersForMixed(realm: Realm, options: TypeOptions) {
+function getListHelpersForMixed(realm: Realm, options: TypeOptions) {
   const helpers: OrderedCollectionHelpers = {
     toBinding: mixedToBinding.bind(null, realm.internal),
     fromBinding: mixedFromBinding.bind(null, options),
@@ -190,14 +187,32 @@ function getCollectionHelpersForMixed(realm: Realm, options: TypeOptions) {
         return new List(realm, results.getList(index), helpers);
       }
       if (elementType === binding.MixedDataType.Dictionary) {
-        // TODO
+        return new Dictionary(realm, results.getDictionary(index), getDictionaryHelpersForMixed(realm, options));
       }
       return results.getAny(index);
     },
   };
   return helpers;
 }
 
+function getDictionaryHelpersForMixed(realm: Realm, options: TypeOptions) {
+  const helpers: DictionaryHelpers = {
+    toBinding: mixedToBinding.bind(null, realm.internal),
+    fromBinding: mixedFromBinding.bind(null, options),
+    get(dictionary: binding.Dictionary, key: string) {
+      const elementType = binding.Helpers.getMixedElementTypeFromDict(dictionary, key);
+      if (elementType === binding.MixedDataType.List) {
+        return new List(realm, dictionary.getList(key), getListHelpersForMixed(realm, options));
+      }
+      if (elementType === binding.MixedDataType.Dictionary) {
+        return new Dictionary(realm, dictionary.getDictionary(key), helpers);
+      }
+      return dictionary.tryGetAny(key);
+    },
+  };
+  return helpers;
+}
+
 function defaultToBinding(value: unknown): binding.MixedArg {
   return value as binding.MixedArg;
 }