polystore 0.7.0 → 0.9.0

package/src/clients/etcd.js

@@ -0,0 +1,39 @@
+// 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";
+  }
+
+  constructor(client) {
+    this.client = client;
+  }
+
+  async get(key) {
+    return this.client.get(key).json();
+  }
+
+  async set(key, value) {
+    if (value === null) {
+      return this.client.delete().key(key).exec();
+    }
+
+    await this.client.put(key).value(JSON.stringify(value));
+  }
+
+  async entries(prefix = "") {
+    const keys = await this.client.getAll().prefix(prefix).keys();
+    const values = await Promise.all(keys.map((k) => this.get(k)));
+    return keys.map((k, i) => [k, values[i]]);
+  }
+
+  async clear(prefix = "") {
+    if (!prefix) return this.client.delete().all();
+
+    return this.client.delete().prefix(prefix);
+  }
+
+  async close() {
+    // return this.client.close();
+  }
+}

package/src/clients/file.js

@@ -0,0 +1,75 @@
+// 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) {
+    if (typeof client === "string" && client.startsWith("file:")) return true;
+    return client instanceof URL && client.protocol === "file:";
+  }
+
+  constructor(file) {
+    this.file =
+      typeof file === "string" ? file.slice("file://".length) : file.pathname;
+
+    // Run this once on launch; import the FS module and reset the file
+    this.promise = (async () => {
+      const fsp = await import("node:fs/promises");
+
+      // We want to make sure the file already exists, so attempt to
+      // create it (but not OVERWRITE it, that's why the x flag) and
+      // it fails if it already exists
+      await fsp.writeFile(this.file, "{}", { flag: "wx" }).catch((err) => {
+        if (err.code !== "EEXIST") throw err;
+      });
+      return fsp;
+    })();
+  }
+
+  // Internal
+  async #read() {
+    const fsp = await this.promise;
+    const text = await fsp.readFile(this.file, "utf8");
+    if (!text) return {};
+    return JSON.parse(text);
+  }
+
+  async #write(data) {
+    const fsp = await this.promise;
+    await fsp.writeFile(this.file, JSON.stringify(data, null, 2));
+  }
+
+  async get(key) {
+    const data = await this.#read();
+    return data[key] ?? null;
+  }
+
+  async set(key, value) {
+    const data = await this.#read();
+    if (value === null) {
+      delete data[key];
+    } else {
+      data[key] = value;
+    }
+    await this.#write(data);
+    return key;
+  }
+
+  // Group methods
+  async entries(prefix = "") {
+    const data = await this.#read();
+    return Object.entries(data).filter((p) => p[0].startsWith(prefix));
+  }
+
+  async clear(prefix = "") {
+    if (!prefix) {
+      return this.#write({});
+    }
+
+    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

@@ -0,0 +1,42 @@
+// 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;
+  }
+
+  constructor(client) {
+    this.client = client;
+  }
+
+  async get(key) {
+    return this.client.getItem(key);
+  }
+
+  async set(key, value) {
+    if (value === null) {
+      await this.client.removeItem(key);
+    } else {
+      await this.client.setItem(key, value);
+    }
+    return key;
+  }
+
+  async entries(prefix = "") {
+    const all = await this.client.keys();
+    const keys = all.filter((k) => k.startsWith(prefix));
+    const values = await Promise.all(
+      keys.map((key) => this.client.getItem(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)));
+  }
+}

package/src/clients/index.js

@@ -0,0 +1,21 @@
+import cloudflare from "./cloudflare.js";
+import cookie from "./cookie.js";
+import etcd from "./etcd.js";
+import file from "./file.js";
+import forage from "./forage.js";
+import level from "./level.js";
+import memory from "./memory.js";
+import redis from "./redis.js";
+import storage from "./storage.js";
+
+export default {
+  cloudflare,
+  cookie,
+  etcd,
+  file,
+  forage,
+  level,
+  memory,
+  redis,
+  storage,
+};

package/src/clients/level.js

@@ -0,0 +1,45 @@
+// 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";
+  }
+
+  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);
+  }
+
+  async entries(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();
+    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();
+  }
+}

package/src/clients/memory.js

@@ -0,0 +1,38 @@
+// 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;
+  }
+
+  constructor(client) {
+    this.client = client;
+  }
+
+  get(key) {
+    return this.client.get(key) ?? null;
+  }
+
+  set(key, data) {
+    this.client.set(key, data);
+  }
+
+  del(key) {
+    this.client.delete(key);
+  }
+
+  // Group methods
+  entries(prefix = "") {
+    const entries = [...this.client.entries()];
+    return entries.filter((p) => p[0].startsWith(prefix));
+  }
+
+  clear(prefix = "") {
+    // Delete the whole dataset
+    if (!prefix) return this.client.clear();
+
+    // Delete them in a map
+    const list = this.entries(prefix);
+    return Promise.all(list.map((e) => e[0]).map((k) => this.del(k)));
+  }
+}

package/src/clients/redis.js

@@ -0,0 +1,56 @@
+// Use a redis client to back up the store
+export default class Redis {
+  // 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 && 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);
+  }
+
+  async set(key, value, { expires } = {}) {
+    if (value === null || expires === 0) {
+      return this.client.del(key);
+    }
+
+    const EX = expires ? Math.round(expires) : undefined;
+    await this.client.set(key, JSON.stringify(value), { EX });
+    return key;
+  }
+
+  async has(key) {
+    return Boolean(await this.client.exists(key));
+  }
+
+  // Group methods
+  async keys(prefix = "") {
+    return this.client.keys(prefix + "*");
+  }
+
+  async entries(prefix = "") {
+    const keys = await this.client.keys(prefix + "*");
+    const values = await Promise.all(keys.map((k) => this.get(k)));
+    return keys.map((k, i) => [k, values[i]]);
+  }
+
+  async clear(prefix = "") {
+    if (!prefix) return this.client.flushAll();
+
+    const list = await this.keys(prefix);
+    return Promise.all(list.map((k) => this.set(k, null)));
+  }
+
+  async close() {
+    return this.client.quit();
+  }
+}

package/src/clients/storage.js

@@ -0,0 +1,43 @@
+// A client that uses a single file (JSON) as a store
+export default class WebStorage {
+  // 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) {
+    if (data === null) {
+      this.client.removeItem(key);
+    } else {
+      this.client.setItem(key, JSON.stringify(data));
+    }
+    return key;
+  }
+
+  // Group methods
+  entries(prefix = "") {
+    const entries = Object.entries(this.client);
+    return entries
+      .map((p) => [p[0], p[1] ? JSON.parse(p[1]) : null])
+      .filter((p) => p[0].startsWith(prefix));
+  }
+
+  clear(prefix = "") {
+    // Delete the whole store
+    if (!prefix) return this.client.clear();
+
+    // Delete them in a map
+    return this.entries(prefix).map((e) => this.set(e[0], null));
+  }
+}