polystore 0.11.1 → 0.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "A small compatibility layer for many popular KV stores like localStorage, Redis, FileSystem, etc.",
   "homepage": "https://polystore.dev/",
   "repository": "https://github.com/franciscop/polystore.git",
@@ -16,7 +16,7 @@
   "scripts": {
     "size": "echo $(gzip -c src/index.js | wc -c) bytes",
     "start": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch --coverage --detectOpenHandles",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --ci --watchAll=false --detectOpenHandles && check-dts src/index.types.ts"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --ci --watchAll=false --detectOpenHandles && check-dts test/index.types.ts"
   },
   "keywords": [
     "kv",
@@ -54,11 +54,8 @@
   "jest": {
     "testEnvironment": "jsdom",
     "setupFiles": [
-      "./src/test/setup.js"
+      "./test/setup.js"
     ],
-    "transform": {},
-    "modulePathIgnorePatterns": [
-      "src/test/"
-    ]
+    "transform": {}
   }
 }

package/src/index.js

@@ -1,12 +1,6 @@
-/**
- * A number, or a string containing a number.
- * @typedef {(number|string|object|array)} Value
- */
-
 import clients from "./clients/index.js";
 import { createId, isClass, parse } from "./utils.js";
 
-// #region Store
 class Store {
   PREFIX = "";
 
@@ -21,7 +15,6 @@ class Store {
     });
   }
 
-  // #region #client()
   #find(store) {
     // Already a fully compliant KV store
     if (store instanceof Store) return store.client;
@@ -41,7 +34,6 @@ class Store {
     return store;
   }
 
