Fix concurrent addition errors with position

Author: julienmalard

src/utils.ts

@@ -31,12 +31,12 @@ export const getScalePosition = async ({
   const afterPosition = entries[Math.max(position, 0)]?.position;
 
   // Insert to beginning of list if there is no preceding entry
+  // Note: use Math.random() rather than mean to reduce risk of collisions in concurrent edits
   if (beforePosition === undefined)
-    return afterPosition === undefined ? 0 : afterPosition - 1;
+    return (afterPosition === undefined ? Math.random() : afterPosition - Math.random());
 
   // Insert to end of list if there is no following entry, or somewhere between adjacent entries
-  // Note: use Math.random() rather than mean to reduce risk of collisions in concurrent edits
   return afterPosition === undefined
-    ? beforePosition + 1
+    ? beforePosition + 1 * Math.random()
     : beforePosition + (afterPosition - beforePosition) * Math.random();
 };

test/ordered-keyvalue.spec.ts

@@ -8,6 +8,7 @@ import { DBElements } from "@/types.js";
 import { createTestHelia } from "./config.js";
 import { isBrowser } from "wherearewe";
 import { expect } from "aegir/chai";
+import { sortPosition } from "./utils.js";
 
 const keysPath = "./testkeys";
 
@@ -368,6 +369,21 @@ describe("OrderedKeyValue Database", () => {
       ]);
     });
 
+    it("synchronous addition", async () => {
+      await Promise.all(
+        [...Array(2).keys()].map((i) => db.put(`key${i}`, `value${i}`)),
+      );
+      const hash = await db.put("in", "between", 1);
+
+      const actual = await db.all();
+
+      // Here we only check the middle value, because we don't know if key0 or key1 was 
+      // added first due to the race condition we intentionally introduced above
+      expect(actual[1]).to.deep.equal(
+        { value: "between", key: "in", hash },
+      );
+    })
+
     it("returns all values", async () => {
       const keyvalue: {
         value: DBElements;
@@ -421,7 +437,7 @@ describe("OrderedKeyValue Database", () => {
         all.unshift(pair);
       }
 
-      expect(all).to.deep.equal(keyvalue);
+      expect(sortPosition(all)).to.deep.equal(sortPosition(keyvalue));
     });
   });
 

test/utils.ts

@@ -0,0 +1,7 @@
+export const sortPosition = <T>(array: (T & { position: number})[]): T[] => {
+  const sorted = array.toSorted((a, b) => a.position - b.position)
+  return sorted.map(x=>{
+    delete (x as T & { position?: number})["position"]
+    return x
+  })
+}