polystore 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A small compatibility layer for many popular KV stores like localStorage, Redis, FileSystem, etc.",
   "homepage": "https://github.com/franciscop/polystore",
   "repository": "https://github.com/franciscop/polystore.git",

package/readme.md

@@ -22,6 +22,7 @@ This is the [API](#api) with all of the methods (they are all `async`):
 - `.entries(prefix?): [string, any][]`: get a list of all the key-value pairs in the store.
 - `.clear()`: delete ALL of the data in the store, effectively resetting it.
 - `.close()`: (only _some_ stores) ends the connection to the store.
+- `.prefix(prefix): store`: create a new sub-instance of the store where all the keys have this prefix.
 
 Available stores:
 
@@ -224,9 +225,9 @@ Remove all of the data from the store:
 await store.clear();
 ```
 
-### .prefix() (TODO) (unstable)
+### .prefix() (unstable)
 
-Create a sub-store where all the operations use the given prefix:
+Create a sub-store where all the operations use the given prefix. This is **the only method** of the store that is sync and you don't need to await:
 
 ```js
 const store = kv(new Map());
@@ -248,8 +249,13 @@ await session.clear(); // delete only keys with the prefix
 This will probably never be stable given the nature of some engines, so as an alternative please consider using two stores instead of prefixes:
 
 ```js
+// Two in-memory stores
 const store = kv(new Map());
 const session = kv(new Map());
+
+// Two file-stores
+const users = kv(new URL(`file://${import.meta.dirname}/users.json`));
+const books = kv(new URL(`file://${import.meta.dirname}/books.json`));
 ```
 
 The main reason this is not stable is because [_some_ store engines don't allow for atomic deletion of keys given a prefix](https://stackoverflow.com/q/4006324/938236). While we do still clear them internally in those cases, that is a non-atomic operation and it could have some trouble if some other thread is reading/writing the data _at the same time_.
@@ -359,6 +365,7 @@ const store = kv(new URL("file:///Users/me/project/cache.json"));
 // Paths need to be absolute, but you can use process.cwd() to make
 // it relative to the current process:
 const store = kv(new URL(`file://${process.cwd()}/cache.json`));
+const store2 = kv(new URL(`file://${import.meta.dirname}/data.json`));
 ```
 
 ### Cloudflare KV

package/src/index.js

@@ -385,6 +385,39 @@ export default function compat(storeClient = new Map()) {
     {},
     {
       get: (instance, key) => {
+        if (key === "prefix") {
+          const store = compat(storeClient);
+          return (prefix) => ({
+            get: (key) => store.get(prefix + key),
+            set: async (key, value, opts) => {
+              const id = await store.set(prefix + key, value, opts);
+              return id.slice(prefix.length);
+            },
+            add: async (value, opts) => {
+              const id = await store.set(prefix + generateId(), value, opts);
+              return id.slice(prefix.length);
+            },
+            has: (key) => store.has(prefix + key),
+            del: (key) => store.del(prefix + key),
+
+            keys: async (next = "") => {
+              const keys = await store.keys(prefix + next);
+              return keys.map((k) => k.slice(prefix.length));
+            },
+            values: (next = "") => store.values(prefix + next),
+            entries: async (next = "") => {
+              const entries = await store.entries(prefix + next);
+              return entries.map(([k, v]) => [k.slice(prefix.length), v]);
+            },
+
+            clear: async () => {
+              const keys = await store.keys(prefix);
+              await Promise.all(keys.map((key) => store.del(key)));
+            },
+            close: () => store.close(),
+          });
+        }
+
         return async (...args) => {
           // Only once, even if called twice in succession, since the
           // second time will go straight to the await

package/src/index.test.js

@@ -292,5 +292,61 @@ for (let [name, store] of stores) {
         });
       }
     });
+
+    describe(".prefix()", () => {
+      const session = store.prefix("session:");
+
+      it("has all the methods", () => {
+        expect(Object.keys(session)).toEqual([
+          "get",
+          "set",
+          "add",
+          "has",
+          "del",
+          "keys",
+          "values",
+          "entries",
+          "clear",
+          "close",
+        ]);
+      });
+
+      it("can write/read one", async () => {
+        const id = await session.set("a", "b");
+        expect(id).toBe("a");
+        expect(await session.get("a")).toBe("b");
+        expect(await store.get("session:a")).toBe("b");
+      });
+
+      it("can add with the prefix", async () => {
+        const id = await session.add("b");
+        expect(id.length).toBe(24);
+        expect(id).not.toMatch(/^session\:/);
+
+        const keys = await store.keys();
+        expect(keys[0]).toMatch(/^session\:/);
+      });
+
+      it("the group operations return the proper values", async () => {
+        await session.set("a", "b");
+
+        expect(await session.keys()).toEqual(["a"]);
+        expect(await session.values()).toEqual(["b"]);
+        expect(await session.entries()).toEqual([["a", "b"]]);
+
+        expect(await store.keys()).toEqual(["session:a"]);
+        expect(await store.values()).toEqual(["b"]);
+        expect(await store.entries()).toEqual([["session:a", "b"]]);
+      });
+
+      it("clears only the substore", async () => {
+        await store.set("a", "b");
+        await session.set("c", "d");
+
+        expect((await store.keys()).sort()).toEqual(["a", "session:c"]);
+        await session.clear();
+        expect(await store.keys()).toEqual(["a"]);
+      });
+    });
   });
 }