polystore 0.4.5 → 0.6.0

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "polystore",
-  "version": "0.4.5",
+  "version": "0.6.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",
   "bugs": "https://github.com/franciscop/polystore/issues",
   "funding": "https://www.paypal.me/franciscopresencia/19",
   "author": "Francisco Presencia <public@francisco.io> (https://francisco.io/)",
-  "main": "index.min.js",
-  "types": "index.d.ts",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "esbuild src/index.js --bundle --minify --sourcemap --outfile=index.min.js --format=esm",
-    "size": "echo $(gzip -c index.min.js | wc -c) bytes",
+    "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 --detectOpenHandles && check-dts"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles && check-dts src/index.types.ts"
   },
-  "keywords": [],
+  "keywords": [
+    "kv",
+    "store",
+    "polystore",
+    "key-value",
+    "key",
+    "value"
+  ],
   "license": "MIT",
   "devDependencies": {
     "check-dts": "^0.7.2",

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/index.min.js.svg?compression=gzip)](https://github.com/franciscop/polystore/blob/master/index.min.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://img.badgesize.io/franciscop/polystore/master/src/index.js.svg?compression=gzip)](https://github.com/franciscop/polystore/blob/master/src/index.js)
 
 A small compatibility layer for many KV stores like localStorage, Redis, FileSystem, etc:
 
@@ -14,9 +14,12 @@ This is the [API](#api) with all of the methods (they are all `async`):
 
 - `.get(key): any`: retrieve a single value, or `null` if it doesn't exist or is expired.
 - `.set(key, value, options?)`: save a single value, which can be anything that is serializable.
+- `.add(value, options?)`: same as with `.set()`, but auto-generate the key.
 - `.has(key): boolean`: check whether the key is in the store or not.
 - `.del(key)`: delete a single value from the store.
 - `.keys(prefix?): string[]`: get a list of all the available strings in the store.
+- `.values(prefix?): any[]`: get a list of all the values in the store.
+- `.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.
 
@@ -27,12 +30,12 @@ Available stores:
 - **Session Storage** `sessionStorage` (fe): persist the data in the browser's sessionStorage
 - **Cookies** `"cookie"` (fe): persist the data using cookies
 - **LocalForage** `localForage` (fe): persist the data on IndexedDB
-- **Redis Client** `redisClient` (be): persist the data in the Redis instance that you connect to
 - **FS File** `new URL('file:///...')` (be): store the data in a single JSON file
-- (WIP) **Cloudflare KV** `env.KV_NAMESPACE` (be): use Cloudflare's KV store
+- **Redis Client** `redisClient` (be): use the Redis instance that you connect to
+- **Cloudflare KV** `env.KV_NAMESPACE` (be): use Cloudflare's KV store
 - (WIP) **Consul KV** `new Consul()` (fe+be): use Hashicorp's Consul KV store (https://www.npmjs.com/package/consul#kv)
 
-I build this library to be used as a "building block" of other libraries, so that _your library_ can accept many cache stores effortlessly! It's isomorphic (Node.js and the Browser) and tiny (1~2KB). For example, let's say you create an API library, then you can accept the stores from your client:
+I made this library to be used as a "building block" of other libraries, so that _your library_ can accept many cache stores effortlessly! It's isomorphic (Node.js and the Browser) and tiny (~2KB). For example, let's say you create an API library, then you can accept the stores from your client:
 
 ```js
 import MyApi from "my-api";
@@ -91,47 +94,71 @@ If the value is returned, it can be a simple type like `boolean`, `string` or `n
 
 ### .set()
 
-Create or update a value in the store. Will return a promise that resolves when the value has been saved. The value needs to be serializable:
+Create or update a value in the store. Will return a promise that resolves with the key when the value has been saved. The value needs to be serializable:
 
 ```js
-await store.set(key: string, value: any, options?: { expire: number|string });
+await store.set(key: string, value: any, options?: { expires: number|string });
 
 await store.set("key1", "Hello World");
-await store.set("key2", ["my", "grocery", "list"], { expire: "1h" });
-await store.set("key3", { name: "Francisco" }, { expire: 60 * 60 * 1000  });
+await store.set("key2", ["my", "grocery", "list"], { expires: "1h" });
+await store.set("key3", { name: "Francisco" }, { expires: 60 * 60 * 1000  });
 ```
 
 The value can be a simple type like `boolean`, `string` or `number`, or it can be a plain Object or Array, or a combination of those. It **cannot** be a more complex or non-serializable values like a `Date()`, `Infinity`, `undefined` (casted to `null`), a `Symbol`, etc.
 
 - By default the keys _don't expire_.
-- Setting the `value` to `null`, or the `expire` to `0` is the equivalent of deleting the key+value.
-- Conversely, setting `expire` to `null` or `undefined` will make the value never to expire.
+- Setting the `value` to `null`, or the `expires` to `0` is the equivalent of deleting the key+value.
+- Conversely, setting `expires` to `null` or `undefined` will make the value never to expire.
 
-#### Expire
+#### Expires
 
-When the `expire` option is set, it can be a number (ms) or a string representing some time:
+When the `expires` option is set, it can be a number (**seconds**) or a string representing some time:
 
 ```js
 // Valid "expire" values:
 0 - expire immediately (AKA delete it)
-100 - expire after 100ms
-60 * 60 * 1000 - expire after 1h
-3_600_000 - expire after 1h
+0.1 - expire after 100ms*
+60 * 60 - expire after 1h
+3_600 - expire after 1h
 "10s" - expire after 10 seconds
 "2minutes" - expire after 2 minutes
 "5d" - expire after 5 days
 ```
 
+\* not all stores support sub-second expirations, notably Redis and Cookies don't, so it's safer to always use an integer or an amount larger than 1s
+
 These are all the units available:
 
 > "ms", "millisecond", "s", "sec", "second", "m", "min", "minute", "h", "hr", "hour", "d", "day", "w", "wk", "week", "b" (month), "month", "y", "yr", "year"
 
+### .add()
+
+Create a value in the store with a random key string. Will return a promise that resolves with the key when the value has been saved. The value needs to be serializable:
+
+```js
+const key:string = await store.add(value: any, options?: { expires: number|string });
+
+const key1 = await store.add("Hello World");
+const key2 = await store.add(["my", "grocery", "list"], { expires: "1h" });
+const key3 = await store.add({ name: "Francisco" }, { expires: 60 * 60 * 1000  });
+```
+
+The generated key is 24 AlphaNumeric characters (including upper and lower case) generated with random cryptography to make sure it's unguessable, high entropy and safe to use in most contexts like URLs, queries, etc. We use [`nanoid`](https://github.com/ai/nanoid/) with a custom dictionary, so you can check the entropy [in this dictionary](https://zelark.github.io/nano-id-cc/) by removing the "\_" and "-", and setting it to 24 characters.
+
+Here is the safety: "If you generate 1 million keys/second, it will take ~14 million years in order to have a 1% probability of at least one collision."
+
+> Note: please make sure to read the [`.set()`](#set) section for all the details, since `.set()` and `.add()` behave the same way except for the first argument.
+
 ### .has()
 
 Check whether the key is available in the store and not expired:
 
 ```js
 await store.has(key: string);
+
+if (await store.has('cookie-consent')) {
+  loadCookies();
+}
 ```
 
 ### .del()
@@ -150,6 +177,45 @@ Get all of the keys in the store, optionally filtered by a prefix:
 await store.keys(filter?: string);
 ```
 
+> We ensure that all of the keys returned by this method are _not_ expired, while discarding any potentially expired key. See [**expiration explained**](#expiration-explained) for more details.
+
+### .values()
+
+Get all of the values in the store, optionally filtered by a **key** prefix:
+
+```js
+await store.values(filter?: string);
+```
+
+This is useful specially when you already have the id/key within the value as an object, then you can just get a list of all of them:
+
+```js
+const sessions = await store.values("session:");
+// A list of all the sessions
+
+const companies = await store.values("company:");
+// A list of all the companies
+```
+
+> We ensure that all of the values returned by this method are _not_ expired, while discarding any potentially expired key. See [**expiration explained**](#expiration-explained) for more details.
+
+### .entries()
+
+Get all of the entries (key:value tuples) in the store, optionally filtered by a **key** prefix:
+
+```js
+await store.entries(filter?: string);
+```
+
+It is in a format that you can easily build an object out of it:
+
+```js
+const sessionEntries = await store.entries("session:");
+const sessions = Object.fromEntries(sessionEntries);
+```
+
+> We ensure that all of the entries returned by this method are _not_ expired, while discarding any potentially expired key. See [**expiration explained**](#expiration-explained) for more details.
+
 ### .clear()
 
 Remove all of the data from the store:
@@ -164,35 +230,33 @@ Create a sub-store where all the operations use the given prefix:
 
 ```js
 const store = kv(new Map());
-const sub = store.prefix("session:");
-
-const sub = kv(new Map(), { prefix: "session:" });
+const session = store.prefix("session:");
 ```
 
 Then all of the operations will be converted internally to add the prefix when reading, writing, etc:
 
 ```js
-const val = await sub.get("key1"); // .get('session:key1');
-await sub.set("key2", "some data"); // .set('session:key2', ...);
-const val = await sub.has("key3"); // .has('session:key3');
-await sub.del("key4"); // .del('session:key4');
-await sub.keys(); // .keys('session:');
+const val = await session.get("key1"); // .get('session:key1');
+await session.set("key2", "some data"); // .set('session:key2', ...);
+const val = await session.has("key3"); // .has('session:key3');
+await session.del("key4"); // .del('session:key4');
+await session.keys(); // .keys('session:');
 // ['key1', 'key2', ...]   Note no prefix here
-await sub.clear(); // delete only keys with the prefix
+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
 const store = kv(new Map());
-const sessionStore = kv(new Map());
+const session = kv(new Map());
 ```
 
 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_.
 
 ## Stores
 
-Accepts directly the store, or a promise that resolves into a store. All of the stores, including those that natively _don't_ support it, are enhanced with `Promises` and `expire` times, so they all work the same way.
+Accepts directly the store, or a promise that resolves into a store. All of the stores, including those that natively _don't_ support it, are enhanced with `Promises` and `expires` times, so they all work the same way.
 
 ### Memory
 
@@ -253,18 +317,18 @@ console.log(await store.get("key1"));
 
 It is fairly limited for how powerful cookies are, but in exchange it has the same API as any other method or KV store. It works with browser-side Cookies (no http-only).
 
-> Note: the cookie expire resolution is in the seconds. While it still expects you to pass the number of ms as with the other methods (or [a string like `1h`](#expire)), times shorter than 1 second like `expire: 200` (ms) don't make sense for this storage method and won't properly save them.
+> Note: the cookie expire resolution is in the seconds, so times shorter than 1 second like `expires: 0.02` (20 ms) don't make sense for this storage method and won't properly save them.
 
 ### Local Forage
 
-Supports localForage (with any driver it uses) so that you have a unified API. It also _adds_ the `expire` option to the setters!
+Supports localForage (with any driver it uses) so that you have a unified API. It also _adds_ the `expires` option to the setters!
 
 ```js
 import kv from "polystore";
 import localForage from "localforage";
 
 const store = kv(localForage);
-await store.set("key1", "Hello world", { expire: "1h" });
+await store.set("key1", "Hello world", { expires: "1h" });
 console.log(await store.get("key1"));
 ```
 
@@ -282,7 +346,7 @@ await store.set("key1", "Hello world");
 console.log(await store.get("key1"));
 ```
 
-> Note: the Redis client expire resolution is in the seconds. While it still expects you to pass the number of ms as with the other methods (or [a string like `1h`](#expire)), times shorter than 1 second like `expire: 200` (ms) don't make sense for this storage method and won't properly save them.
+> Note: the Redis client expire resolution is in the seconds, so times shorter than 1 second like `expires: 0.02` (20 ms) don't make sense for this storage method and won't properly save them.
 
 ### FS File
 
@@ -299,7 +363,88 @@ const store = kv(new URL(`file://${process.cwd()}/cache.json`));
 
 ### Cloudflare KV
 
+Supports the official Cloudflare's KV stores. Follow [the official guide](https://developers.cloudflare.com/kv/get-started/), then load it like this:
+
 ```js
 import kv from "polystore";
-// TODO
+
+export default {
+  async fetch(request, env, ctx) {
+    const store = kv(env.YOUR_KV_NAMESPACE);
+
+    await store.set("KEY", "VALUE");
+    const value = await store.get("KEY");
+
+    if (!value) {
+      return new Response("Value not found", { status: 404 });
+    }
+    return new Response(value);
+  },
+};
+```
+
+Why? The Cloudflare native KV store only accepts strings and has you manually calculating timeouts, but as usual with `polystore` you can set/get any serializable value and set the timeout in a familiar format:
+
+```js
+// GOOD - with polystore
+await store.set("user", { name: "Francisco" }, { expires: "2days" });
+
+// COMPLEX - With native Cloudflare KV
+const serialValue = JSON.stringify({ name: "Francisco" });
+const twoDaysInSeconds = 2 * 24 * 3600;
+await env.YOUR_KV_NAMESPACE.put("user", serialValue, {
+  expirationTtl: twoDaysInSeconds,
+});
+```
+
+## Expiration explained
+
+While different engines do expiration slightly differently internally, in creating polystore we want to ensure certain constrains, which _can_ affect performance. For example, if you do this operation:
+
+```js
+// in-memory store
+const store = polystore(new Map());
+await store.set("a", "b", { expires: "1s" });
+
+// These checks of course work:
+console.log(await store.keys()); // ['a']
+console.log(await store.has("a")); // true
+console.log(await store.get("a")); // 'b'
+
+// Make sure the key is expired
+await delay(2000); // 2s
+
+// Not only the .get() is null, but `.has()` returns false, and .keys() ignores it
+console.log(await store.keys()); // []
+console.log(await store.has("a")); // false
+console.log(await store.get("a")); // null
+```
+
+This is great because with polystore we do ensure that if a key has expired, it doesn't show up in `.keys()`, `.entries()`, `.values()`, `.has()` or `.get()`.
+
+However, in some stores this does come with some potential performance disadvantages. For example, both the in-memory example above and localStorage _don't_ have a native expiration/eviction process, so we have to store that information as metadata, meaning that even to check if a key exists we need to read and decode its value. For one or few keys it's not a problem, but for large sets this can become an issue.
+
+For other stores like Redis this is not a problem, because the low-level operations already do them natively, so we don't need to worry about this for performance at the user-level. Instead, Redis and cookies have the problem that they only have expiration resolution at the second level. Meaning that 800ms is not a valid Redis expiration time, it has to be 1s, 2s, etc.
+
+## Creating a store
+
+A store needs at least 4 methods with these signatures:
+
+```js
+const store = {};
+store.get = (key: string) => Promise<any>;
+store.set = (key: string, value: any, { expires: number }) => Promise<string>;
+store.entries = (prefix: string = "") => Promise<[key:string, value:any][]>;
+store.clear = () => Promise<null>;
+```
+
+All of the other methods will be implemented on top of these if not available, but you can provide those as well for optimizations, incompatible APIs, etc. For example, `.set('a', null)` _should_ delete the key `a`, and for this you may provide a native implementation:
+
+```js
+const native = myNativeStore();
+
+const store = {};
+store.get = (key) => native.getItem(key);
+// ...
+store.del = (key) => native.deleteItem(key);
 ```

package/src/index.d.ts

@@ -0,0 +1,19 @@
+type Key = string;
+type Options = { expires?: number | string | null };
+
+type Store = {
+  get: (key: Key) => Promise<any>;
+  add: (value: any, options?: Options) => Promise<Key>;
+  set: (key: Key, value: any, options?: Options) => Promise<Key>;
+  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][]>;
+
+  clear: () => Promise<null>;
+  close?: () => Promise<null>;
+};
+
+export default function (store?: any): Store;

package/src/index.js

@@ -2,8 +2,8 @@ const layers = {};
 
 const times = /(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/iu;
 
-parse.millisecond = parse.ms = 1;
-parse.second = parse.sec = parse.s = parse[""] = parse.ms * 1000;
+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;
@@ -22,135 +22,238 @@ function parse(str) {
   const unitValue = parse[units] || parse[units.replace(/s$/, "")];
   if (!unitValue) return null;
   const result = unitValue * parseFloat(value, 10);
-  return Math.abs(Math.round(result));
+  return Math.abs(Math.round(result * 1000) / 1000);
 }
 
+// "nanoid" imported manually
+// Something about improved GZIP performance with this string
+const urlAlphabet =
+  "useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict";
+
+export let random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+
+function generateId() {
+  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;
+}
+
+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 keys = async (prefix = "") => {
+    const all = await store.entries(prefix);
+    return all.map((p) => p[0]);
+  };
+  const values = async (prefix = "") => {
+    const all = await store.entries(prefix);
+    return all.map((p) => p[1]);
+  };
+  return { add, has, del, keys, values, ...store };
+};
+
+// Adds an expiration layer to those stores that don't have it;
+// it's not perfect since it's not deleted until it's read, but
+// hey it's better than nothing
 layers.expire = (store) => {
   // Item methods
   const get = async (key) => {
-    if (!(await store.has(key))) return null;
-    const { data, expire } = await store.get(key);
-    if (expire === null) return data;
+    const data = await store.get(key);
+    if (!data) return null;
+    const { value, expire } = data;
+    // It never expires
+    if (expire === null) return value;
     const diff = expire - new Date().getTime();
     if (diff <= 0) return null;
-    return data;
+    return value;
   };
-  const set = async (key, data, { expire = null } = {}) => {
-    const time = parse(expire);
-    const expDiff = time !== null ? new Date().getTime() + time : null;
-    return store.set(key, { expire: expDiff, data });
+  const set = async (key, value, { expire, expires } = {}) => {
+    const time = parse(expire || expires);
+    // Already expired, or do _not_ save it, then delete it
+    if (value === null || time === 0) return store.set(key, null);
+    const expDiff = time !== null ? new Date().getTime() + time * 1000 : null;
+    return store.set(key, { expire: expDiff, value });
   };
-  const has = async (key) => (await store.get(key)) !== null;
-  const del = store.del;
 
   // Group methods
-  const keys = store.keys;
-  const clear = store.clear;
+  const entries = async (prefix = "") => {
+    const all = await store.entries(prefix);
+    const now = new Date().getTime();
+    return all
+      .filter(([, data]) => {
+        // There's no data, so remove this
+        if (!data || data === null) return false;
+
+        // It never expires, so keep it
+        const { expire } = data;
+        if (expire === null) return true;
+
+        // It's expired, so remove it
+        if (expire - now <= 0) return false;
+
+        // It's not expired, keep it
+        return true;
+      })
+      .map(([key, data]) => [key, data.value]);
+  };
 
-  return { get, set, has, del, keys, clear };
+  // We want to force overwrite here!
+  return { ...store, get, set, entries };
 };
 
 layers.memory = (store) => {
   // Item methods
-  const get = async (key) => store.get(key) || null;
-  const set = async (key, data) => store.set(key, data);
-  const has = async (key) => store.has(key);
-  const del = async (key) => store.delete(key);
+  const get = async (key) => store.get(key) ?? null;
+  const set = async (key, data) => {
+    if (data === null) {
+      await store.delete(key);
+    } else {
+      await store.set(key, data);
+    }
+    return key;
+  };
 
   // Group methods
-  const keys = async (prefix = "") =>
-    [...(await store.keys())].filter((k) => k.startsWith(prefix));
+  const entries = async (prefix = "") => {
+    const entries = [...store.entries()];
+    return entries.filter((p) => p[0].startsWith(prefix));
+  };
   const clear = () => store.clear();
 
-  return { get, set, has, del, keys, clear };
+  return { get, set, entries, clear };
 };
 
 layers.storage = (store) => {
   // Item methods
   const get = async (key) => (store[key] ? JSON.parse(store[key]) : null);
-  const set = async (key, data) => store.setItem(key, JSON.stringify(data));
-  const has = async (key) => key in store;
-  const del = async (key) => store.removeItem(key);
+  const set = async (key, data) => {
+    if (data === null) {
+      await store.removeItem(key);
+    } else {
+      await store.setItem(key, JSON.stringify(data));
+    }
+    return key;
+  };
 
   // Group methods
-  const keys = async (prefix = "") =>
-    Object.keys(store).filter((k) => k.startsWith(prefix));
+  const entries = async (prefix = "") => {
+    const entries = Object.entries(store);
+    return entries
+      .map((p) => [p[0], p[1] ? JSON.parse(p[1]) : null])
+      .filter((p) => p[0].startsWith(prefix));
+  };
   const clear = () => store.clear();
 
-  return { get, set, has, del, keys, clear };
+  return { get, set, entries, clear };
 };
 
+// Cookies auto-expire, so we cannot do expiration checks manually
 layers.cookie = () => {
-  const get = async (key) => {
-    const value =
-      document.cookie
-        .split("; ")
-        .filter(Boolean)
-        .find((row) => row.startsWith(key + "="))
-        ?.split("=")[1] || null;
-    return JSON.parse(decodeURIComponent(value));
+  const getAll = () => {
+    const all = {};
+    for (let entry of document.cookie
+      .split(";")
+      .map((k) => k.trim())
+      .filter(Boolean)) {
+      const [key, data] = entry.split("=");
+      try {
+        all[key.trim()] = JSON.parse(decodeURIComponent(data.trim()));
+      } catch (error) {
+        // no-op (some 3rd party can set cookies independently)
+      }
+    }
+    return all;
   };
 
-  const set = async (key, data, { expire = null } = {}) => {
-    const time = parse(expire);
-    const now = new Date().getTime();
-    const expireStr =
-      time !== null ? `; expires=${new Date(now + time).toUTCString()}` : "";
-    const value = encodeURIComponent(JSON.stringify(data));
-    document.cookie = key + "=" + value + expireStr;
+  const get = async (key) => getAll()[key] ?? null;
+
+  const set = async (key, data, { expire, expires } = {}) => {
+    if (data === null) {
+      await set(key, "", { expire: -100 });
+    } else {
+      const time = parse(expire || expires);
+      const now = new Date().getTime();
+      // NOTE: 0 is already considered here!
+      const expireStr =
+        time !== null
+          ? `; expires=${new Date(now + time * 1000).toUTCString()}`
+          : "";
+      const value = encodeURIComponent(JSON.stringify(data));
+      document.cookie = key + "=" + value + expireStr;
+    }
+    return key;
   };
-  const has = async (key) => (await keys()).includes(key);
-  const del = async (key) => set(key, "", { expire: -100 });
 
   // Group methods
-  const keys = async (prefix = "") =>
-    document.cookie
-      .split(";")
-      .map((l) => l.split("=")[0].trim())
-      .filter(Boolean)
-      .filter((k) => k.startsWith(prefix));
+  const entries = async (prefix = "") => {
+    const all = Object.entries(getAll());
+    return all.filter((p) => p[0].startsWith(prefix));
+  };
+
   const clear = async () => {
-    await Promise.all((await keys()).map(del));
+    const keys = Object.keys(getAll());
+    await Promise.all(keys.map((key) => set(key, null)));
   };
 
-  return { get, set, has, del, keys, clear };
+  return { get, set, entries, clear };
 };
 
+// Plain 'redis' and not ioredis or similar
 layers.redis = (store) => {
   const get = async (key) => {
-    const client = await store;
-    const value = await client.get(key);
+    const value = await store.get(key);
     if (!value) return null;
     return JSON.parse(value);
   };
-  const set = async (key, value, { expire = null } = {}) => {
-    if (value === null || expire === 0) return del(key);
-    const client = await store;
-    const exp = parse(expire);
-    const EX = exp ? Math.round(exp / 1000) : undefined;
-    return client.set(key, JSON.stringify(value), { EX });
+  const set = async (key, value, { expire, expires } = {}) => {
+    const time = parse(expire || expires);
+    if (value === null || time === 0) return del(key);
+    const EX = time ? Math.round(time) : undefined;
+    await store.set(key, JSON.stringify(value), { EX });
+    return key;
   };
-  const has = async (key) => Boolean(await (await store).exists(key));
-  const del = async (key) => (await store).del(key);
-
-  const keys = async (prefix = "") => (await store).keys(prefix + "*");
-  const clear = async () => (await store).flushAll();
-  const close = async () => (await store).quit();
+  const has = async (key) => Boolean(await store.exists(key));
+  const del = async (key) => store.del(key);
+
+  const keys = async (prefix = "") => store.keys(prefix + "*");
+  const entries = async (prefix = "") => {
+    const keys = await store.keys(prefix + "*");
+    const values = await Promise.all(keys.map((k) => get(k)));
+    return keys.map((k, i) => [k, values[i]]);
+  };
+  const clear = async () => store.flushAll();
+  const close = async () => store.quit();
 
-  return { get, set, has, del, keys, clear, close };
+  return { get, set, has, del, keys, entries, clear, close };
 };
 
 layers.localForage = (store) => {
-  const get = (key) => store.getItem(key);
-  const set = (key, value) => store.setItem(key, value);
-  const has = async (key) => (await get(key)) !== null;
-  const del = (key) => store.removeItem(key);
-
-  const keys = async (prefix = "") =>
-    (await store.keys()).filter((k) => k.startsWith(prefix));
-  const clear = () => store.clear();
+  const get = async (key) => store.getItem(key);
+  const set = async (key, value) => {
+    if (value === null) {
+      await store.removeItem(key);
+    } else {
+      await store.setItem(key, value);
+    }
+    return key;
+  };
+  const entries = async (prefix = "") => {
+    const all = await store.keys();
+    const keys = all.filter((k) => k.startsWith(prefix));
+    const values = await Promise.all(keys.map((key) => store.getItem(key)));
+    return keys.map((key, i) => [key, values[i]]);
+  };
+  const clear = async () => store.clear();
 
-  return { get, set, has, del, keys, clear };
+  return { get, set, entries, clear };
 };
 
 layers.cloudflare = (store) => {
@@ -159,18 +262,29 @@ layers.cloudflare = (store) => {
     if (!data) return null;
     return JSON.parse(data);
   };
-  const set = async (key, value, { expire }) => {
-    if (value === null || expire === 0) return del(key);
+  const set = async (key, value, { expire, expires } = {}) => {
+    const time = parse(expire || expires);
+    if (value === null || time === 0) return del(key);
     const client = await store;
-    const exp = parse(expire);
-    const expirationTtl = exp ? Math.round(exp / 1000) : undefined;
-    return client.put(key, JSON.stringify(value), { expirationTtl });
+    const expirationTtl = time ? Math.round(time) : undefined;
+    client.put(key, JSON.stringify(value), { expirationTtl });
+    return key;
   };
   const has = async (key) => Boolean(await store.get(key));
   const del = (key) => store.delete(key);
-  const keys = (prefix) => store.list({ prefix });
+
+  // Group methods
+  const keys = async (prefix = "") => {
+    const raw = await store.list({ prefix });
+    return raw.keys;
+  };
+  const entries = async (prefix = "") => {
+    const all = await keys(prefix);
+    const values = await Promise.all(all.map((k) => get(k)));
+    return all.map((key, i) => [key, values[i]]);
+  };
   const clear = () => {};
-  return { get, set, has, del, keys, clear };
+  return { get, set, has, del, entries, keys, clear };
 };
 
 layers.file = (file) => {
@@ -202,57 +316,60 @@ layers.file = (file) => {
   };
   const set = async (key, value) => {
     const data = await getContent();
-    data[key] = value;
+    if (value === null) {
+      delete data[key];
+    } else {
+      data[key] = value;
+    }
     await setContent(data);
+    return key;
   };
   const has = async (key) => (await get(key)) !== null;
-  const del = async (key) => {
-    const data = await getContent();
-    delete data[key];
-    await setContent(data);
-  };
-  const keys = async (prefix = "") => {
+  const del = async (key) => set(key, null);
+
+  // Group methods
+  const entries = async (prefix = "") => {
     const data = await getContent();
-    return Object.keys(data).filter((k) => k.startsWith(prefix));
+    return Object.entries(data).filter((p) => p[0].startsWith(prefix));
   };
   const clear = async () => {
     await setContent({});
   };
-  return { get, set, has, del, keys, clear };
+  return { get, set, has, del, entries, clear };
 };
 
 const getStore = async (store) => {
   // Convert it to the normalized kv, then add the expiry layer on top
   if (store instanceof Map) {
-    return layers.expire(layers.memory(store));
+    return layers.extra(layers.expire(layers.memory(store)));
   }
 
   if (typeof localStorage !== "undefined" && store === localStorage) {
-    return layers.expire(layers.storage(store));
+    return layers.extra(layers.expire(layers.storage(store)));
   }
 
   if (typeof sessionStorage !== "undefined" && store === sessionStorage) {
-    return layers.expire(layers.storage(store));
+    return layers.extra(layers.expire(layers.storage(store)));
   }
 
   if (store === "cookie") {
-    return layers.cookie();
+    return layers.extra(layers.cookie());
   }
 
   if (store.defineDriver && store.dropInstance && store.INDEXEDDB) {
-    return layers.expire(layers.localForage(store));
+    return layers.extra(layers.expire(layers.localForage(store)));
   }
 
   if (store.protocol && store.protocol === "file:") {
-    return layers.expire(layers.file(store));
+    return layers.extra(layers.expire(layers.file(store)));
   }
 
   if (store.pSubscribe && store.sSubscribe) {
-    return layers.redis(store);
+    return layers.extra(layers.redis(store));
   }
 
   if (store?.constructor?.name === "KvNamespace") {
-    return layers.cloudflare(store);
+    return layers.extra(layers.cloudflare(store));
   }
 
   // ¯\_(ツ)_/¯
@@ -263,17 +380,22 @@ export default function compat(storeClient = new Map()) {
   return new Proxy(
     {},
     {
-      get: (_, key) => {
+      get: (instance, key) => {
         return async (...args) => {
-          const store = await getStore(await storeClient);
+          // Only once, even if called twice in succession, since the
+          // second time will go straight to the await
+          if (!instance.store && !instance.promise) {
+            instance.promise = getStore(await storeClient);
+          }
+          instance.store = await instance.promise;
           // Throw at the first chance when the store failed to init:
-          if (!store) {
+          if (!instance.store) {
             throw new Error("Store is not valid");
           }
           // The store.close() is the only one allowed to be called even
           // if it doesn't exist, since it's optional in some stores
-          if (!store[key] && key === "close") return null;
-          return store[key](...args);
+          if (!instance.store[key] && key === "close") return null;
+          return instance.store[key](...args);
         };
       },
     }

package/src/index.test.js

@@ -46,10 +46,20 @@ for (let [name, store] of stores) {
       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 () => {
-      await store.set("a", "b");
+      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 basic types", async () => {
@@ -62,8 +72,8 @@ for (let [name, store] of stores) {
     });
 
     it("can store arrays of JSON values", async () => {
-      await store.set("a", ["b"]);
-      expect(await store.get("a")).toEqual(["b"]);
+      await store.set("a", ["b", "c"]);
+      expect(await store.get("a")).toEqual(["b", "c"]);
       expect(await store.has("a")).toBe(true);
     });
 
@@ -73,22 +83,83 @@ for (let [name, store] of stores) {
       expect(await store.has("a")).toBe(true);
     });
 
-    it("can retrieve the prefixed keys with colon", async () => {
+    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 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", "b2");
+      await store.set("a:2", "a2");
       expect((await store.keys("a:")).sort()).toEqual(["a:0", "a:1", "a:2"]);
     });
 
-    it("can retrieve the prefixed keys with dash", async () => {
+    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.values("a:")).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("a:")).sort()).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");
       await store.set("b-0", "b0");
-      await store.set("a-2", "b2");
+      await store.set("a-2", "a2");
       expect((await store.keys("a-")).sort()).toEqual(["a-0", "a-1", "a-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.values("a-")).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.entries("a-")).sort()).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");
@@ -96,12 +167,6 @@ for (let [name, store] of stores) {
       expect(await store.get("a")).toBe(null);
     });
 
-    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 clear all the values", async () => {
       await store.set("a", "b");
       await store.set("c", "d");
@@ -113,33 +178,37 @@ for (let [name, store] of stores) {
     });
 
     describe("expires", () => {
-      it("expire = 0 means immediately", async () => {
-        await store.set("a", "b", { expire: 0 });
+      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("expire = potato means undefined = forever", async () => {
-        await store.set("a", "b", { expire: "potato" });
+      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("expire = 5potato means undefined = forever", async () => {
-        await store.set("a", "b", { expire: "5potato" });
+      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("expire = null means never to expire it", async () => {
-        await store.set("a", "b", { expire: null });
+      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("expire = undefined means never to expire it", async () => {
+      it("expires = undefined means never to expire it", async () => {
         await store.set("a", "b");
         expect(await store.get("a")).toBe("b");
         await delay(100);
@@ -147,42 +216,43 @@ for (let [name, store] of stores) {
       });
 
       if (name !== "kv('cookie')" && name !== "kv(redis)") {
-        it("can use 10 expire", async () => {
-          await store.set("a", "b", { expire: 10 });
+        it("can use 0.01 expire", async () => {
+          // 10ms
+          await store.set("a", "b", { expires: 0.01 });
           expect(await store.get("a")).toBe("b");
           await delay(100);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 0.01s expire", async () => {
-          await store.set("a", "b", { expire: "0.01s" });
+          await store.set("a", "b", { expires: "0.01s" });
           expect(await store.get("a")).toBe("b");
           await delay(100);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 0.01seconds expire", async () => {
-          await store.set("a", "b", { expire: "0.01seconds" });
+          await store.set("a", "b", { expires: "0.01seconds" });
           expect(await store.get("a")).toBe("b");
           await delay(100);
           expect(await store.get("a")).toBe(null);
         });
 
         it("can use 10ms expire", async () => {
-          await store.set("a", "b", { expire: "10ms" });
+          await store.set("a", "b", { expires: "10ms" });
           expect(await store.get("a")).toBe("b");
           await delay(100);
           expect(await store.get("a")).toBe(null);
         });
       } else {
-        it("can use 1000 expire", async () => {
-          await store.set("a", "b", { expire: 1000 });
+        it("can use 1 (second) expire", async () => {
+          await store.set("a", "b", { expires: 1 });
           expect(await store.get("a")).toBe("b");
           await delay(2000);
           expect(await store.get("a")).toBe(null);
         });
         it("can use 1s expire", async () => {
-          await store.set("a", "b", { expire: "1s" });
+          await store.set("a", "b", { expires: "1s" });
           expect(await store.get("a")).toBe("b");
           await delay(2000);
           expect(await store.get("a")).toBe(null);

package/src/index.types.ts

@@ -3,11 +3,15 @@ import kv from "..";
 const store = kv();
 
 (async () => {
-  const val = await store.get("key");
+  await store.get("key");
   await store.set("key", "value");
   await store.set("key", "value", {});
-  await store.set("key", "value", { expire: 100 });
-  await store.set("key", "value", { expire: "100s" });
+  await store.set("key", "value", { expires: 100 });
+  await store.set("key", "value", { expires: "100s" });
+  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/index.d.ts

@@ -1,13 +0,0 @@
-type Expire = number | string | null;
-
-type Store = {
-  get: (key: string) => Promise<any>;
-  set: (key: string, value: any, opts?: { expire?: Expire }) => Promise<null>;
-  has: (key: string) => Promise<boolean>;
-  del: (key: string) => Promise<null>;
-
-  keys: (prefix?: string) => Promise<string[]>;
-  clear: () => Promise<null>;
-};
-
-export default function (store?: any): Store;

package/index.min.js

@@ -1,2 +0,0 @@
-var o={},m=/(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/iu;a.millisecond=a.ms=1;a.second=a.sec=a.s=a[""]=a.ms*1e3;a.minute=a.min=a.m=a.s*60;a.hour=a.hr=a.h=a.m*60;a.day=a.d=a.h*24;a.week=a.wk=a.w=a.d*7;a.year=a.yr=a.y=a.d*365.25;a.month=a.b=a.y/12;function a(t){if(t==null)return null;if(typeof t=="number")return t;t=t.toLowerCase().replace(/[,_]/g,"");let[u,l,r]=m.exec(t)||[];if(!r)return null;let c=a[r]||a[r.replace(/s$/,"")];if(!c)return null;let p=c*parseFloat(l,10);return Math.abs(Math.round(p))}o.expire=t=>{let u=async n=>{if(!await t.has(n))return null;let{data:e,expire:d}=await t.get(n);return d===null?e:d-new Date().getTime()<=0?null:e},l=async(n,e,{expire:d=null}={})=>{let s=a(d),i=s!==null?new Date().getTime()+s:null;return t.set(n,{expire:i,data:e})},r=async n=>await t.get(n)!==null,c=t.del,p=t.keys,y=t.clear;return{get:u,set:l,has:r,del:c,keys:p,clear:y}};o.memory=t=>({get:async n=>t.get(n)||null,set:async(n,e)=>t.set(n,e),has:async n=>t.has(n),del:async n=>t.delete(n),keys:async(n="")=>[...await t.keys()].filter(e=>e.startsWith(n)),clear:()=>t.clear()});o.storage=t=>({get:async n=>t[n]?JSON.parse(t[n]):null,set:async(n,e)=>t.setItem(n,JSON.stringify(e)),has:async n=>n in t,del:async n=>t.removeItem(n),keys:async(n="")=>Object.keys(t).filter(e=>e.startsWith(n)),clear:()=>t.clear()});o.cookie=()=>{let t=async y=>{let n=document.cookie.split("; ").filter(Boolean).find(e=>e.startsWith(y+"="))?.split("=")[1]||null;return JSON.parse(decodeURIComponent(n))},u=async(y,n,{expire:e=null}={})=>{let d=a(e),s=new Date().getTime(),i=d!==null?`; expires=${new Date(s+d).toUTCString()}`:"",f=encodeURIComponent(JSON.stringify(n));document.cookie=y+"="+f+i},l=async y=>(await c()).includes(y),r=async y=>u(y,"",{expire:-100}),c=async(y="")=>document.cookie.split(";").map(n=>n.split("=")[0].trim()).filter(Boolean).filter(n=>n.startsWith(y));return{get:t,set:u,has:l,del:r,keys:c,clear:async()=>{await Promise.all((await c()).map(r))}}};o.redis=t=>{let u=async e=>{let s=await(await t).get(e);return s?JSON.parse(s):null},l=async(e,d,{expire:s=null}={})=>{if(d===null||s===0)return c(e);let i=await t,f=a(s),w=f?Math.round(f/1e3):void 0;return i.set(e,JSON.stringify(d),{EX:w})},r=async e=>!!await(await t).exists(e),c=async e=>(await t).del(e);return{get:u,set:l,has:r,del:c,keys:async(e="")=>(await t).keys(e+"*"),clear:async()=>(await t).flushAll(),close:async()=>(await t).quit()}};o.localForage=t=>{let u=n=>t.getItem(n);return{get:u,set:(n,e)=>t.setItem(n,e),has:async n=>await u(n)!==null,del:n=>t.removeItem(n),keys:async(n="")=>(await t.keys()).filter(e=>e.startsWith(n)),clear:()=>t.clear()}};o.cloudflare=t=>{let u=async n=>{let e=await t.get(n);return e?JSON.parse(e):null},l=async(n,e,{expire:d})=>{if(e===null||d===0)return c(n);let s=await t,i=a(d),f=i?Math.round(i/1e3):void 0;return s.put(n,JSON.stringify(e),{expirationTtl:f})},r=async n=>!!await t.get(n),c=n=>t.delete(n);return{get:u,set:l,has:r,del:c,keys:n=>t.list({prefix:n}),clear:()=>{}}};o.file=t=>{let u=(async()=>{let i=await import(["node:fs","promises"].join("/"));return await i.writeFile(t.pathname,"{}",{flag:"wx"}).catch(f=>{if(f.code!=="EEXIST")throw f}),i})(),l=async()=>{let i=await(await u).readFile(t.pathname,"utf8");return i?JSON.parse(i):{}},r=async s=>{await(await u).writeFile(t.pathname,JSON.stringify(s,null,2))},c=async s=>(await l())[s]??null;return{get:c,set:async(s,i)=>{let f=await l();f[s]=i,await r(f)},has:async s=>await c(s)!==null,del:async s=>{let i=await l();delete i[s],await r(i)},keys:async(s="")=>{let i=await l();return Object.keys(i).filter(f=>f.startsWith(s))},clear:async()=>{await r({})}}};var g=async t=>t instanceof Map?o.expire(o.memory(t)):typeof localStorage<"u"&&t===localStorage||typeof sessionStorage<"u"&&t===sessionStorage?o.expire(o.storage(t)):t==="cookie"?o.cookie():t.defineDriver&&t.dropInstance&&t.INDEXEDDB?o.expire(o.localForage(t)):t.protocol&&t.protocol==="file:"?o.expire(o.file(t)):t.pSubscribe&&t.sSubscribe?o.redis(t):t?.constructor?.name==="KvNamespace"?o.cloudflare(t):null;function h(t=new Map){return new Proxy({},{get:(u,l)=>async(...r)=>{let c=await g(await t);if(!c)throw new Error("Store is not valid");return!c[l]&&l==="close"?null:c[l](...r)}})}export{h as default};
-//# sourceMappingURL=index.min.js.map

package/index.min.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["src/index.js"],
-  "sourcesContent": ["const layers = {};\n\nconst times = /(-?(?:\\d+\\.?\\d*|\\d*\\.?\\d+)(?:e[-+]?\\d+)?)\\s*([\\p{L}]*)/iu;\n\nparse.millisecond = parse.ms = 1;\nparse.second = parse.sec = parse.s = parse[\"\"] = parse.ms * 1000;\nparse.minute = parse.min = parse.m = parse.s * 60;\nparse.hour = parse.hr = parse.h = parse.m * 60;\nparse.day = parse.d = parse.h * 24;\nparse.week = parse.wk = parse.w = parse.d * 7;\nparse.year = parse.yr = parse.y = parse.d * 365.25;\nparse.month = parse.b = parse.y / 12;\n\n// Returns the time in milliseconds\nfunction parse(str) {\n  if (str === null || str === undefined) return null;\n  if (typeof str === \"number\") return str;\n  // ignore commas/placeholders\n  str = str.toLowerCase().replace(/[,_]/g, \"\");\n  let [_, value, units] = times.exec(str) || [];\n  if (!units) return null;\n  const unitValue = parse[units] || parse[units.replace(/s$/, \"\")];\n  if (!unitValue) return null;\n  const result = unitValue * parseFloat(value, 10);\n  return Math.abs(Math.round(result));\n}\n\nlayers.expire = (store) => {\n  // Item methods\n  const get = async (key) => {\n    if (!(await store.has(key))) return null;\n    const { data, expire } = await store.get(key);\n    if (expire === null) return data;\n    const diff = expire - new Date().getTime();\n    if (diff <= 0) return null;\n    return data;\n  };\n  const set = async (key, data, { expire = null } = {}) => {\n    const time = parse(expire);\n    const expDiff = time !== null ? new Date().getTime() + time : null;\n    return store.set(key, { expire: expDiff, data });\n  };\n  const has = async (key) => (await store.get(key)) !== null;\n  const del = store.del;\n\n  // Group methods\n  const keys = store.keys;\n  const clear = store.clear;\n\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.memory = (store) => {\n  // Item methods\n  const get = async (key) => store.get(key) || null;\n  const set = async (key, data) => store.set(key, data);\n  const has = async (key) => store.has(key);\n  const del = async (key) => store.delete(key);\n\n  // Group methods\n  const keys = async (prefix = \"\") =>\n    [...(await store.keys())].filter((k) => k.startsWith(prefix));\n  const clear = () => store.clear();\n\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.storage = (store) => {\n  // Item methods\n  const get = async (key) => (store[key] ? JSON.parse(store[key]) : null);\n  const set = async (key, data) => store.setItem(key, JSON.stringify(data));\n  const has = async (key) => key in store;\n  const del = async (key) => store.removeItem(key);\n\n  // Group methods\n  const keys = async (prefix = \"\") =>\n    Object.keys(store).filter((k) => k.startsWith(prefix));\n  const clear = () => store.clear();\n\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.cookie = () => {\n  const get = async (key) => {\n    const value =\n      document.cookie\n        .split(\"; \")\n        .filter(Boolean)\n        .find((row) => row.startsWith(key + \"=\"))\n        ?.split(\"=\")[1] || null;\n    return JSON.parse(decodeURIComponent(value));\n  };\n\n  const set = async (key, data, { expire = null } = {}) => {\n    const time = parse(expire);\n    const now = new Date().getTime();\n    const expireStr =\n      time !== null ? `; expires=${new Date(now + time).toUTCString()}` : \"\";\n    const value = encodeURIComponent(JSON.stringify(data));\n    document.cookie = key + \"=\" + value + expireStr;\n  };\n  const has = async (key) => (await keys()).includes(key);\n  const del = async (key) => set(key, \"\", { expire: -100 });\n\n  // Group methods\n  const keys = async (prefix = \"\") =>\n    document.cookie\n      .split(\";\")\n      .map((l) => l.split(\"=\")[0].trim())\n      .filter(Boolean)\n      .filter((k) => k.startsWith(prefix));\n  const clear = async () => {\n    await Promise.all((await keys()).map(del));\n  };\n\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.redis = (store) => {\n  const get = async (key) => {\n    const client = await store;\n    const value = await client.get(key);\n    if (!value) return null;\n    return JSON.parse(value);\n  };\n  const set = async (key, value, { expire = null } = {}) => {\n    if (value === null || expire === 0) return del(key);\n    const client = await store;\n    const exp = parse(expire);\n    const EX = exp ? Math.round(exp / 1000) : undefined;\n    return client.set(key, JSON.stringify(value), { EX });\n  };\n  const has = async (key) => Boolean(await (await store).exists(key));\n  const del = async (key) => (await store).del(key);\n\n  const keys = async (prefix = \"\") => (await store).keys(prefix + \"*\");\n  const clear = async () => (await store).flushAll();\n  const close = async () => (await store).quit();\n\n  return { get, set, has, del, keys, clear, close };\n};\n\nlayers.localForage = (store) => {\n  const get = (key) => store.getItem(key);\n  const set = (key, value) => store.setItem(key, value);\n  const has = async (key) => (await get(key)) !== null;\n  const del = (key) => store.removeItem(key);\n\n  const keys = async (prefix = \"\") =>\n    (await store.keys()).filter((k) => k.startsWith(prefix));\n  const clear = () => store.clear();\n\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.cloudflare = (store) => {\n  const get = async (key) => {\n    const data = await store.get(key);\n    if (!data) return null;\n    return JSON.parse(data);\n  };\n  const set = async (key, value, { expire }) => {\n    if (value === null || expire === 0) return del(key);\n    const client = await store;\n    const exp = parse(expire);\n    const expirationTtl = exp ? Math.round(exp / 1000) : undefined;\n    return client.put(key, JSON.stringify(value), { expirationTtl });\n  };\n  const has = async (key) => Boolean(await store.get(key));\n  const del = (key) => store.delete(key);\n  const keys = (prefix) => store.list({ prefix });\n  const clear = () => {};\n  return { get, set, has, del, keys, clear };\n};\n\nlayers.file = (file) => {\n  const fsProm = (async () => {\n    // For the bundler, it doesn't like it otherwise\n    const lib = [\"node:fs\", \"promises\"].join(\"/\");\n    const fsp = await import(lib);\n    // We want to make sure the file already exists, so attempt to\n    // create it (but not OVERWRITE it, that's why the x flag) and\n    // it fails if it already exists\n    await fsp.writeFile(file.pathname, \"{}\", { flag: \"wx\" }).catch((err) => {\n      if (err.code !== \"EEXIST\") throw err;\n    });\n    return fsp;\n  })();\n  const getContent = async () => {\n    const fsp = await fsProm;\n    const text = await fsp.readFile(file.pathname, \"utf8\");\n    if (!text) return {};\n    return JSON.parse(text);\n  };\n  const setContent = async (data) => {\n    const fsp = await fsProm;\n    await fsp.writeFile(file.pathname, JSON.stringify(data, null, 2));\n  };\n  const get = async (key) => {\n    const data = await getContent();\n    return data[key] ?? null;\n  };\n  const set = async (key, value) => {\n    const data = await getContent();\n    data[key] = value;\n    await setContent(data);\n  };\n  const has = async (key) => (await get(key)) !== null;\n  const del = async (key) => {\n    const data = await getContent();\n    delete data[key];\n    await setContent(data);\n  };\n  const keys = async (prefix = \"\") => {\n    const data = await getContent();\n    return Object.keys(data).filter((k) => k.startsWith(prefix));\n  };\n  const clear = async () => {\n    await setContent({});\n  };\n  return { get, set, has, del, keys, clear };\n};\n\nconst getStore = async (store) => {\n  // Convert it to the normalized kv, then add the expiry layer on top\n  if (store instanceof Map) {\n    return layers.expire(layers.memory(store));\n  }\n\n  if (typeof localStorage !== \"undefined\" && store === localStorage) {\n    return layers.expire(layers.storage(store));\n  }\n\n  if (typeof sessionStorage !== \"undefined\" && store === sessionStorage) {\n    return layers.expire(layers.storage(store));\n  }\n\n  if (store === \"cookie\") {\n    return layers.cookie();\n  }\n\n  if (store.defineDriver && store.dropInstance && store.INDEXEDDB) {\n    return layers.expire(layers.localForage(store));\n  }\n\n  if (store.protocol && store.protocol === \"file:\") {\n    return layers.expire(layers.file(store));\n  }\n\n  if (store.pSubscribe && store.sSubscribe) {\n    return layers.redis(store);\n  }\n\n  if (store?.constructor?.name === \"KvNamespace\") {\n    return layers.cloudflare(store);\n  }\n\n  // \u00AF\\_(\u30C4)_/\u00AF\n  return null;\n};\n\nexport default function compat(storeClient = new Map()) {\n  return new Proxy(\n    {},\n    {\n      get: (_, key) => {\n        return async (...args) => {\n          const store = await getStore(await storeClient);\n          // Throw at the first chance when the store failed to init:\n          if (!store) {\n            throw new Error(\"Store is not valid\");\n          }\n          // The store.close() is the only one allowed to be called even\n          // if it doesn't exist, since it's optional in some stores\n          if (!store[key] && key === \"close\") return null;\n          return store[key](...args);\n        };\n      },\n    }\n  );\n}\n"],
-  "mappings": "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",
-  "names": ["layers", "times", "parse", "str", "_", "value", "units", "unitValue", "result", "store", "get", "key", "data", "expire", "set", "time", "expDiff", "has", "del", "keys", "clear", "prefix", "k", "row", "now", "expireStr", "l", "client", "exp", "EX", "expirationTtl", "file", "fsProm", "fsp", "err", "getContent", "text", "setContent", "getStore", "compat", "storeClient", "args"]
-}

package/tsconfig.json

@@ -1 +0,0 @@
-{ "exclude": ["node_modules"] }