polystore 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.6.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

@@ -1,4 +1,4 @@
-# Polystore [![npm install polystore](https://img.shields.io/badge/npm%20install-polystore-blue.svg)](https://www.npmjs.com/package/polystore) [![test badge](https://github.com/franciscop/polystore/workflows/tests/badge.svg "test badge")](https://github.com/franciscop/polystore/blob/master/.github/workflows/tests.yml) [![gzip size](https://img.badgesize.io/franciscop/polystore/master/src/index.js.svg?compression=gzip)](https://github.com/franciscop/polystore/blob/master/src/index.js)
+# Polystore [![npm install polystore](https://img.shields.io/badge/npm%20install-polystore-blue.svg)](https://www.npmjs.com/package/polystore) [![test badge](https://github.com/franciscop/polystore/workflows/tests/badge.svg "test badge")](https://github.com/franciscop/polystore/blob/master/.github/workflows/tests.yml) [![gzip size](https://badgen.net/bundlephobia/minzip/polystore?label=gzip&color=green)](https://github.com/franciscop/polystore/blob/master/src/index.js)
 
 A small compatibility layer for many KV stores like localStorage, Redis, FileSystem, etc:
 
@@ -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

@@ -49,6 +49,10 @@ layers.extra = (store) => {
   const add = async (value, options) => store.set(generateId(), value, options);
   const has = async (key) => (await store.get(key)) !== null;
   const del = async (key) => store.set(key, null);
+  const all = async (prefix = "") => {
+    const entries = await store.entries(prefix);
+    return Object.fromEntries(entries);
+  };
   const keys = async (prefix = "") => {
     const all = await store.entries(prefix);
     return all.map((p) => p[0]);
@@ -57,7 +61,7 @@ layers.extra = (store) => {
     const all = await store.entries(prefix);
     return all.map((p) => p[1]);
   };
-  return { add, has, del, keys, values, ...store };
+  return { add, has, del, keys, values, all, ...store };
 };
 
 // Adds an expiration layer to those stores that don't have it;
@@ -381,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

@@ -104,6 +104,15 @@ for (let [name, store] of stores) {
       ]);
     });
 
+    it("can get the all object", async () => {
+      await store.set("a", "b");
+      await store.set("c", "d");
+      expect(await store.all()).toEqual({
+        a: "b",
+        c: "d",
+      });
+    });
+
     it("can get the keys with a colon prefix", async () => {
       await store.set("a:0", "a0");
       await store.set("a:1", "a1");
@@ -132,6 +141,18 @@ for (let [name, store] of stores) {
       ]);
     });
 
+    it("can get the all object with a colon prefix", async () => {
+      await store.set("a:0", "a0");
+      await store.set("a:1", "a1");
+      await store.set("b:0", "b0");
+      await store.set("a:2", "a2");
+      expect(await store.all("a:")).toEqual({
+        "a:0": "a0",
+        "a:1": "a1",
+        "a:2": "a2",
+      });
+    });
+
     it("can get the keys with a dash prefix", async () => {
       await store.set("a-0", "a0");
       await store.set("a-1", "a1");
@@ -160,6 +181,18 @@ for (let [name, store] of stores) {
       ]);
     });
 
+    it("can get the all object with a dash prefix", async () => {
+      await store.set("a-0", "a0");
+      await store.set("a-1", "a1");
+      await store.set("b-0", "b0");
+      await store.set("a-2", "a2");
+      expect(await store.all("a-")).toEqual({
+        "a-0": "a0",
+        "a-1": "a1",
+        "a-2": "a2",
+      });
+    });
+
     it("can delete the data", async () => {
       await store.set("a", "b");
       expect(await store.get("a")).toBe("b");
@@ -259,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"]);
+      });
+    });
   });
 }