polystore 0.7.0 → 0.9.0

package/src/index.test.js

@@ -1,9 +1,15 @@
 import "dotenv/config";
 
+import { jest } from "@jest/globals";
+import { EdgeKVNamespace as KVNamespace } from "edge-mock";
+import { Etcd3 } from "etcd3";
+import { Level } from "level";
 import localForage from "localforage";
 import { createClient } from "redis";
 
 import kv from "./";
+import customFull from "./test/customFull.js";
+import customSimple from "./test/customSimple.js";
 
 global.setImmediate = global.setImmediate || ((cb) => setTimeout(cb, 0));
 
@@ -15,17 +21,83 @@ stores.push(["kv(sessionStorage)", kv(sessionStorage)]);
 stores.push(["kv(localForage)", kv(localForage)]);
 const path = `file://${process.cwd()}/src/test/data.json`;
 stores.push([`kv(new URL("${path}"))`, kv(new URL(path))]);
+const path2 = `file://${process.cwd()}/src/test/data.json`;
+stores.push([`kv("${path2}")`, kv(path2)]);
+stores.push([`kv("cookie")`, kv("cookie")]);
+stores.push(["kv(new KVNamespace())", kv(new KVNamespace())]);
+stores.push([`kv(new Level("data"))`, kv(new Level("data"))]);
 if (process.env.REDIS) {
   stores.push(["kv(redis)", kv(createClient().connect())]);
 }
-stores.push(["kv('cookie')", kv("cookie")]);
+if (process.env.ETCD) {
+  stores.push(["kv(new Etcd3())", kv(new Etcd3())]);
+}
+
+stores.push(["kv(customSimple)", kv(customSimple)]);
+stores.push(["kv(customFull)", kv(customFull)]);
 
 const delay = (t) => new Promise((done) => setTimeout(done, t));
 
