polystore 0.15.5 → 0.15.7

package/package.json

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

package/src/clients/api.js

@@ -20,14 +20,12 @@ export default class Api {
   }
 
   get = (key) => this.client(`/${enc(key)}`);
-
   set = (key, value, { expires } = {}) =>
     this.client(
       `/${enc(key)}?expires=${enc(expires || "")}`,
       "PUT",
       JSON.stringify(value),
     );
-
   del = (key) => this.client(`/${enc(key)}`, "DELETE");
 
   async *iterate(prefix = "") {

package/src/clients/cloudflare.js

@@ -4,34 +4,28 @@ export default class Cloudflare {
   EXPIRES = true;
 
   // Check whether the given store is a FILE-type
-  static test(client) {
-    return (
-      client?.constructor?.name === "KvNamespace" ||
-      client?.constructor?.name === "EdgeKVNamespace"
-    );
-  }
+  static test = (client) =>
+    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);
-  }
+  get = async (key) => {
+    const text = await this.client.get(key);
+    return text ? JSON.parse(text) : null;
+  };
 
-  async set(key, value, { expires } = {}) {
+  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 });
-  }
+  };
 
-  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 +44,7 @@ export default class Cloudflare {
     } while (cursor);
   }
 
-  async keys(prefix = "") {
+  keys = async (prefix = "") => {
     const keys = [];
     let cursor;
     do {
@@ -59,16 +53,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

@@ -4,12 +4,10 @@ export default class Cookie {
   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 +20,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!
@@ -40,11 +36,9 @@ export default class Cookie {
 
     const value = encodeURIComponent(JSON.stringify(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,15 @@
 // Use a redis client to back up the store
 export default class Etcd {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client?.constructor?.name === "Etcd3";
-  }
+  static test = (client) => 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));
-  }
-
-  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(JSON.stringify(value));
+  del = (key) => this.client.delete().key(key).exec();
 
   async *iterate(prefix = "") {
     const keys = await this.client.getAll().prefix(prefix).keys();
@@ -28,18 +18,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,14 +1,14 @@
 // A client that uses a single file (JSON) as a store
 export default class File {
   // 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;
@@ -54,7 +54,6 @@ export default class File {
       data[key] = value;
     }
     await this.#write(data);
-    return key;
   };
 
   async *iterate(prefix = "") {
@@ -66,9 +65,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,67 +1,54 @@
-const noFileOk = (error) => {
-  if (error.code === "ENOENT") return null;
-  throw error;
-};
+const json = (data) => JSON.stringify(data, null, 2);
 
 // A client that uses a single file (JSON) as a store
 export default class Folder {
   // Check if this is the right class for the given client
-  static test(client) {
-    if (
+  static test = (client) => {
+    if (client instanceof URL) client = client.href;
+    return (
       typeof client === "string" &&
-      client.startsWith("file:") &&
+      client.startsWith("file://") &&
       client.endsWith("/")
-    )
-      return true;
-    return (
-      client instanceof URL &&
-      client.protocol === "file:" &&
-      client.pathname.endsWith("/")
     );
-  }
+  };
 
   constructor(folder) {
-    this.folder =
-      typeof folder === "string"
-        ? folder.slice("file://".length).replace(/\/$/, "") + "/"
-        : folder.pathname.replace(/\/$/, "") + "/";
+    if (folder instanceof URL) folder = folder.href;
+    folder = folder.replace(/^file:\/\//, "");
 
     // Run this once on launch; import the FS module and reset the file
-    this.promise = (async () => {
-      const fsp = await import("node:fs/promises");
-
+    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
-      await fsp.mkdir(this.folder, { recursive: true }).catch(() => {});
-      return fsp;
-    })();
-  }
-
-  async get(key) {
-    const fsp = await this.promise;
-    const file = this.folder + key + ".json";
-    const text = await fsp.readFile(file, "utf8").catch(noFileOk);
-    if (!text) return null;
-    return JSON.parse(text);
+      return fsp.mkdir(folder, { recursive: true }).then(
+        () => fsp,
+        () => {},
+      );
+    });
+
+    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;
+        });
+      };
+    };
+
+    this.fs = new Proxy({}, { get: getter });
   }
 
-  async set(key, value) {
-    const fsp = await this.promise;
-    const file = this.folder + key + ".json";
-    await fsp.writeFile(file, JSON.stringify(value, null, 2), "utf8");
-    return file;
-  }
-
-  async del(key) {
-    const file = this.folder + key + ".json";
-    const fsp = await this.promise;
-    await fsp.unlink(file).catch(noFileOk);
-    return file;
-  }
+  get = async (key) => {
+    const text = await this.fs.readFile(key, "utf8");
+    return text ? JSON.parse(text) : null;
+  };
+  set = (key, value) => this.fs.writeFile(key, json(value), "utf8");
+  del = (key) => this.fs.unlink(key);
 
   async *iterate(prefix = "") {
-    const fsp = await this.promise;
-    const all = await fsp.readdir(this.folder);
+    const all = await this.fs.readdir();
     const keys = all
       .filter((f) => f.startsWith(prefix) && f.endsWith(".json"))
       .map((name) => name.slice(0, -".json".length));
@@ -70,14 +57,4 @@ export default class Folder {
       yield [key, data];
     }
   }
-
-  // async clear(prefix = "") {
-  //   const data = await this.#read();
-  //   for (let key in data) {
-  //     if (key.startsWith(prefix)) {
-  //       delete data[key];
-  //     }
-  //   }
-  //   await this.#write(data);
-  // }
 }

package/src/clients/forage.js

@@ -1,25 +1,16 @@
 // Use localForage for managing the KV
 export default class Forage {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client?.defineDriver && client?.dropInstance && client?.INDEXEDDB;
-  }
+  static test = (client) =>
+    client?.defineDriver && client?.dropInstance && client?.INDEXEDDB;
 
   constructor(client) {
     this.client = client;
   }
 
-  async get(key) {
-    return this.client.getItem(key);
-  }
-
-  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 +20,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,21 @@
+const valueEncoding = "json";
+const notFound = (error) => {
+  if (error?.code === "LEVEL_NOT_FOUND") return null;
+  throw error;
+};
+
 // 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";
-  }
+  static test = (client) => client?.constructor?.name === "ClassicLevel";
 
   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;
-    }
-  }
-
-  async set(key, value) {
-    return this.client.put(key, value, { valueEncoding: "json" });
-  }
-
-  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 +25,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,21 @@
 // Use a Map() as an in-memory client
 export default class Memory {
   // Check if this is the right class for the given client
-  static test(client) {
-    return client instanceof Map;
-  }
+  static test = (client) => client instanceof Map;
 
   constructor(client) {
     this.client = client;
   }
 
-  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

@@ -4,37 +4,25 @@ export default class Redis {
   EXPIRES = true;
 
   // Check if this is the right class for the given client
-  static test(client) {
-    return client && client.pSubscribe && client.sSubscribe;
-  }
+  static test = (client) => client && client.pSubscribe && client.sSubscribe;
 
   constructor(client) {
     this.client = client;
   }
 
-  async get(key) {
-    const value = await this.client.get(key);
-    if (!value) return null;
-    return JSON.parse(value);
-  }
+  get = async (key) => {
+    const text = await this.client.get(key);
+    return text ? JSON.parse(text) : null;
+  };
 
-  async set(key, value, { expires } = {}) {
+  set = async (key, value, { expires } = {}) => {
     const EX = expires ? Math.round(expires) : undefined;
     return this.client.set(key, JSON.stringify(value), { EX });
-  }
+  };
 
-  async del(key) {
-    return this.client.del(key);
-  }
-
-  async has(key) {
-    return Boolean(await this.client.exists(key));
-  }
+  del = (key) => this.client.del(key);
 
-  // Group methods
-  async keys(prefix = "") {
-    return this.client.keys(prefix + "*");
-  }
+  has = async (key) => Boolean(await this.client.exists(key));
 
   // Go through each of the [key, value] in the set
   async *iterate(prefix = "") {
@@ -47,32 +35,24 @@ export default class Redis {
     }
   }
 
-  // Optimizing the retrieval of them all in bulk by loading the values
-  // in parallel
-  async entries(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]]);
-  }
-
   // Optimizing the retrieval of them by not getting their values
-  async keys(prefix = "") {
+  keys = async (prefix = "") => {
     const MATCH = prefix + "*";
     const keys = [];
     for await (const key of this.client.scanIterator({ MATCH })) {
       keys.push(key);
     }
     return keys;
-  }
+  };
 
-  async clear(prefix = "") {
-    if (!prefix) return this.client.flushAll();
-
-    const list = await this.keys(prefix);
-    return Promise.all(list.map((k) => this.client.del(k)));
-  }
+  // Optimizing the retrieval of them all in bulk by loading the values
+  // in parallel
+  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 close() {
-    return this.client.quit();
-  }
+  clearAll = () => this.client.flushAll();
+  close = () => this.client.quit();
 }

package/src/clients/storage.js

@@ -11,18 +11,12 @@ export default class WebStorage {
   }
 
   // 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) => {
+    const text = this.client[key];
+    return text ? JSON.parse(text) : null;
+  };
+  set = (key, data) => this.client.setItem(key, JSON.stringify(data));
+  del = (key) => this.client.removeItem(key);
 
   *iterate(prefix = "") {
     for (const key of Object.keys(this.client)) {
@@ -33,13 +27,5 @@ export default class WebStorage {
     }
   }
 
-  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

@@ -247,6 +247,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);
     }