insert a nested non-object value

Author: julienmalard

src/nested.ts

@@ -15,6 +15,7 @@ import type {
   NestedValue,
   NestedValueWithUndefined,
   PossiblyNestedValue,
+  PossiblyNestedValueWithUndefined,
 } from "./types";
 import {
   flatten,
@@ -139,20 +140,20 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
 
   type InsertFunction = {
     (object: NestedValueWithUndefined): Promise<string>;
-    (key: NestedKey, object: NestedValueWithUndefined): Promise<string>;
+    (key: NestedKey, object: PossiblyNestedValueWithUndefined): Promise<string>;
   };
 
   const insert: InsertFunction = async (
     keyOrObject,
-    object?: NestedValueWithUndefined | undefined,
+    object?: Exclude<PossiblyNestedValueWithUndefined, undefined>,
   ): Promise<string> => {
     if (isNestedKey(keyOrObject)) {
       const joinedRootKey =
         typeof keyOrObject === "string" ? keyOrObject : joinKey(keyOrObject);
       return await addOperation({
         op: "INSERT",
         key: joinedRootKey,
-        value: removeUndefineds(object!),
+        value: isNestedValue(object) ? removeUndefineds(object) : object!,
       });
     } else {
       return await addOperation({
@@ -201,14 +202,18 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
       const { op, key, value } = entry.payload;
 
       if (op === "INSERT") {
-        if (typeof value !== "object" || !isNestedValue(value)) continue;
-        const flattenedEntries = flatten(value).map((entry) => ({
-          key: key === null ? entry.key : `${key}/${entry.key}`,
-          value: entry.value,
-        }));
         const hash = entry.hash;
-        for (const flat of flattenedEntries) {
-          yield* processEntry({ key: flat.key, value: flat.value, hash });
+        if (isNestedValue(value)) {
+          const flattenedEntries = flatten(value).map((entry) => ({
+            key: key === null ? entry.key : `${key}/${entry.key}`,
+            value: entry.value,
+          }));
+          for (const flat of flattenedEntries) {
+            yield* processEntry({ key: flat.key, value: flat.value, hash });
+          }
+        } else {
+          if (!key) continue;
+          yield* processEntry({ key, value, hash });
         }
       }
 

src/types.ts

@@ -13,3 +13,6 @@ export type NestedValue<T = DagCborEncodable> = {
 export type NestedValueWithUndefined = NestedValue<
   DagCborEncodable | undefined
 >;
+export type PossiblyNestedValueWithUndefined = PossiblyNestedValue<
+  DagCborEncodable | undefined
+>;

src/utils.ts

@@ -54,7 +54,9 @@ export const isSisterKey = (key1: NestedKey, key2: NestedKey): boolean => {
   return true;
 };
 
-export const isNestedValue = (x: PossiblyNestedValue): x is NestedValue => {
+export const isNestedValue = <T>(
+  x: PossiblyNestedValue<T>,
+): x is NestedValue<T> => {
   return (
     typeof x === "object" &&
     !Array.isArray(x) &&

test/nested.spec.ts

@@ -234,6 +234,14 @@ describe("Nested Database", () => {
       expect(actual).to.deep.equal({ b: 1, c: 3 });
     });
 
+    it("insert a nested non-object value", async () => {
+      await db.insert(["a", "b"], 1);
+      await db.insert(["a", "c"], 2);
+
+      const actual = await db.all();
+      expect(actual).to.deep.equal({ a: { b: 1, c: 2 } });
+    });
+
     it("insert nested value containing undefined", async () => {
       await db.insert("a", { b: 2, c: undefined });