+class Base {
+  get() {}
+  set() {}
+  entries() {}
+}
+
+global.console = {
+  ...console,
+  warn: jest.fn(),
+};
+
 describe("potato", () => {
   it("a potato is not a valid store", async () => {
     await expect(() => kv("potato").get("any")).rejects.toThrow();
   });
+
+  it("an empty object is not a valid store", async () => {
+    await expect(() => kv({}).get("any")).rejects.toThrow({
+      message: "A client should have at least a .get(), .set() and .entries()",
+    });
+  });
+
+  it("cannot handle no EXPIRES + keys", async () => {
+    await expect(() =>
+      kv(
+        class extends Base {
+          has() {}
+        }
+      ).get("any")
+    ).rejects.toThrow({
+      message:
+        "You can only define client.has() when the client manages the expiration; otherwise please do NOT define .has() and let us manage it",
+    });
+  });
+
+  it("cannot handle no EXPIRES + keys", async () => {
+    await expect(() =>
+      kv(
+        class extends Base {
+          keys() {}
+        }
+      ).get("any")
+    ).rejects.toThrow({
+      message:
+        "You can only define client.keys() when the client manages the expiration; otherwise please do NOT define .keys() and let us manage them",
+    });
+  });
+
+  it("warns the user with no EXPIRES + .values()", async () => {
+    const warn = jest
+      .spyOn(console, "warn")
+      .mockImplementationOnce(() => "Hello");
+    await kv(
+      class extends Base {
+        values() {}
+      }
+    ).get("any");
+    expect(warn).toHaveBeenCalled(); // But at least we warn them
+    warn.mockClear();
+  });
 });
 
 for (let [name, store] of stores) {
@@ -36,9 +108,15 @@ for (let [name, store] of stores) {
 
     afterAll(async () => {
       await store.clear();
-      if (store.close) {
-        await store.close();
-      }
+      await store.close();
+    });
+
+    it("can perform a CRUD", async () => {
+      expect(await store.get("a")).toBe(null);
+      expect(await store.set("a", "b")).toBe("a");
+      expect(await store.get("a")).toBe("b");
+      expect(await store.del("a")).toBe("a");
+      expect(await store.get("a")).toBe(null);
     });
 
     it("is empty on the start", async () => {
@@ -62,6 +140,34 @@ for (let [name, store] of stores) {
       expect(key).toBe("a");
     });
 
+    it("can store values with a semicolon", async () => {
+      const key = await store.set("a", "b;c");
+      expect(await store.get("a")).toBe("b;c");
+      expect(await store.has("a")).toBe(true);
+      expect(key).toBe("a");
+    });
+
+    it("can store values with an equal", async () => {
+      const key = await store.set("a", "b=c");
+      expect(await store.get("a")).toBe("b=c");
+      expect(await store.has("a")).toBe(true);
+      expect(key).toBe("a");
+    });
+
+    it("can store values with a semicolon in the key", async () => {
+      const key = await store.set("a;b", "c");
+      expect(await store.get("a;b")).toBe("c");
+      expect(await store.has("a;b")).toBe(true);
+      expect(key).toBe("a;b");
+    });
+
+    it("can store values with an equal in the key", async () => {
+      const key = await store.set("a=b", "c");
+      expect(await store.get("a=b")).toBe("c");
+      expect(await store.has("a=b")).toBe(true);
+      expect(key).toBe("a=b");
+    });
+
     it("can store basic types", async () => {
       await store.set("a", 10);
       expect(await store.get("a")).toEqual(10);
@@ -118,7 +224,8 @@ for (let [name, store] of stores) {
       await store.set("a:1", "a1");
       await store.set("b:0", "b0");
       await store.set("a:2", "a2");
-      expect((await store.keys("a:")).sort()).toEqual(["a:0", "a:1", "a:2"]);
+      expect((await store.keys()).sort()).toEqual(["a:0", "a:1", "a:2", "b:0"]);
+      expect((await store.prefix("a:").keys()).sort()).toEqual(["0", "1", "2"]);
     });
 
     it("can get the values with a colon prefix", async () => {
@@ -126,7 +233,11 @@ for (let [name, store] of stores) {
       await store.set("a:1", "a1");
       await store.set("b:0", "b0");
       await store.set("a:2", "a2");
-      expect((await store.values("a:")).sort()).toEqual(["a0", "a1", "a2"]);
+      expect((await store.prefix("a:").values()).sort()).toEqual([
+        "a0",
+        "a1",
+        "a2",
+      ]);
     });
 
     it("can get the entries with a colon prefix", async () => {
@@ -134,10 +245,16 @@ for (let [name, store] of stores) {
       await store.set("a:1", "a1");
       await store.set("b:0", "b0");
       await store.set("a:2", "a2");
-      expect((await store.entries("a:")).sort()).toEqual([
+      expect((await store.entries()).sort()).toEqual([
         ["a:0", "a0"],
         ["a:1", "a1"],
         ["a:2", "a2"],
+        ["b:0", "b0"],
+      ]);
+      expect((await store.prefix("a:").entries()).sort()).toEqual([
+        ["0", "a0"],
+        ["1", "a1"],
+        ["2", "a2"],
       ]);
     });
 
@@ -146,10 +263,10 @@ for (let [name, store] of stores) {
       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",
+      expect(await store.prefix("a:").all()).toEqual({
+        0: "a0",
+        1: "a1",
+        2: "a2",
       });
     });
 
@@ -158,7 +275,8 @@ for (let [name, store] of stores) {
       await store.set("a-1", "a1");
       await store.set("b-0", "b0");
       await store.set("a-2", "a2");
-      expect((await store.keys("a-")).sort()).toEqual(["a-0", "a-1", "a-2"]);
+      expect((await store.keys()).sort()).toEqual(["a-0", "a-1", "a-2", "b-0"]);
+      expect((await store.prefix("a-").keys()).sort()).toEqual(["0", "1", "2"]);
     });
 
     it("can get the values with a dash prefix", async () => {
@@ -166,7 +284,11 @@ for (let [name, store] of stores) {
       await store.set("a-1", "a1");
       await store.set("b-0", "b0");
       await store.set("a-2", "a2");
-      expect((await store.values("a-")).sort()).toEqual(["a0", "a1", "a2"]);
+      expect((await store.prefix("a-").values()).sort()).toEqual([
+        "a0",
+        "a1",
+        "a2",
+      ]);
     });
 
     it("can get the entries with a dash prefix", async () => {
@@ -174,10 +296,10 @@ for (let [name, store] of stores) {
       await store.set("a-1", "a1");
       await store.set("b-0", "b0");
       await store.set("a-2", "a2");
-      expect((await store.entries("a-")).sort()).toEqual([
-        ["a-0", "a0"],
-        ["a-1", "a1"],
-        ["a-2", "a2"],
+      expect((await store.prefix("a-").entries()).sort()).toEqual([
+        ["0", "a0"],
+        ["1", "a1"],
+        ["2", "a2"],
       ]);
     });
 
@@ -186,10 +308,10 @@ for (let [name, store] of stores) {
       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",
+      expect(await store.prefix("a-").all()).toEqual({
+        0: "a0",
+        1: "a1",
+        2: "a2",
       });
     });
 
@@ -198,6 +320,15 @@ for (let [name, store] of stores) {
       expect(await store.get("a")).toBe("b");
       await store.del("a");
       expect(await store.get("a")).toBe(null);
+      expect(await store.keys()).toEqual([]);
+    });
+
+    it("can delete the data by setting it to null", async () => {
+      await store.set("a", "b");
+      expect(await store.get("a")).toBe("b");
+      await store.set("a", null);
+      expect(await store.get("a")).toBe(null);
+      expect(await store.keys()).toEqual([]);
     });
 
     it("can clear all the values", async () => {
@@ -211,6 +342,13 @@ for (let [name, store] of stores) {
     });
 
     describe("expires", () => {
+      // The mock implementation does NOT support expiration 😪
+      if (name === "kv(new KVNamespace())") return;
+
+      afterEach(() => {
+        jest.restoreAllMocks();
+      });
+
       it("expires = 0 means immediately", async () => {
         await store.set("a", "b", { expires: 0 });
         expect(await store.get("a")).toBe(null);
@@ -248,49 +386,203 @@ for (let [name, store] of stores) {
         expect(await store.get("a")).toBe("b");
       });
 
-      if (name !== "kv('cookie')" && name !== "kv(redis)") {
+      if (
+        name !== `kv("cookie")` &&
+        name !== `kv(redis)` &&
+        name !== `kv(new Etcd3())`
+      ) {
         it("can use 0.01 expire", async () => {
           // 10ms
           await store.set("a", "b", { expires: 0.01 });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(100);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 0.01s expire", async () => {
           await store.set("a", "b", { expires: "0.01s" });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(100);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 0.01seconds expire", async () => {
           await store.set("a", "b", { expires: "0.01seconds" });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(100);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 10ms expire", async () => {
           await store.set("a", "b", { expires: "10ms" });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(100);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
+
+        it("removes the expired key with .get()", async () => {
+          await store.set("a", "b", { expires: "10ms" });
+          const spy = jest.spyOn(store, "del");
+          expect(spy).not.toHaveBeenCalled();
+          await delay(100);
+          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
+          expect(await store.get("a")).toBe(null);
+          expect(spy).toHaveBeenCalled();
+        });
+
+        it("removes the expired key with .keys()", async () => {
+          await store.set("a", "b", { expires: "10ms" });
+          const spy = jest.spyOn(store, "del");
+          expect(spy).not.toHaveBeenCalled();
+          await delay(100);
+          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
+          expect(await store.keys()).toEqual([]);
+          expect(spy).toHaveBeenCalled();
+        });
+
+        it("CANNOT remove the expired key with .values()", async () => {
+          await store.set("a", "b", { expires: "10ms" });
+          const spy = jest.spyOn(store, "del");
+          expect(spy).not.toHaveBeenCalled();
+          await delay(100);
+          expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪
+          expect(await store.values()).toEqual([]);
+          if (!store.client.EXPIRES && store.client.values) {
+            expect(spy).not.toHaveBeenCalled(); // Nothing we can do 😪😪
+          } else {
+            expect(spy).toHaveBeenCalled();
+          }
+        });
       } else {
         it("can use 1 (second) expire", async () => {
           await store.set("a", "b", { expires: 1 });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(2000);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
         it("can use 1s expire", async () => {
           await store.set("a", "b", { expires: "1s" });
+          expect(await store.keys()).toEqual(["a"]);
+          expect(await store.values()).toEqual(["b"]);
           expect(await store.get("a")).toBe("b");
           await delay(2000);
+          expect(await store.keys()).toEqual([]);
+          expect(await store.values()).toEqual([]);
           expect(await store.get("a")).toBe(null);
         });
       }
     });
+
+    describe(".prefix()", () => {
+      let session;
+      beforeAll(() => {
+        session = store.prefix("session:");
+      });
+
+      it("has the same methods", () => {
+        expect(Object.keys(store)).toEqual(Object.keys(session));
+      });
+
+      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"]);
+      });
+    });
+
+    describe(".prefix().prefix()", () => {
+      let auth;
+      beforeAll(() => {
+        auth = store.prefix("session:").prefix("auth:");
+      });
+
+      it("can write/read one", async () => {
+        const id = await auth.set("a", "b");
+        expect(id).toBe("a");
+        expect(await auth.get("a")).toBe("b");
+        expect(await store.get("session:auth:a")).toBe("b");
+      });
+
+      it("can add with the prefix", async () => {
+        const id = await auth.add("b");
+        expect(id.length).toBe(24);
+        expect(id).not.toMatch(/^session\:/);
+
+        const keys = await store.keys();
+        expect(keys[0]).toMatch(/^session\:auth\:/);
+      });
+
+      it("the group operations return the proper values", async () => {
+        await auth.set("a", "b");
+
+        expect(await auth.keys()).toEqual(["a"]);
+        expect(await auth.values()).toEqual(["b"]);
+        expect(await auth.entries()).toEqual([["a", "b"]]);
+
+        expect(await store.keys()).toEqual(["session:auth:a"]);
+        expect(await store.values()).toEqual(["b"]);
+        expect(await store.entries()).toEqual([["session:auth:a", "b"]]);
+      });
+
+      it("clears only the substore", async () => {
+        await store.set("a", "b");
+        await auth.set("c", "d");
+
+        expect((await store.keys()).sort()).toEqual(["a", "session:auth:c"]);
+        await auth.clear();
+        expect(await store.keys()).toEqual(["a"]);
+      });
+    });
   });
 }

package/src/index.types.ts

@@ -8,6 +8,7 @@ const store = kv();
   await store.set("key", "value", {});
   await store.set("key", "value", { expires: 100 });
   await store.set("key", "value", { expires: "100s" });
+  await store.prefix("a:").prefix("b:").get("hello");
   const key1: string = await store.add("value");
   const key2: string = await store.add("value", { expires: 100 });
   const key3: string = await store.add("value", { expires: "100s" });

package/src/{index.d.ts → indexa.d.ts}

@@ -8,9 +8,11 @@ type Store = {
   has: (key: Key) => Promise<boolean>;
   del: (key: Key) => Promise<null>;
 
-  keys: (prefix?: string) => Promise<string[]>;
-  values: (prefix?: string) => Promise<any[]>;
-  entries: (prefix?: string) => Promise<[key: string, value: any][]>;
+  keys: () => Promise<string[]>;
+  values: () => Promise<any[]>;
+  entries: () => Promise<[key: string, value: any][]>;
+
+  prefix: (prefix: string) => Store;
 
   clear: () => Promise<null>;
   close?: () => Promise<null>;

package/src/test/customFull.js

@@ -0,0 +1,38 @@
+const dataSource = {};
+
+export default class MyClient {
+  get(key) {
+    return dataSource[key];
+  }
+
+  set(key, value) {
+    dataSource[key] = value;
+  }
+
+  add(prefix, value) {
+    const id = Math.random().toString(16).slice(2).padStart(24, "0");
+    this.set(prefix + id, value);
+    return id;
+  }
+
+  del(key) {
+    delete dataSource[key];
+  }
+
+  // Filter them by the prefix, note that `prefix` will always be a string
+  entries(prefix) {
+    const entries = Object.entries(dataSource);
+    if (!prefix) return entries;
+    return entries.filter(([key]) => key.startsWith(prefix));
+  }
+
+  values(prefix) {
+    const list = this.entries(prefix);
+    return list.map((e) => e[1]);
+  }
+
+  // Cannot have a keys() if it's an unamanaged store
+  // keys(prefix) {
+  //   // This should throw
+  // }
+}

package/src/test/customSimple.js

@@ -0,0 +1,23 @@
+const dataSource = {};
+
+export default class MyClient {
+  get(key) {
+    return dataSource[key];
+  }
+
+  // No need to stringify it or anything for a plain object storage
+  set(key, value) {
+    if (value === null) {
+      delete dataSource[key];
+    } else {
+      dataSource[key] = value;
+    }
+  }
+
+  // Filter them by the prefix, note that `prefix` will always be a string
+  entries(prefix) {
+    const entries = Object.entries(dataSource);
+    if (!prefix) return entries;
+    return entries.filter(([key, value]) => key.startsWith(prefix));
+  }
+}

package/src/test/setup.js

@@ -0,0 +1,12 @@
+import * as util from "util";
+
+// ref: https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
+// ref: https://github.com/jsdom/jsdom/issues/2524
+Object.defineProperty(window, "TextEncoder", {
+  writable: true,
+  value: util.TextEncoder,
+});
+Object.defineProperty(window, "TextDecoder", {
+  writable: true,
+  value: util.TextDecoder,
+});

package/src/utils.js

@@ -0,0 +1,44 @@
+const times = /(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/iu;
+
+parse.millisecond = parse.ms = 0.001;
+parse.second = parse.sec = parse.s = parse[""] = 1;
+parse.minute = parse.min = parse.m = parse.s * 60;
+parse.hour = parse.hr = parse.h = parse.m * 60;
+parse.day = parse.d = parse.h * 24;
+parse.week = parse.wk = parse.w = parse.d * 7;
+parse.year = parse.yr = parse.y = parse.d * 365.25;
+parse.month = parse.b = parse.y / 12;
+
+// Returns the time in milliseconds
+function parse(str) {
+  if (str === null || str === undefined) return null;
+  if (typeof str === "number") return str;
+  // ignore commas/placeholders
+  str = str.toLowerCase().replace(/[,_]/g, "");
+  let [_, value, units] = times.exec(str) || [];
+  if (!units) return null;
+  const unitValue = parse[units] || parse[units.replace(/s$/, "")];
+  if (!unitValue) return null;
+  const result = unitValue * parseFloat(value, 10);
+  return Math.abs(Math.round(result * 1000) / 1000);
+}
+
+// "nanoid" imported manually
+// Something about improved GZIP performance with this string
+const urlAlphabet =
+  "useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict";
+
+function createId() {
+  let size = 24;
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size));
+  while (size--) {
+    // Using the bitwise AND operator to "cap" the value of
+    // the random byte from 255 to 63, in that way we can make sure
+    // that the value will be a valid index for the "chars" string.
+    id += urlAlphabet[bytes[size] & 61];
+  }
+  return id;
+}
+
+export { parse, createId };