polystore 0.15.6 → 0.15.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.15.6",
+  "version": "0.15.8",
   "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",
@@ -15,6 +15,7 @@
     "src/"
   ],
   "scripts": {
+    "analyze": "esbuild ./ --bundle --packages=external --format=esm --minify --outfile=index.min.js && gzip-size index.min.js && rm index.min.js",
     "lint": "check-dts test/index.types.ts",
     "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",

package/src/clients/Client.js

@@ -0,0 +1,7 @@
+export default class Client {
+  constructor(client) {
+    this.client = client;
+  }
+  encode = (val) => JSON.stringify(val, null, 2);
+  decode = (val) => (val ? JSON.parse(val) : null);
+}

package/src/clients/api.js

@@ -1,37 +1,28 @@
-const enc = encodeURIComponent; // Optimization of size
+import Client from "./Client";
 
 // Handle an API endpoint with fetch()
-export default class Api {
+export default class Api extends Client {
   // Indicate that the file handler DOES handle expirations
   EXPIRES = true;
 
   static test = (client) =>
     typeof client === "string" && /^https?:\/\//.test(client);
 
-  constructor(client) {
-    client = client.replace(/\/$/, "");
-    this.client = async (path, method = "GET", body) => {
-      const url = `${client}/${path.replace(/^\//, "")}`;
-      const headers = { accept: "application/json" };
-      if (body) headers["content-type"] = "application/json";
-      const res = await fetch(url, { method, headers, body });
-      return res.ok ? res.json() : null;
-    };
-  }
-
-  get = (key) => this.client(`/${enc(key)}`);
+  #api = async (key, opts = "", method = "GET", body) => {
+    const url = `${this.client.replace(/\/$/, "")}/${encodeURIComponent(key)}${opts}`;
+    const headers = { accept: "application/json" };
+    if (body) headers["content-type"] = "application/json";
+    const res = await fetch(url, { method, headers, body });
+    return res.ok ? res.json() : null;
+  };
 
+  get = (key) => this.#api(key);
   set = (key, value, { expires } = {}) =>
-    this.client(
-      `/${enc(key)}?expires=${enc(expires || "")}`,
-      "PUT",
-      JSON.stringify(value),
-    );
-
-  del = (key) => this.client(`/${enc(key)}`, "DELETE");
+    this.#api(key, `?expires=${expires || ""}`, "PUT", this.encode(value));
+  del = (key) => this.#api(key, "", "DELETE");
 
   async *iterate(prefix = "") {
-    const data = await this.client(`/?prefix=${enc(prefix)}`);
+    const data = await this.#api("", `?prefix=${encodeURIComponent(prefix)}`);
     for (let [key, value] of Object.entries(data || {})) {
       yield [prefix + key, value];
     }

package/src/clients/cloudflare.js

@@ -1,37 +1,25 @@
+import Client from "./Client";
+
 // Use Cloudflare's KV store
-export default class Cloudflare {
+export default class Cloudflare extends Client {
   // Indicate that the file handler does NOT handle expirations
   EXPIRES = true;
 
   // Check whether the given store is a FILE-type
-  static test(client) {
-    return (
-      client?.constructor?.name === "KvNamespace" ||
-      client?.constructor?.name === "EdgeKVNamespace"
-    );
-  }
-
-  constructor(client) {
-    this.client = client;
-  }
-
-  async get(key) {
-    const data = await this.client.get(key);
-    if (!data) return null;
-    return JSON.parse(data);
-  }
+  static test = (client) =>
+    client?.constructor?.name === "KvNamespace" ||
+    client?.constructor?.name === "EdgeKVNamespace";
 
-  async set(key, value, { expires } = {}) {
+  get = async (key) => this.decode(await this.client.get(key));
+  set = (key, value, { expires } = {}) => {
     const expirationTtl = expires ? Math.round(expires) : undefined;
     if (expirationTtl && expirationTtl < 60) {
       throw new Error("Cloudflare's min expiration is '60s'");
     }
-    return this.client.put(key, JSON.stringify(value), { expirationTtl });
-  }
+    return this.client.put(key, this.encode(value), { expirationTtl });
+  };
 
-  async del(key) {
-    return this.client.delete(key);
-  }
+  del = (key) => this.client.delete(key);
 
   // Since we have pagination, we don't want to get all of the
   // keys at once if we can avoid it
@@ -50,7 +38,7 @@ export default class Cloudflare {
     } while (cursor);
   }
 
-  async keys(prefix = "") {
+  keys = async (prefix = "") => {
     const keys = [];
     let cursor;
     do {
@@ -59,16 +47,11 @@ export default class Cloudflare {
       cursor = raw.list_complete ? null : raw.cursor;
     } while (cursor);
     return keys;
-  }
+  };
 
-  async entries(prefix = "") {
+  entries = async (prefix = "") => {
     const keys = await this.keys(prefix);
     const values = await Promise.all(keys.map((k) => this.get(k)));
     return keys.map((k, i) => [k, values[i]]);
-  }
-
-  async clear(prefix = "") {
-    const list = await this.keys(prefix);
-    return Promise.all(list.map((k) => this.del(k)));
-  }
+  };
 }

package/src/clients/cookie.js

@@ -1,15 +1,15 @@
+import Client from "./Client";
+
 // A client that uses a single file (JSON) as a store
-export default class Cookie {
+export default class Cookie extends Client {
   // Indicate if this client handles expirations (true = it does)
   EXPIRES = true;
 
   // Check if this is the right class for the given client
-  static test(client) {
-    return client === "cookie" || client === "cookies";
-  }
+  static test = (client) => client === "cookie" || client === "cookies";
 
   // Group methods
-  #read() {
+  #read = () => {
     const all = {};
     for (let entry of document.cookie.split(";")) {
       try {
@@ -22,14 +22,12 @@ export default class Cookie {
       }
     }
     return all;
-  }
+  };
 
   // For cookies, an empty value is the same as null, even `""`
-  get(key) {
-    return this.#read()[key] || null;
-  }
+  get = (key) => this.#read()[key] || null;
 
-  set(key, data = null, { expires } = {}) {
+  set = (key, data = null, { expires } = {}) => {
     // Setting it to null deletes it
     let expireStr = "";
     // NOTE: 0 is already considered here!
@@ -38,13 +36,11 @@ export default class Cookie {
       expireStr = `; expires=${time}`;
     }
 
-    const value = encodeURIComponent(JSON.stringify(data || ""));
+    const value = encodeURIComponent(this.encode(data || ""));
     document.cookie = encodeURIComponent(key) + "=" + value + expireStr;
-  }
+  };
 
-  del(key) {
-    this.set(key, "", { expires: -100 });
-  }
+  del = (key) => this.set(key, "", { expires: -100 });
 
   async *iterate(prefix = "") {
     for (let [key, value] of Object.entries(this.#read())) {

package/src/clients/etcd.js

@@ -1,25 +1,13 @@
+import Client from "./Client";
+
 // Use a redis client to back up the store
-export default class Etcd {
+export default class Etcd extends Client {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client?.constructor?.name === "Etcd3";
-  }
-
-  constructor(client) {
-    this.client = client;
-  }
-
-  async get(key) {
-    return this.client.get(key).json();
-  }
-
-  async set(key, value) {
-    return this.client.put(key).value(JSON.stringify(value));
-  }
+  static test = (client) => client?.constructor?.name === "Etcd3";
 
-  async del(key) {
-    return this.client.delete().key(key).exec();
-  }
+  get = (key) => this.client.get(key).json();
+  set = (key, value) => this.client.put(key).value(this.encode(value));
+  del = (key) => this.client.delete().key(key).exec();
 
   async *iterate(prefix = "") {
     const keys = await this.client.getAll().prefix(prefix).keys();
@@ -28,18 +16,14 @@ export default class Etcd {
     }
   }
 
-  async keys(prefix = "") {
-    return this.client.getAll().prefix(prefix).keys();
-  }
-
-  async entries(prefix = "") {
+  keys = (prefix = "") => this.client.getAll().prefix(prefix).keys();
+  entries = async (prefix = "") => {
     const keys = await this.keys(prefix);
     const values = await Promise.all(keys.map((k) => this.get(k)));
     return keys.map((k, i) => [k, values[i]]);
-  }
-
-  async clear(prefix = "") {
+  };
+  clear = async (prefix = "") => {
     if (!prefix) return this.client.delete().all();
     return this.client.delete().prefix(prefix);
-  }
+  };
 }

package/src/clients/file.js

@@ -1,44 +1,36 @@
+import Client from "./Client";
+
 // A client that uses a single file (JSON) as a store
-export default class File {
+export default class File extends Client {
   // Check if this is the right class for the given client
-  static test(client) {
+  static test = (client) => {
     if (client instanceof URL) client = client.href;
     return (
       typeof client === "string" &&
       client.startsWith("file://") &&
       client.includes(".")
     );
-  }
-
-  constructor(file) {
-    if (file instanceof URL) file = file.href;
-    this.file = file.replace(/^file:\/\//, "");
+  };
 
-    // Run this once on launch; import the FS module and reset the file
-    this.promise = (async () => {
-      // We want to make sure the file already exists, so attempt to
-      // create the folders and the file (but not OVERWRITE it, that's why the x flag)
-      // It fails if it already exists, hence the catch case
-      const fsp = await import("node:fs/promises");
-      const folder = this.file.split("/").slice(0, -1).join("/");
-      await fsp.mkdir(folder, { recursive: true }).catch(() => {});
-      await fsp.writeFile(this.file, "{}", { flag: "wx" }).catch((err) => {
-        if (err.code !== "EEXIST") throw err;
-      });
-      return fsp;
-    })();
-  }
+  // We want to make sure the file already exists, so attempt to
+  // create the folders and the file (but not OVERWRITE it, that's why the x flag)
+  // It fails if it already exists, hence the catch case
+  #promise = (async () => {
+    this.fsp = await import("node:fs/promises");
+    this.file = (this.client?.href || this.client).replace(/^file:\/\//, "");
+    const folder = this.file.split("/").slice(0, -1).join("/");
+    await this.fsp.mkdir(folder, { recursive: true }).catch(() => {});
+    await this.fsp.writeFile(this.file, "{}", { flag: "wx" }).catch(() => {});
+  })();
 
   // Internal
   #read = async () => {
-    const fsp = await this.promise;
-    const text = await fsp.readFile(this.file, "utf8");
+    const text = await this.fsp.readFile(this.file, "utf8");
     return text ? JSON.parse(text) : {};
   };
 
   #write = async (data) => {
-    const fsp = await this.promise;
-    return fsp.writeFile(this.file, JSON.stringify(data, null, 2));
+    return this.fsp.writeFile(this.file, this.encode(data));
   };
 
   get = async (key) => {
@@ -65,9 +57,8 @@ export default class File {
   }
 
   // Bulk updates are worth creating a custom method here
+  clearAll = () => this.#write({});
   clear = async (prefix = "") => {
-    if (!prefix) return this.#write({});
-
     const data = await this.#read();
     for (let key in data) {
       if (key.startsWith(prefix)) {

package/src/clients/folder.js

@@ -1,60 +1,47 @@
-const json = (data) => JSON.stringify(data, null, 2);
+import Client from "./Client";
+
+const noFileOk = (error) => {
+  if (error.code === "ENOENT") return null;
+  throw error;
+};
 
 // A client that uses a single file (JSON) as a store
-export default class Folder {
+export default class Folder extends Client {
   // Check if this is the right class for the given client
-  static test(client) {
+  static test = (client) => {
     if (client instanceof URL) client = client.href;
     return (
       typeof client === "string" &&
       client.startsWith("file://") &&
       client.endsWith("/")
     );
-  }
-
-  constructor(folder) {
-    if (folder instanceof URL) folder = folder.href;
-    folder = folder.replace(/^file:\/\//, "");
+  };
 
-    // Run this once on launch; import the FS module and reset the file
-    const prom = import("node:fs/promises").then((fsp) => {
-      // Make sure the folder already exists, so attempt to create it
-      // It fails if it already exists, hence the catch case
-      return fsp.mkdir(folder, { recursive: true }).then(
-        () => fsp,
-        () => {},
-      );
-    });
+  // Make sure the folder already exists, so attempt to create it
+  // It fails if it already exists, hence the catch case
+  #promise = (async () => {
+    this.fsp = await import("node:fs/promises");
+    this.folder = (this.client?.href || this.client).replace(/^file:\/\//, "");
+    await this.fsp.mkdir(this.folder, { recursive: true }).catch(() => {});
+  })();
 
-    const getter = (_, name) => {
-      return async (key, ...props) => {
-        const file = folder + (key ? key + ".json" : "");
-        const method = (await prom)[name];
-        return method(file, ...props).catch((error) => {
-          if (error.code === "ENOENT") return null;
-          throw error;
-        });
-      };
-    };
+  file = (key) => this.folder + key + ".json";
 
-    this.fs = new Proxy({}, { get: getter });
-  }
-
-  get = async (key) => {
-    const text = await this.fs.readFile(key, "utf8");
-    return text ? JSON.parse(text) : null;
+  get = (key) => {
+    return this.fsp
+      .readFile(this.file(key), "utf8")
+      .then(this.decode, noFileOk);
   };
-
-  set = (key, value) => this.fs.writeFile(key, json(value), "utf8");
-
-  del = (key) => this.fs.unlink(key);
+  set = (key, value) => {
+    return this.fsp.writeFile(this.file(key), this.encode(value), "utf8");
+  };
+  del = (key) => this.fsp.unlink(this.file(key)).catch(noFileOk);
 
   async *iterate(prefix = "") {
-    const all = await this.fs.readdir();
-    const keys = all
-      .filter((f) => f.startsWith(prefix) && f.endsWith(".json"))
-      .map((name) => name.slice(0, -".json".length));
-    for (const key of keys) {
+    const all = await this.fsp.readdir(this.folder);
+    const keys = all.filter((f) => f.startsWith(prefix) && f.endsWith(".json"));
+    for (const name of keys) {
+      const key = name.slice(0, -".json".length);
       const data = await this.get(key);
       yield [key, data];
     }

package/src/clients/forage.js

@@ -1,25 +1,14 @@
+import Client from "./Client";
+
 // Use localForage for managing the KV
-export default class Forage {
+export default class Forage extends Client {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client?.defineDriver && client?.dropInstance && client?.INDEXEDDB;
-  }
-
-  constructor(client) {
-    this.client = client;
-  }
-
-  async get(key) {
-    return this.client.getItem(key);
-  }
+  static test = (client) =>
+    client?.defineDriver && client?.dropInstance && client?.INDEXEDDB;
 
-  async set(key, value) {
-    return this.client.setItem(key, value);
-  }
-
-  async del(key) {
-    return this.client.removeItem(key);
-  }
+  get = (key) => this.client.getItem(key);
+  set = (key, value) => this.client.setItem(key, value);
+  del = (key) => this.client.removeItem(key);
 
   async *iterate(prefix = "") {
     const keys = await this.client.keys();
@@ -29,19 +18,12 @@ export default class Forage {
     }
   }
 
-  async entries(prefix = "") {
+  entries = async (prefix = "") => {
     const all = await this.client.keys();
     const keys = all.filter((k) => k.startsWith(prefix));
     const values = await Promise.all(keys.map((key) => this.get(key)));
     return keys.map((key, i) => [key, values[i]]);
-  }
-
-  async clear(prefix = "") {
-    // Delete the whole dataset
-    if (!prefix) return this.client.clear();
+  };
 
-    // Delete them in a map
-    const list = await this.entries(prefix);
-    return Promise.all(list.map((e) => this.set(e[0], null)));
-  }
+  clearAll = () => this.client.clear();
 }

package/src/clients/level.js

@@ -1,30 +1,19 @@
-// Level KV DB - https://github.com/Level/level
-export default class Level {
-  // Check if this is the right class for the given client
-  static test(client) {
-    return client?.constructor?.name === "ClassicLevel";
-  }
+import Client from "./Client";
 
-  constructor(client) {
-    this.client = client;
-  }
-
-  async get(key) {
-    try {
-      return await this.client.get(key, { valueEncoding: "json" });
-    } catch (error) {
-      if (error?.code === "LEVEL_NOT_FOUND") return null;
-      throw error;
-    }
-  }
+const valueEncoding = "json";
+const notFound = (error) => {
+  if (error?.code === "LEVEL_NOT_FOUND") return null;
+  throw error;
+};
 
-  async set(key, value) {
-    return this.client.put(key, value, { valueEncoding: "json" });
-  }
+// Level KV DB - https://github.com/Level/level
+export default class Level extends Client {
+  // Check if this is the right class for the given client
+  static test = (client) => client?.constructor?.name === "ClassicLevel";
 
-  async del(key) {
-    return this.client.del(key);
-  }
+  get = (key) => this.client.get(key, { valueEncoding }).catch(notFound);
+  set = (key, value) => this.client.put(key, value, { valueEncoding });
+  del = (key) => this.client.del(key);
 
   async *iterate(prefix = "") {
     const keys = await this.client.keys().all();
@@ -34,20 +23,18 @@ export default class Level {
     }
   }
 
-  async entries(prefix = "") {
+  entries = async (prefix = "") => {
     const keys = await this.client.keys().all();
     const list = keys.filter((k) => k.startsWith(prefix));
     return Promise.all(list.map(async (k) => [k, await this.get(k)]));
-  }
+  };
 
-  async clear(prefix = "") {
-    if (!prefix) return this.client.clear();
+  clearAll = () => this.client.clear();
+  clear = async (prefix = "") => {
     const keys = await this.client.keys().all();
     const list = keys.filter((k) => k.startsWith(prefix));
     return this.client.batch(list.map((key) => ({ type: "del", key })));
-  }
+  };
 
-  async close() {
-    return await this.client.close();
-  }
+  close = () => this.client.close();
 }

package/src/clients/memory.js

@@ -1,40 +1,19 @@
+import Client from "./Client";
+
 // Use a Map() as an in-memory client
-export default class Memory {
+export default class Memory extends Client {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client instanceof Map;
-  }
-
-  constructor(client) {
-    this.client = client;
-  }
+  static test = (client) => client instanceof Map;
 
-  get(key) {
-    return this.client.get(key) ?? null;
-  }
-
-  set(key, data) {
-    return this.client.set(key, data);
-  }
-
-  del(key) {
-    return this.client.delete(key);
-  }
+  get = (key) => this.client.get(key) ?? null;
+  set = (key, data) => this.client.set(key, data);
+  del = (key) => this.client.delete(key);
 
   *iterate(prefix = "") {
     for (const entry of this.client.entries()) {
-      if (!entry[0].startsWith(prefix)) continue;
-      yield entry;
+      if (entry[0].startsWith(prefix)) yield entry;
     }
   }
 
-  clear(prefix = "") {
-    // Delete the whole dataset
-    if (!prefix) return this.client.clear();
-
-    // Delete them in a map
-    return [...this.client.keys()]
-      .filter((k) => k.startsWith(prefix))
-      .map((k) => this.del(k));
-  }
+  clearAll = () => this.client.clear();
 }

package/src/clients/redis.js

@@ -1,25 +1,18 @@
+import Client from "./Client";
+
 // Use a redis client to back up the store
-export default class Redis {
+export default class Redis extends Client {
   // Indicate if this client handles expirations (true = it does)
   EXPIRES = true;
 
   // Check if this is the right class for the given client
   static test = (client) => client && client.pSubscribe && client.sSubscribe;
 
-  constructor(client) {
-    this.client = client;
-  }
-
-  get = async (key) => {
-    const text = await this.client.get(key);
-    return text ? JSON.parse(text) : null;
-  };
-
+  get = async (key) => this.decode(await this.client.get(key));
   set = async (key, value, { expires } = {}) => {
     const EX = expires ? Math.round(expires) : undefined;
-    return this.client.set(key, JSON.stringify(value), { EX });
+    return this.client.set(key, this.encode(value), { EX });
   };
-
   del = (key) => this.client.del(key);
 
   has = async (key) => Boolean(await this.client.exists(key));
@@ -53,12 +46,6 @@ export default class Redis {
     return keys.map((k, i) => [k, values[i]]);
   };
 
-  clear = async (prefix = "") => {
-    if (!prefix) return this.client.flushAll();
-
-    const list = await this.keys(prefix);
-    return Promise.all(list.map((k) => this.client.del(k)));
-  };
-
+  clearAll = () => this.client.flushAll();
   close = () => this.client.quit();
 }

package/src/clients/storage.js

@@ -1,45 +1,25 @@
+import Client from "./Client";
+
 // A client that uses a single file (JSON) as a store
-export default class WebStorage {
+export default class WebStorage extends Client {
   // Check if this is the right class for the given client
   static test(client) {
     if (typeof Storage === "undefined") return false;
     return client instanceof Storage;
   }
 
-  constructor(client) {
-    this.client = client;
-  }
-
   // Item methods
-  get(key) {
-    const data = this.client[key];
-    return data ? JSON.parse(data) : null;
-  }
-
-  set(key, data) {
-    return this.client.setItem(key, JSON.stringify(data));
-  }
-
-  del(key) {
-    return this.client.removeItem(key);
-  }
+  get = (key) => this.decode(this.client[key]);
+  set = (key, data) => this.client.setItem(key, this.encode(data));
+  del = (key) => this.client.removeItem(key);
 
   *iterate(prefix = "") {
     for (const key of Object.keys(this.client)) {
       if (!key.startsWith(prefix)) continue;
       const value = this.get(key);
-      if (!value) continue;
-      yield [key, value];
+      if (value) yield [key, value];
     }
   }
 
-  clear(prefix = "") {
-    // Delete the whole store
-    if (!prefix) return this.client.clear();
-
-    // Delete them in a map
-    return Object.keys(this.client)
-      .filter((k) => k.startsWith(prefix))
-      .map((k) => this.del(k));
-  }
+  clearAll = () => this.client.clear();
 }

package/src/index.js

@@ -9,6 +9,7 @@ class Store {
       this.client = this.#find(client);
       this.#validate(this.client);
       this.promise = null;
+      await this.client.promise;
       return client;
     });
   }
@@ -47,7 +48,7 @@ class Store {
       for (let method of ["has", "keys", "values"]) {
         if (client[method]) {
           throw new Error(
-            `You can only define client.${method}() when the client manages the expiration; otherwise please do NOT define .${method}() and let us manage it`,
+            `You can only define client.${method}() when the client manages the expiration.`,
           );
         }
       }
@@ -91,8 +92,7 @@ class Store {
     }
 
     const key = createId();
-    await this.set(key, value, { expires });
-    return key; // The plain one without the prefix
+    return this.set(key, value, { expires });
   }
 
   async set(key, value, options = {}) {
@@ -102,8 +102,7 @@ class Store {
 
     // Quick delete
     if (value === null || (typeof expires === "number" && expires <= 0)) {
-      await this.del(id);
-      return key;
+      return this.del(id);
     }
 
     // The client manages the expiration, so let it manage it
@@ -143,8 +142,7 @@ class Store {
       return this.client.has(id);
     }
 
-    const value = await this.get(key);
-    return value !== null;
+    return (await this.get(key)) !== null;
   }
 
   async del(key) {
@@ -247,6 +245,10 @@ class Store {
   async clear() {
     await this.promise;
 
+    if (!this.PREFIX && this.client.clearAll) {
+      return this.client.clearAll();
+    }
+
     if (this.client.clear) {
       return this.client.clear(this.PREFIX);
     }
@@ -258,7 +260,7 @@ class Store {
 
   prefix(prefix = "") {
     const store = new Store(
-      Promise.resolve(this.promise).then((client) => client || this.client),
+      Promise.resolve(this.promise).then(() => this.client),
     );
     store.PREFIX = this.PREFIX + prefix;
     return store;