polystore 0.15.13 → 0.16.0

package/src/index.js

@@ -1,278 +0,0 @@
-import clients from "./clients/index.js";
-import { createId, parse, unix } from "./utils.js";
-
-class Store {
-  PREFIX = "";
-
-  constructor(clientPromise) {
-    this.promise = Promise.resolve(clientPromise).then(async (client) => {
-      this.client = this.#find(client);
-      this.#validate(this.client);
-      this.promise = null;
-      await this.client.promise;
-      return client;
-    });
-  }
-
-  #find(store) {
-    // Already a fully compliant KV store
-    if (store instanceof Store) return store.client;
-
-    // One of the supported ones, so we receive an instance and
-    // wrap it with the client wrapper
-    for (let client of Object.values(clients)) {
-      if (client.test && client.test(store)) {
-        return new client(store);
-      }
-    }
-
-    // We get passed a class
-    if (
-      typeof store === "function" &&
-      /^class\s/.test(Function.prototype.toString.call(store))
-    ) {
-      return new store();
-    }
-
-    // A raw one, we just receive the single instance to use directly
-    return store;
-  }
-
-  #validate(client) {
-    if (!client) throw new Error("No client received");
-    if (!client.set || !client.get || !client.iterate) {
-      throw new Error("Client should have .get(), .set() and .iterate()");
-    }
-
-    if (!client.EXPIRES) {
-      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.`,
-          );
-        }
-      }
-    }
-  }
-
-  // Check if the given data is fresh or not; if
-  #isFresh(data, key) {
-    // Should never happen, but COULD happen; schedule it for
-    // removal and mark it as stale
-    if (!data || !data.value || typeof data !== "object") {
-      if (key) this.del(key);
-      return false;
-    }
-
-    // It never expires, so keep it
-    if (data.expires === null) return true;
-
-    // It's fresh, keep it
-    if (data.expires > Date.now()) return true;
-
-    // It's expired, remove it
-    if (key) this.del(key);
-    return false;
-  }
-
-  async add(value, options = {}) {
-    await this.promise;
-    let expires = parse(options.expire ?? options.expires);
-
-    // Use the underlying one from the client if found
-    if (this.client.add) {
-      if (this.client.EXPIRES) {
-        return await this.client.add(this.PREFIX, value, { expires });
-      }
-
-      // In the data we need the timestamp since we need it "absolute":
-      expires = unix(expires);
-      const key = await this.client.add(this.PREFIX, { expires, value });
-      return key;
-    }
-
-    const key = createId();
-    return this.set(key, value, { expires });
-  }
-
-  async set(key, value, options = {}) {
-    await this.promise;
-    const id = this.PREFIX + key;
-    let expires = parse(options.expire ?? options.expires);
-
-    // Quick delete
-    if (value === null || (typeof expires === "number" && expires <= 0)) {
-      return this.del(id);
-    }
-
-    // The client manages the expiration, so let it manage it
-    if (this.client.EXPIRES) {
-      await this.client.set(id, value, { expires });
-      return key;
-    }
-
-    // In the data we need the timestamp since we need it "absolute":
-    expires = unix(expires);
-    await this.client.set(id, { expires, value });
-    return key;
-  }
-
-  async get(key) {
-    await this.promise;
-    const id = this.PREFIX + key;
-
-    const data = (await this.client.get(id)) ?? null;
-
-    // No value; nothing to do/check
-    if (data === null) return null;
-
-    // The client already managed expiration and there's STILL some data,
-    // so we can assume it's the raw user data
-    if (this.client.EXPIRES) return data;
-
-    if (!this.#isFresh(data, key)) return null;
-    return data.value;
-  }
-
-  async has(key) {
-    await this.promise;
-    const id = this.PREFIX + key;
-
-    if (this.client.has) {
-      return this.client.has(id);
-    }
-
-    return (await this.get(key)) !== null;
-  }
-
-  async del(key) {
-    await this.promise;
-    const id = this.PREFIX + key;
-
-    if (this.client.del) {
-      await this.client.del(id);
-      return key;
-    }
-
-    await this.client.set(id, null, { expires: 0 });
-    return key;
-  }
-
-  async *[Symbol.asyncIterator]() {
-    await this.promise;
-
-    for await (const [name, data] of this.client.iterate(this.PREFIX)) {
-      const key = name.slice(this.PREFIX.length);
-      if (this.client.EXPIRES) {
-        yield [key, data];
-      } else if (this.#isFresh(data, key)) {
-        yield [key, data.value];
-      }
-    }
-  }
-
-  async entries() {
-    await this.promise;
-
-    // Cut the key to size
-    const trim = (key) => key.slice(this.PREFIX.length);
-
-    let list = [];
-    if (this.client.entries) {
-      const entries = await this.client.entries(this.PREFIX);
-      list = entries.map(([key, value]) => [trim(key), value]);
-    } else {
-      for await (const [key, value] of this.client.iterate(this.PREFIX)) {
-        list.push([trim(key), value]);
-      }
-    }
-
-    // The client already manages the expiration, so we can assume
-    // that at this point, all entries are not-expired
-    if (this.client.EXPIRES) return list;
-
-    // We need to do manual expiration checking
-    return list
-      .filter(([key, data]) => this.#isFresh(data, key))
-      .map(([key, data]) => [key, data.value]);
-  }
-
-  async keys() {
-    await this.promise;
-
-    if (this.client.keys) {
-      const list = await this.client.keys(this.PREFIX);
-      if (!this.PREFIX) return list;
-      return list.map((k) => k.slice(this.PREFIX.length));
-    }
-
-    const entries = await this.entries();
-    return entries.map((e) => e[0]);
-  }
-
-  async values() {
-    await this.promise;
-
-    if (this.client.values) {
-      const list = this.client.values(this.PREFIX);
-      if (this.client.EXPIRES) return list;
-      return list
-        .filter((data) => this.#isFresh(data))
-        .map((data) => data.value);
-    }
-
-    const entries = await this.entries();
-    return entries.map((e) => e[1]);
-  }
-
-  async all() {
-    await this.promise;
-
-    if (this.client.all) {
-      const obj = await this.client.all(this.PREFIX);
-      if (!this.PREFIX) return obj;
-      const all = {};
-      for (let key in obj) {
-        all[key.slice(this.PREFIX.length)] = obj[key];
-      }
-      return all;
-    }
-
-    const entries = await this.entries();
-    return Object.fromEntries(entries);
-  }
-
-  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);
-    }
-
-    const keys = await this.keys();
-    // Note: this gives trouble of concurrent deletes in the FS
-    await Promise.all(keys.map((key) => this.del(key)));
-  }
-
-  prefix(prefix = "") {
-    const store = new Store(
-      Promise.resolve(this.promise).then(() => this.client),
-    );
-    store.PREFIX = this.PREFIX + prefix;
-    return store;
-  }
-
-  async close() {
-    await this.promise;
-
-    if (this.client.close) {
-      return this.client.close();
-    }
-  }
-}
-
-export default (client) => new Store(client);

package/src/server.js

@@ -1,81 +0,0 @@
-// This is an example server implementation of the HTTP library!
-import http from "node:http";
-import kv from "./index.js";
-
-// Add/remove the key whether you want the API to be behind a key
-const key = null;
-// const key = 'MY-SECRET-KEY';
-
-// Modify this to use any sub-store as desired. It's nice
-// to use polystore itself for the polystore server library!'
-const store = kv(new Map());
-
-// Some reply helpers
-const notFound = () => new Response(null, { status: 404 });
-const sendJson = (data, status = 200) => {
-  const body = JSON.stringify(data);
-  const headers = { "content-type": "application/json" };
-  return new Response(body, { status, headers });
-};
-
-async function fetch({ method, url, body }) {
-  method = method.toLowerCase();
-  url = new URL(url);
-  let [, id] = url.pathname.split("/");
-  id = decodeURIComponent(id);
-  const expires = Number(url.searchParams.get("expires")) || null;
-  const prefix = url.searchParams.get("prefix") || null;
-
-  let local = store;
-  if (prefix) local = store.prefix(prefix);
-
-  if (method === "get") {
-    if (id === "ping") return new Response(null, { status: 200 });
-    if (!id) return sendJson(await local.all());
-    const data = await local.get(id);
-    if (data === null) return notFound();
-    return sendJson(data);
-  }
-
-  if (method === "put") {
-    if (!id) return notFound();
-    const data = await new Response(body).json();
-    if (!data) return notFound();
-    await local.set(id, data, { expires });
-    return sendJson(id);
-  }
-
-  if (method === "delete" && id) {
-    await local.del(id);
-    return sendJson(id);
-  }
-
-  return notFound();
-}
-
-// http or express server-like handler:
-async function server(req, res) {
-  // Secure it behind a key (optional)
-  if (key && req.headers.get("x-api-key") !== key) return res.send(401);
-
-  const url = new URL(req.url, "http://localhost:3000/").href;
-  const reply = await fetch({ ...req, url });
-  res.writeHead(reply.status, null, reply.headers || {});
-  if (reply.body) res.write(reply.body);
-  res.end();
-}
-
-function start(port = 3000) {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer(server);
-    server.on("clientError", (error, socket) => {
-      reject(error);
-      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-    });
-    server.listen(port, resolve);
-    return () => server.close();
-  });
-}
-
-export { fetch, server, start };
-export default { fetch, server, start };

package/src/utils.js

@@ -1,47 +0,0 @@
-const times = /(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/iu;
-
-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;
-parse.week = parse.wk = parse.w = parse.d * 7;
-parse.year = parse.yr = parse.y = parse.d * 365.25;
-parse.month = parse.b = parse.y / 12;
-
-// Returns the time in seconds
-export function parse(str) {
-  if (str === null || str === undefined) return null;
-  if (typeof str === "number") return str;
-  // ignore commas/placeholders
-  str = str.toLowerCase().replace(/[,_]/g, "");
-  let [_, value, units] = times.exec(str) || [];
-  if (!units) return null;
-  const unitValue = parse[units] || parse[units.replace(/s$/, "")];
-  if (!unitValue) return null;
-  const result = unitValue * parseFloat(value, 10);
-  return Math.abs(Math.round(result * 1000) / 1000);
-}
-
-// "nanoid" imported manually
-// Something about improved GZIP performance with this string
-const urlAlphabet =
-  "useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict";
-
-export function createId() {
-  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;
-}
-
-export function unix(expires) {
-  const now = new Date().getTime();
-  return expires === null ? null : now + expires * 1000;
-}