Fix ordering of root nodes

Author: julienmalard

src/nested.ts

@@ -21,11 +21,13 @@ import {
 } from "./types.js";
 import {
   asJoinedKey,
+  asSplitKey,
   flatten,
   isNestedKey,
   isNestedValue,
   isSisterKey,
   isSubkey,
+  parentKey,
   splitKey,
   toNested,
 } from "./utils.js";
@@ -103,31 +105,38 @@ Nested.type = type;
 export const NestedApi = ({ database }: { database: InternalDatabase }) => {
   const putEntry = async (
     key: NestedKey,
-    value: DagCborEncodable,
+    value?: DagCborEncodable,
     position?: number,
   ): Promise<string> => {
-    const entries = (await itAll(iterator())).filter((entry) =>
+    const entries = await itAll(iterator());
+    const sisterEntries = (entries).filter((entry) =>
       isSisterKey(entry.key, key),
     );
     key = asJoinedKey(key);
 
+    const parent = parentKey(key)
+    if (parent && !entries.find(e=>e.key === parent))
+      await putEntry(parent)
+
     // Avoid overwriting existing position; default to end of list
     let scaledPosition: number | undefined = undefined;
     if (position === undefined) {
-      scaledPosition = entries.find((e) => e.key === key)?.position;
+      scaledPosition = sisterEntries.find((e) => e.key === key)?.position;
     }
     if (scaledPosition === undefined) {
       scaledPosition = await getScalePosition({
-        entries,
+        entries: sisterEntries,
         key,
         position: position ?? -1,
       });
     }
 
+    const entryValue: {value?: DagCborEncodable, position: number} = { position: scaledPosition };
+    if (value !== undefined) entryValue.value = value
     return database.addOperation({
       op: "PUT",
       key,
-      value: { value, position: scaledPosition },
+      value: entryValue,
     });
   };
 
@@ -163,8 +172,10 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
       if (k === joinedKey || isSubkey(k, joinedKey))
         relevantKeyValues.push({ key: k, value });
     }
+
     let nested: PossiblyNestedValueMap | undefined =
       toNested(relevantKeyValues);
+
     for (const k of splitKey(joinedKey)) {
       try {
         nested = (nested as NestedValueMap).get(k);
@@ -287,7 +298,12 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
     for await (const entry of iterator()) {
       values.unshift(entry);
     }
-    const sorted = values.toSorted((a, b) => a.position - b.position);
+
+    const sorted = values.toSorted((a, b) => {
+      const lengthDif = asSplitKey(a.key).length - asSplitKey(b.key).length
+
+      return lengthDif || (a.position - b.position)
+    });
 
     return toNested(sorted);
   };

src/utils.ts

@@ -19,6 +19,12 @@ export const asSplitKey = (key: NestedKey): string[] =>
 export const asJoinedKey = (key: NestedKey): string =>
   typeof key === "string" ? key : joinKey(key);
 
+export const parentKey = (key: NestedKey): string | undefined => {
+  const keyComponents = asSplitKey(key);
+  if (keyComponents.length > 1) return asJoinedKey(keyComponents.slice(0, -1));
+  return undefined;
+}
+
 export const isSubkey = (subkey: string, key: string): boolean => {
   const subkeyComponents = splitKey(subkey);
   const keyComponents = splitKey(key);
@@ -102,7 +108,7 @@ export const flatten = (
 };
 
 export const toNested = (
-  x: { key: string; value: DagCborEncodable }[],
+  x: { key: string; value?: DagCborEncodable }[],
 ): NestedValueMap => {
   const nested = new Map<string, unknown>() as NestedValueMap;
 
@@ -118,8 +124,13 @@ export const toNested = (
     }
     const finalKeyComponent = keyComponents.pop();
     if (finalKeyComponent) {
-      const finalValue = isNestedValueObject(value) ? toMap(value) : value;
-      root.set(finalKeyComponent, finalValue as PossiblyNestedValueMap);
+      if (value === undefined) {
+        if (root.get(finalKeyComponent) === undefined)
+          root.set(finalKeyComponent, new Map())
+      } else {
+        const finalValue = (isNestedValueObject(value) ? toMap(value) : value);
+        root.set(finalKeyComponent, finalValue as PossiblyNestedValueMap);
+      }
     }
   }
   return nested;