polystore 0.15.4 → 0.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.15.4",
+  "version": "0.15.6",
   "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/file.js

@@ -32,13 +32,13 @@ export default class File {
   // Internal
   #read = async () => {
     const fsp = await this.promise;
-    const data = await fsp.readFile(this.file, "utf8");
-    return JSON.parse(data || "{}");
+    const text = await fsp.readFile(this.file, "utf8");
+    return text ? JSON.parse(text) : {};
   };
 
   #write = async (data) => {
     const fsp = await this.promise;
-    fsp.writeFile(this.file, JSON.stringify(data, null, 2));
+    return fsp.writeFile(this.file, JSON.stringify(data, null, 2));
   };
 
   get = async (key) => {
@@ -54,7 +54,6 @@ export default class File {
       data[key] = value;
     }
     await this.#write(data);
-    return key;
   };
 
   async *iterate(prefix = "") {

package/src/clients/folder.js

@@ -1,67 +1,56 @@
-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 (
+    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;
-    })();
+      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 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);
-  }
+  get = async (key) => {
+    const text = await this.fs.readFile(key, "utf8");
+    return text ? JSON.parse(text) : null;
+  };
 
-  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;
-  }
+  set = (key, value) => this.fs.writeFile(key, json(value), "utf8");
 
-  async del(key) {
-    const file = this.folder + key + ".json";
-    const fsp = await this.promise;
-    await fsp.unlink(file).catch(noFileOk);
-    return file;
-  }
+  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 +59,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/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,30 @@ 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 = "") {
+  // 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]]);
+  };
+
+  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)));
-  }
+  };
 
-  async close() {
-    return this.client.quit();
-  }
+  close = () => this.client.quit();
 }