-  // #region #validate()
   #validate(client) {
     if (!client.set || !client.get || !client.iterate) {
       throw new Error(
@@ -93,21 +85,6 @@ class Store {
     return false;
   }
 
-  // #region .add()
-  /**
-   * Save the data on an autogenerated key, can add expiration as well:
-   *
-   * ```js
-   * const key1 = await store.add("value1");
-   * const key2 = await store.add({ hello: "world" });
-   * const key3 = await store.add("value3", { expires: "1h" });
-   * ```
-   *
-   * **[→ Full .add() Docs](https://polystore.dev/documentation#add)**
-   * @param {Value} value
-   * @param {{ expires: string }} options
-   * @returns {Promise<string>}
-   */
   async add(value, options = {}) {
     await this.promise;
     const expires = parse(options.expire ?? options.expires);
@@ -130,22 +107,6 @@ class Store {
     return id; // The plain one without the prefix
   }
 
-  // #region .set()
-  /**
-   * Save the data on the given key, can add expiration as well:
-   *
-   * ```js
-   * const key = await store.set("key1", "value1");
-   * await store.set("key2", { hello: "world" });
-   * await store.set("key3", "value3", { expires: "1h" });
-   * ```
-   *
-   * **[→ Full .set() Docs](https://polystore.dev/documentation#set)**
-   * @param {string} key
-   * @param {Value} value
-   * @param {{ expires: string }} options
-   * @returns {Promise<string>}
-   */
   async set(key, value, options = {}) {
     await this.promise;
     const id = this.PREFIX + key;
@@ -168,23 +129,6 @@ class Store {
     return key;
   }
 
-  // #region .get()
-  /**
-   * Read a single value from the KV store:
-   *
-   * ```js
-   * const value1 = await store.get("key1");
-   * // null (doesn't exist or has expired)
-   * const value2 = await store.get("key2");
-   * // "value2"
-   * const value3 = await store.get("key3");
-   * // { hello: "world" }
-   * ```
-   *
-   * **[→ Full .get() Docs](https://polystore.dev/documentation#get)**
-   * @param {string} key
-   * @returns {Promise<Value>}
-   */
   async get(key) {
     await this.promise;
     const id = this.PREFIX + key;
@@ -202,26 +146,6 @@ class Store {
     return data.value;
   }
 
-  // #region .has()
-  /**
-   * Check whether a key exists or not:
-   *
-   * ```js
-   * if (await store.has("key1")) { ... }
-   * ```
-   *
-   * If you are going to use the value, it's better to just read it:
-   *
-   * ```js
-   * const val = await store.get("key1");
-   * if (val) { ... }
-   * ```
-   *
-   *
-   * **[→ Full .has() Docs](https://polystore.dev/documentation#has)**
-   * @param {string} key
-   * @returns {Promise<boolean>}
-   */
   async has(key) {
     await this.promise;
     const id = this.PREFIX + key;
@@ -234,18 +158,6 @@ class Store {
     return value !== null;
   }
 
-  // #region .del()
-  /**
-   * Remove a single key and its value from the store:
-   *
-   * ```js
-   * const key = await store.del("key1");
-   * ```
-   *
-   * **[→ Full .del() Docs](https://polystore.dev/documentation#del)**
-   * @param {string} key
-   * @returns {Promise<string>}
-   */
   async del(key) {
     await this.promise;
     const id = this.PREFIX + key;
@@ -272,33 +184,19 @@ class Store {
     }
   }
 
-  // #region .entries()
-  /**
-   * Return an array of the entries, in the [key, value] format:
-   *
-   * ```js
-   * const entries = await store.entries();
-   * // [["key1", "value1"], ["key2", { hello: "world" }], ...]
-   *
-   * // To limit it to a given prefix, use `.prefix()`:
-   * const sessions = await store.prefix("session:").entries();
-   * ```
-   *
-   * **[→ Full .entries() Docs](https://polystore.dev/documentation#entries)**
-   * @returns {Promise<[string, Value][]>}
-   */
   async entries() {
     await this.promise;
 
+    // Cut the key to size
+    const trim = (key) => key.slice(this.PREFIX.length);
+
     let list = [];
     if (this.client.entries) {
-      list = (await this.client.entries(this.PREFIX)).map(([key, value]) => [
-        key.slice(this.PREFIX.length),
-        value,
-      ]);
+      const entries = await this.client.entries(this.PREFIX);
+      list = entries.map(([key, value]) => [trim(key), value]);
     } else {
       for await (const [key, value] of this.client.iterate(this.PREFIX)) {
-        list.push([key.slice(this.PREFIX.length), value]);
+        list.push([trim(key), value]);
       }
     }
 
@@ -312,21 +210,6 @@ class Store {
       .map(([key, data]) => [key, data.value]);
   }
 
-  // #region .keys()
-  /**
-   * Return an array of the keys in the store:
-   *
-   * ```js
-   * const keys = await store.keys();
-   * // ["key1", "key2", ...]
-   *
-   * // To limit it to a given prefix, use `.prefix()`:
-   * const sessions = await store.prefix("session:").keys();
-   * ```
-   *
-   * **[→ Full .keys() Docs](https://polystore.dev/documentation#keys)**
-   * @returns {Promise<string[]>}
-   */
   async keys() {
     await this.promise;
 
@@ -340,21 +223,6 @@ class Store {
     return entries.map((e) => e[0]);
   }
 
-  // #region .values()
-  /**
-   * Return an array of the values in the store:
-   *
-   * ```js
-   * const values = await store.values();
-   * // ["value1", { hello: "world" }, ...]
-   *
-   * // To limit it to a given prefix, use `.prefix()`:
-   * const sessions = await store.prefix("session:").values();
-   * ```
-   *
-   * **[→ Full .values() Docs](https://polystore.dev/documentation#values)**
-   * @returns {Promise<Value[]>}
-   */
   async values() {
     await this.promise;
 
@@ -370,21 +238,6 @@ class Store {
     return entries.map((e) => e[1]);
   }
 
-  // #region .all()
-  /**
-   * Return an object with the keys:values in the store:
-   *
-   * ```js
-   * const obj = await store.all();
-   * // { key1: "value1", key2: { hello: "world" }, ... }
-   *
-   * // To limit it to a given prefix, use `.prefix()`:
-   * const sessions = await store.prefix("session:").all();
-   * ```
-   *
-   * **[→ Full .all() Docs](https://polystore.dev/documentation#all)**
-   * @returns {Promise<{ [key:string]: Value }>}
-   */
   async all() {
     await this.promise;
 
@@ -402,19 +255,6 @@ class Store {
     return Object.fromEntries(entries);
   }
 
-  // #region .clear()
-  /**
-   * Delete all of the records of the store:
-   *
-   * ```js
-   * await store.clear();
-   * ```
-   *
-   * It's useful for cache invalidation, clearing the data, and testing.
-   *
-   * **[→ Full .clear() Docs](https://polystore.dev/documentation#clear)**
-   * @returns {Promise<null>}
-   */
   async clear() {
     await this.promise;
 
@@ -427,23 +267,6 @@ class Store {
     await Promise.all(keys.map((key) => this.del(key)));
   }
 
-  // #region .prefix()
-  /**
-   * Create a substore where all the keys are stored with
-   * the given prefix:
-   *
-   * ```js
-   * const session = store.prefix("session:");
-   * await session.set("key1", "value1");
-   * console.log(await session.entries());  // session.
-   * // [["key1", "value1"]]
-   * console.log(await store.entries());  // store.
-   * // [["session:key1", "value1"]]
-   * ```
-   *
-   * **[→ Full .prefix() Docs](https://polystore.dev/documentation#prefix)**
-   * @returns {Store}
-   */
   prefix(prefix = "") {
     const store = new Store(
       Promise.resolve(this.promise).then((client) => client || this.client)
@@ -452,19 +275,6 @@ class Store {
     return store;
   }
 
-  // #region .close()
-  /**
-   * Stop the connection to the store, if any:
-   *
-   * ```js
-   * await session.set("key1", "value1");
-   * await store.close();
-   * await session.set("key2", "value2");  // error
-   * ```
-   *
-   * **[→ Full .close() Docs](https://polystore.dev/documentation#close)**
-   * @returns {Store}
-   */
   async close() {
     await this.promise;
 

package/src/index.test.js

@@ -1,631 +0,0 @@
-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 "./index.js";
-import customFull from "./test/customFull.js";
-import customSimple from "./test/customSimple.js";
-
-const stores = [];
-stores.push(["kv()", kv()]);
-stores.push(["kv(new Map())", kv(new Map())]);
-stores.push(["kv(localStorage)", kv(localStorage)]);
-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())]);
-}
-if (process.env.ETCD) {
-  // Note: need to add to .env "ETCD=true" and run `etcd` in the terminal
-  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() {}
-  *iterate() {}
-}
-
-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 .iterate()",
-    });
-  });
-
-  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) {
-  describe(name, () => {
-    beforeEach(async () => {
-      await store.clear();
-    });
-
-    afterAll(async () => {
-      await store.clear();
-      await store.close();
-    });
-
-    it("can perform a CRUD", async () => {
-      expect(await store.get("a")).toBe(null);
-      expect(await store.has("a")).toBe(false);
-      expect(await store.set("a", "b")).toBe("a");
-      expect(await store.has("a")).toBe(true);
-      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 () => {
-      expect(await store.get("a")).toBe(null);
-      expect(await store.has("a")).toBe(false);
-    });
-
-    it("can add() arbitrary values", async () => {
-      const key = await store.add("b");
-      expect(typeof key).toBe("string");
-      expect(await store.get(key)).toBe("b");
-      expect(await store.has(key)).toBe(true);
-      expect(key.length).toBe(24);
-      expect(key).toMatch(/^[a-zA-Z0-9]{24}$/);
-    });
-
-    it("can store values", async () => {
-      const key = await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-      expect(await store.has("a")).toBe(true);
-      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);
-      await store.set("a", "b");
-      expect(await store.get("a")).toEqual("b");
-      await store.set("a", true);
-      expect(await store.get("a")).toEqual(true);
-    });
-
-    it("can store arrays of JSON values", async () => {
-      await store.set("a", ["b", "c"]);
-      expect(await store.get("a")).toEqual(["b", "c"]);
-      expect(await store.has("a")).toBe(true);
-    });
-
-    it("can store objects", async () => {
-      await store.set("a", { b: "c" });
-      expect(await store.get("a")).toEqual({ b: "c" });
-      expect(await store.has("a")).toBe(true);
-    });
-
-    it("can get the keys", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.keys()).toEqual(["a", "c"]);
-    });
-
-    it("can get the values", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.values()).toEqual(["b", "d"]);
-    });
-
-    it("can get the entries", async () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.entries()).toEqual([
-        ["a", "b"],
-        ["c", "d"],
-      ]);
-    });
-
-    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");
-      await store.set("b:0", "b0");
-      await store.set("a:2", "a2");
-      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 () => {
-      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.prefix("a:").values()).sort()).toEqual([
-        "a0",
-        "a1",
-        "a2",
-      ]);
-    });
-
-    it("can get the entries 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.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"],
-      ]);
-    });
-
-    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.prefix("a:").all()).toEqual({
-        0: "a0",
-        1: "a1",
-        2: "a2",
-      });
-    });
-
-    it("can get the keys 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.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 () => {
-      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.prefix("a-").values()).sort()).toEqual([
-        "a0",
-        "a1",
-        "a2",
-      ]);
-    });
-
-    it("can get the entries 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.prefix("a-").entries()).sort()).toEqual([
-        ["0", "a0"],
-        ["1", "a1"],
-        ["2", "a2"],
-      ]);
-    });
-
-    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.prefix("a-").all()).toEqual({
-        0: "a0",
-        1: "a1",
-        2: "a2",
-      });
-    });
-
-    it("can delete the data", async () => {
-      await store.set("a", "b");
-      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 () => {
-      await store.set("a", "b");
-      await store.set("c", "d");
-      expect(await store.get("a")).toBe("b");
-      await store.clear();
-      expect(await store.get("a")).toBe(null);
-      await store.set("a", "b");
-      expect(await store.get("a")).toBe("b");
-    });
-
-    describe("iteration", () => {
-      beforeEach(async () => {
-        await store.clear();
-      });
-
-      it("supports raw iteration", async () => {
-        await store.set("a", "b");
-        await store.set("c", "d");
-
-        const entries = [];
-        for await (const entry of store) {
-          entries.push(entry);
-        }
-        expect(entries).toEqual([
-          ["a", "b"],
-          ["c", "d"],
-        ]);
-      });
-
-      it("supports raw prefix iteration", async () => {
-        await store.set("a:a", "b");
-        await store.set("b:a", "d");
-        await store.set("a:c", "d");
-        await store.set("b:c", "d");
-
-        const entries = [];
-        for await (const entry of store.prefix("a:")) {
-          entries.push(entry);
-        }
-        expect(entries.sort()).toEqual([
-          ["a", "b"],
-          ["c", "d"],
-        ]);
-      });
-    });
-
-    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);
-        expect(await store.has("a")).toBe(false);
-        expect(await store.keys()).toEqual([]);
-        expect(await store.values()).toEqual([]);
-        expect(await store.entries()).toEqual([]);
-      });
-
-      it("expires = potato means undefined = forever", async () => {
-        await store.set("a", "b", { expires: "potato" });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = 5potato means undefined = forever", async () => {
-        await store.set("a", "b", { expires: "5potato" });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = null means never to expire it", async () => {
-        await store.set("a", "b", { expires: null });
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      it("expires = undefined means never to expire it", async () => {
-        await store.set("a", "b");
-        expect(await store.get("a")).toBe("b");
-        await delay(100);
-        expect(await store.get("a")).toBe("b");
-      });
-
-      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("checks the has properly", async () => {
-        expect(await session.has("a")).toBe(false);
-        await session.set("a", "b");
-        expect(await session.has("a")).toBe(true);
-      });
-
-      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

@@ -1,18 +0,0 @@
-import kv from "..";
-
-const store = kv();
-
-(async () => {
-  await store.get("key");
-  await store.set("key", "value");
-  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" });
-  console.log(key1, key2, key3);
-  if (await store.has("key")) {
-  }
-})();

package/src/test/customFull.js

@@ -1,45 +0,0 @@
-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];
-  }
-
-  *iterate(prefix) {
-    const entries = this.entries(prefix);
-    for (const entry of entries) {
-      yield entry;
-    }
-  }
-
-  // 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

@@ -1,27 +0,0 @@
-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
-  *iterate(prefix) {
-    const raw = Object.entries(dataSource);
-    const entries = prefix
-      ? raw.filter(([key, value]) => key.startsWith(prefix))
-      : raw;
-    for (const entry of entries) {
-      yield entry;
-    }
-  }
-}

package/src/test/data.json

@@ -1 +0,0 @@
-{}

package/src/test/setup.js

@@ -1,23 +0,0 @@
-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
-if (typeof TextEncoder === "undefined") {
-  Object.defineProperty(window, "TextEncoder", {
-    writable: true,
-    value: util.TextEncoder,
-  });
-}
-if (typeof TextDecoder === "undefined") {
-  Object.defineProperty(window, "TextDecoder", {
-    writable: true,
-    value: util.TextDecoder,
-  });
-}
-
-if (typeof setImmediate === "undefined") {
-  Object.defineProperty(window, "setImmediate", {
-    writable: true,
-    value: (cb) => setTimeout(cb, 0),
-  });
-}