memx 0.0.1 → 0.0.5

package/dist/index.mjs

@@ -295,6 +295,9 @@ function typedArrayFlags(value) {
   const flags = isUint8Array(value) ? 3402235920 /* UINT8ARRAY */ : isUint8ClampedArray(value) ? 3402235921 /* UINT8CLAMPEDARRAY */ : isUint16Array(value) ? 3402235922 /* UINT16ARRAY */ : isUint32Array(value) ? 3402235923 /* UINT32ARRAY */ : isInt8Array(value) ? 3402235924 /* INT8ARRAY */ : isInt16Array(value) ? 3402235925 /* INT16ARRAY */ : isInt32Array(value) ? 3402235926 /* INT32ARRAY */ : isBigUint64Array(value) ? 3402235927 /* BIGUINT64ARRAY */ : isBigInt64Array(value) ? 3402235928 /* BIGINT64ARRAY */ : isFloat32Array(value) ? 3402235929 /* FLOAT32ARRAY */ : isFloat64Array(value) ? 3402235930 /* FLOAT64ARRAY */ : assert2.fail("Unsupported kind of TypedArray");
   return flags;
 }
+function logPromiseError(promise, message) {
+  return promise.catch((error) => console.log(message, error)).then(() => void 0);
+}
 
 // src/connection.ts
 import assert3 from "assert";
@@ -438,6 +441,153 @@ var Connection = class {
   }
 };
 
+// src/fake.ts
+function toExp(ttl = 0) {
+  if (ttl === 0)
+    return Number.MAX_SAFE_INTEGER;
+  return Date.now() + ttl * 1e3;
+}
+var FakeAdapter = class {
+  #cache = /* @__PURE__ */ new Map();
+  #cas = 1n;
+  ttl = 0;
+  #get(key) {
+    if (key.length > 250)
+      throw new TypeError(`Key too long (len=${key.length})`);
+    const entry = this.#cache.get(key);
+    if (!entry)
+      return;
+    if (Date.now() > entry.exp) {
+      this.#cache.delete(key);
+      return;
+    }
+    return entry;
+  }
+  #set(key, value, flags, ttl) {
+    this.#cache.set(key, {
+      value,
+      flags: flags || 0,
+      cas: ++this.#cas,
+      exp: toExp(ttl)
+    });
+    return this.#cas;
+  }
+  async get(key) {
+    const entry = this.#get(key);
+    if (!entry)
+      return;
+    return {
+      value: entry.value,
+      flags: entry.flags,
+      cas: entry.cas,
+      recycle: () => void 0
+    };
+  }
+  async gat(key, ttl) {
+    const entry = this.#get(key);
+    if (!entry)
+      return;
+    entry.exp = toExp(ttl);
+    return {
+      value: entry.value,
+      flags: entry.flags,
+      cas: entry.cas,
+      recycle: () => void 0
+    };
+  }
+  async touch(key, ttl) {
+    const entry = this.#get(key);
+    if (entry)
+      entry.exp = toExp(ttl);
+    return !!entry;
+  }
+  async set(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
+      return;
+    }
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async add(key, value, options = {}) {
+    if (this.#get(key))
+      return;
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async replace(key, value, options = {}) {
+    if (!this.#get(key))
+      return;
+    return this.#set(key, value, options.flags, options.ttl);
+  }
+  async append(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (!entry)
+      return false;
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return false;
+    entry.value = Buffer.concat([entry.value, value]);
+    return true;
+  }
+  async prepend(key, value, options = {}) {
+    const entry = this.#get(key);
+    if (!entry)
+      return false;
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return false;
+    entry.value = Buffer.concat([value, entry.value]);
+    return true;
+  }
+  async #counter(key, delta, options) {
+    const entry = this.#get(key);
+    if (!entry) {
+      if (options.initial !== void 0) {
+        const value = Buffer.from(options.initial.toString());
+        this.#set(key, value, void 0, options.ttl);
+        return { value: BigInt(options.initial), cas: this.#cas };
+      } else {
+        return;
+      }
+    }
+    if (options.cas !== void 0 && options.cas !== entry.cas)
+      return;
+    try {
+      const value = BigInt(entry.value.toString("utf-8")) + BigInt(delta);
+      this.#set(key, Buffer.from(value.toString()), void 0, options.ttl);
+      return { value, cas: this.#cas };
+    } catch (error) {
+      throw new TypeError(`${error.message} (status=NON_NUMERIC_VALUE, key=${key})`);
+    }
+  }
+  increment(key, delta = 1n, options = {}) {
+    return this.#counter(key, delta, options);
+  }
+  decrement(key, delta = 1n, options = {}) {
+    return this.#counter(key, -delta, options);
+  }
+  async delete(key, options = {}) {
+    const entry = this.#get(key);
+    if (entry && options.cas !== void 0 && entry.cas !== options.cas) {
+      return false;
+    }
+    return this.#cache.delete(key);
+  }
+  async flush(ttl) {
+    if (!ttl)
+      return this.#cache.clear();
+    const wait = toExp(ttl) - Date.now();
+    setTimeout(() => this.#cache.clear(), wait);
+  }
+  async noop() {
+  }
+  async quit() {
+  }
+  async version() {
+    return { fake: "0.0.0-fake" };
+  }
+  async stats() {
+    return { fake: { version: "0.0.0-fake" } };
+  }
+};
+
 // src/server.ts
 var statsBigInt = [
   "auth_cmds",
@@ -585,10 +735,9 @@ var ServerAdapter = class {
       throw new Error(`Key too long (len=${keyLength})`);
     return keyLength;
   }
-  async get(key, options = {}) {
-    const { ttl } = options;
+  async #get(key, ttl) {
     let keyOffset = 0;
-    if (ttl)
+    if (ttl !== void 0)
       keyOffset = this.#buffer.writeUInt32BE(ttl);
     const keyLength = this.#writeKey(key, keyOffset);
     const [response] = await this.#connection.send({
@@ -614,9 +763,15 @@ var ServerAdapter = class {
         fail(response, key);
     }
   }
-  async touch(key, options = {}) {
-    const { ttl = this.#ttl } = options;
-    const keyOffset = this.#buffer.writeUInt32BE(ttl);
+  async get(key) {
+    return this.#get(key);
+  }
+  async gat(key, ttl) {
+    return this.#get(key, ttl || 2592e3);
+  }
+  async touch(key, ttl) {
+    const timeToLive = ttl ?? this.#ttl;
+    const keyOffset = this.#buffer.writeUInt32BE(timeToLive);
     const keyLength = this.#writeKey(key, keyOffset);
     const [response] = await this.#connection.send({
       opcode: 28 /* TOUCH */,
@@ -863,6 +1018,7 @@ var ServerAdapter = class {
 };
 
 // src/cluster.ts
+import assert4 from "assert";
 function parseHosts(hosts) {
   const result = [];
   if (!hosts)
@@ -876,6 +1032,7 @@ function parseHosts(hosts) {
 }
 var ClusterAdapter = class {
   servers;
+  ttl;
   constructor(serversOrOptions) {
     if (Array.isArray(serversOrOptions)) {
       this.servers = [...serversOrOptions];
@@ -903,6 +1060,10 @@ var ClusterAdapter = class {
       throw new Error("No hosts configured");
     if (this.servers.length === 1)
       this.server = () => this.servers[0];
+    this.ttl = this.servers[0].ttl;
+    this.servers.slice(1).forEach((server) => {
+      assert4.equal(server.ttl, this.ttl, `TTL Mismatch (${server.ttl} != ${this.ttl})`);
+    });
     Object.freeze(this.servers);
   }
   server(key) {
@@ -912,11 +1073,14 @@ var ClusterAdapter = class {
       hash = hash * 31 + key.charCodeAt(i);
     return this.servers[hash % this.servers.length];
   }
-  get(key, options) {
-    return this.server(key).get(key, options);
+  get(key) {
+    return this.server(key).get(key);
   }
-  touch(key, options) {
-    return this.server(key).touch(key, options);
+  gat(key, ttl) {
+    return this.server(key).gat(key, ttl);
+  }
+  touch(key, ttl) {
+    return this.server(key).touch(key, ttl);
   }
   set(key, value, options) {
     return this.server(key).set(key, value, options);
@@ -962,8 +1126,34 @@ var ClusterAdapter = class {
 };
 
 // src/client.ts
-import assert4 from "assert";
+import assert5 from "assert";
 import { isTypedArray } from "util/types";
+function replacer(key, value) {
+  if (typeof this[key] === "bigint")
+    return ["\0__$BIGINT$__\0", this[key].toString()];
+  if (this[key] instanceof Date)
+    return ["\0__$DATE$__\0", this[key].toISOString()];
+  if (this[key] instanceof Set)
+    return ["\0__$SET$__\0", ...value];
+  if (this[key] instanceof Map)
+    return ["\0__$MAP$__\0", ...value.entries()];
+  return value;
+}
+function reviver(key, value) {
+  if (Array.isArray(value)) {
+    switch (value[0]) {
+      case "\0__$BIGINT$__\0":
+        return BigInt(value[1]);
+      case "\0__$DATE$__\0":
+        return new Date(value[1]);
+      case "\0__$SET$__\0":
+        return new Set(value.slice(1));
+      case "\0__$MAP$__\0":
+        return new Map(value.slice(1));
+    }
+  }
+  return value;
+}
 function toBuffer(value, options) {
   if (Buffer.isBuffer(value))
     return [value, __spreadProps(__spreadValues({}, options), { flags: 0 /* BUFFER */ })];
@@ -979,7 +1169,7 @@ function toBuffer(value, options) {
     case "object":
       break;
     default:
-      assert4.fail(`Unable to store value of type "${typeof value}"`);
+      assert5.fail(`Unable to store value of type "${typeof value}"`);
   }
   if (isTypedArray(value)) {
     const flags = typedArrayFlags(value);
@@ -988,15 +1178,63 @@ function toBuffer(value, options) {
   }
   if (value === null)
     return [EMPTY_BUFFER, __spreadProps(__spreadValues({}, options), { flags: 3402235918 /* NULL */ })];
-  return [Buffer.from(JSON.stringify(value), "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
+  const json = JSON.stringify(value, replacer);
+  return [Buffer.from(json, "utf-8"), __spreadProps(__spreadValues({}, options), { flags: 3402235919 /* JSON */ })];
+}
+function fromBuffer(result) {
+  try {
+    const { flags, value, cas } = result;
+    switch (flags) {
+      case 3402235904 /* BIGINT */:
+        return { value: BigInt(value.toString("utf-8")), cas };
+      case 3402235905 /* BOOLEAN */:
+        return { value: !!value[0], cas };
+      case 3402235906 /* NUMBER */:
+        return { value: Number(value.toString("utf-8")), cas };
+      case 3402235907 /* STRING */:
+        return { value: value.toString("utf-8"), cas };
+      case 3402235918 /* NULL */:
+        return { value: null, cas };
+      case 3402235919 /* JSON */:
+        return { value: JSON.parse(value.toString("utf-8"), reviver), cas };
+      case 3402235920 /* UINT8ARRAY */:
+        return { value: makeTypedArray(Uint8Array, value), cas };
+      case 3402235921 /* UINT8CLAMPEDARRAY */:
+        return { value: makeTypedArray(Uint8ClampedArray, value), cas };
+      case 3402235922 /* UINT16ARRAY */:
+        return { value: makeTypedArray(Uint16Array, value), cas };
+      case 3402235923 /* UINT32ARRAY */:
+        return { value: makeTypedArray(Uint32Array, value), cas };
+      case 3402235924 /* INT8ARRAY */:
+        return { value: makeTypedArray(Int8Array, value), cas };
+      case 3402235925 /* INT16ARRAY */:
+        return { value: makeTypedArray(Int16Array, value), cas };
+      case 3402235926 /* INT32ARRAY */:
+        return { value: makeTypedArray(Int32Array, value), cas };
+      case 3402235927 /* BIGUINT64ARRAY */:
+        return { value: makeTypedArray(BigUint64Array, value), cas };
+      case 3402235928 /* BIGINT64ARRAY */:
+        return { value: makeTypedArray(BigInt64Array, value), cas };
+      case 3402235929 /* FLOAT32ARRAY */:
+        return { value: makeTypedArray(Float32Array, value), cas };
+      case 3402235930 /* FLOAT64ARRAY */:
+        return { value: makeTypedArray(Float64Array, value), cas };
+      case 0 /* BUFFER */:
+      default:
+        return { value: Buffer.from(value), cas };
+    }
+  } finally {
+    result.recycle();
+  }
 }
-function makeTypedArray(constructor, source, bytesPerValue) {
+function makeTypedArray(constructor, source) {
   const clone = Buffer.from(source);
   const { buffer, byteOffset, byteLength } = clone;
-  return new constructor(buffer, byteOffset, byteLength / bytesPerValue);
+  return new constructor(buffer, byteOffset, byteLength / constructor.BYTES_PER_ELEMENT);
 }
 var Client = class {
   #adapter;
+  #prefix;
   constructor(adapterOrOptions) {
     if (!adapterOrOptions) {
       this.#adapter = new ClusterAdapter();
@@ -1005,96 +1243,73 @@ var Client = class {
     } else if ("hosts" in adapterOrOptions) {
       this.#adapter = new ClusterAdapter(adapterOrOptions);
     }
-    assert4(this.#adapter, "Invalid client constructor arguments");
+    this.#prefix = "";
+    assert5(this.#adapter, "Invalid client constructor arguments");
   }
   get adapter() {
     return this.#adapter;
   }
-  async get(key, options) {
-    const result = await this.#adapter.get(key, options);
-    if (!result)
-      return;
-    try {
-      const { flags, value, cas } = result;
-      switch (flags) {
-        case 3402235904 /* BIGINT */:
-          return { value: BigInt(value.toString("utf-8")), cas };
-        case 3402235905 /* BOOLEAN */:
-          return { value: !!value[0], cas };
-        case 3402235906 /* NUMBER */:
-          return { value: Number(value.toString("utf-8")), cas };
-        case 3402235907 /* STRING */:
-          return { value: value.toString("utf-8"), cas };
-        case 3402235918 /* NULL */:
-          return { value: null, cas };
-        case 3402235919 /* JSON */:
-          return { value: JSON.parse(value.toString("utf-8")), cas };
-        case 3402235920 /* UINT8ARRAY */:
-          return { value: makeTypedArray(Uint8Array, value, 1), cas };
-        case 3402235921 /* UINT8CLAMPEDARRAY */:
-          return { value: makeTypedArray(Uint8ClampedArray, value, 1), cas };
-        case 3402235922 /* UINT16ARRAY */:
-          return { value: makeTypedArray(Uint16Array, value, 2), cas };
-        case 3402235923 /* UINT32ARRAY */:
-          return { value: makeTypedArray(Uint32Array, value, 4), cas };
-        case 3402235924 /* INT8ARRAY */:
-          return { value: makeTypedArray(Int8Array, value, 1), cas };
-        case 3402235925 /* INT16ARRAY */:
-          return { value: makeTypedArray(Int16Array, value, 2), cas };
-        case 3402235926 /* INT32ARRAY */:
-          return { value: makeTypedArray(Int32Array, value, 4), cas };
-        case 3402235927 /* BIGUINT64ARRAY */:
-          return { value: makeTypedArray(BigUint64Array, value, 8), cas };
-        case 3402235928 /* BIGINT64ARRAY */:
-          return { value: makeTypedArray(BigInt64Array, value, 8), cas };
-        case 3402235929 /* FLOAT32ARRAY */:
-          return { value: makeTypedArray(Float32Array, value, 4), cas };
-        case 3402235930 /* FLOAT64ARRAY */:
-          return { value: makeTypedArray(Float64Array, value, 8), cas };
-        case 0 /* BUFFER */:
-        default:
-          return { value: Buffer.from(value), cas };
-      }
-    } finally {
-      result.recycle();
-    }
+  get prefix() {
+    return this.#prefix;
+  }
+  withPrefix(prefix) {
+    assert5(prefix, "Invalid prefix");
+    const client = new Client(this.#adapter);
+    client.#prefix = prefix;
+    return client;
+  }
+  async get(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result).value;
+  }
+  async gat(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result).value;
+  }
+  async getc(key) {
+    const result = await this.#adapter.get(this.#prefix + key);
+    return result && fromBuffer(result);
+  }
+  async gatc(key, ttl) {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl);
+    return result && fromBuffer(result);
   }
   async set(key, value, options) {
-    return this.#adapter.set(key, ...toBuffer(value, options));
+    return this.#adapter.set(this.#prefix + key, ...toBuffer(value, options));
   }
   async add(key, value, options) {
-    return this.#adapter.add(key, ...toBuffer(value, options));
+    return this.#adapter.add(this.#prefix + key, ...toBuffer(value, options));
   }
   async replace(key, value, options) {
-    return this.#adapter.replace(key, ...toBuffer(value, options));
+    return this.#adapter.replace(this.#prefix + key, ...toBuffer(value, options));
   }
   append(key, value, options) {
-    return this.#adapter.append(key, ...toBuffer(value, options));
+    return this.#adapter.append(this.#prefix + key, ...toBuffer(value, options));
   }
   prepend(key, value, options) {
-    return this.#adapter.prepend(key, ...toBuffer(value, options));
+    return this.#adapter.prepend(this.#prefix + key, ...toBuffer(value, options));
   }
   async increment(key, delta, options) {
-    const counter = await this.#adapter.increment(key, delta, options);
-    if (counter && options && options.initial !== void 0 && counter.value === BigInt(options.initial)) {
+    const counter = await this.#adapter.increment(this.#prefix + key, delta, options);
+    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
       counter.cas = cas ?? counter.cas;
     }
     return counter;
   }
   async decrement(key, delta, options) {
-    const counter = await this.#adapter.decrement(key, delta, options);
-    if (counter && options && options.initial !== void 0 && counter.value === BigInt(options.initial)) {
+    const counter = await this.#adapter.decrement(this.#prefix + key, delta, options);
+    if ((options == null ? void 0 : options.initial) !== void 0 && (counter == null ? void 0 : counter.value) === BigInt(options.initial)) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl });
       counter.cas = cas ?? counter.cas;
     }
     return counter;
   }
-  touch(key, options) {
-    return this.#adapter.touch(key, options);
+  touch(key, ttl) {
+    return this.#adapter.touch(this.#prefix + key, ttl);
   }
   delete(key, options) {
-    return this.#adapter.delete(key, options);
+    return this.#adapter.delete(this.#prefix + key, options);
   }
   flush(ttl) {
     return this.#adapter.flush(ttl);
@@ -1112,9 +1327,139 @@ var Client = class {
     return this.#adapter.stats();
   }
 };
+
+// src/utils.ts
+import assert6 from "assert";
+var Factory = class {
+  #factory;
+  #client;
+  #ttl;
+  constructor(client, factory, ttl) {
+    assert6(typeof factory === "function", "Invalid or no factory specified");
+    assert6(client, "No client specified");
+    this.#factory = factory;
+    this.#client = client;
+    this.#ttl = ttl;
+  }
+  async get(key) {
+    const cached = await this.#client.getc(key);
+    if (cached) {
+      void logPromiseError(this.#client.touch(key), `Factory error touching key "${this.#client.prefix}${key}"`);
+      return cached.value;
+    }
+    const created = await this.#factory(key);
+    if (created) {
+      void logPromiseError(this.#client.set(key, created, { ttl: this.#ttl }), `Factory error setting key "${this.#client.prefix}${key}"`);
+    }
+    return created;
+  }
+};
+var Bundle = class {
+  #client;
+  #name;
+  #ttl;
+  constructor(client, name, ttl) {
+    assert6(client, "No client specified");
+    assert6(name, "No bundle name specified");
+    this.#client = client;
+    this.#name = name;
+    this.#ttl = ttl || 0;
+  }
+  async #appendKey(key) {
+    await logPromiseError((async () => {
+      const added = await this.#client.add(this.#name, key, { ttl: this.#ttl });
+      if (!added) {
+        await this.#client.append(this.#name, `\0${key}`);
+        await this.#client.touch(this.#name, this.#ttl);
+      }
+    })(), `Bundle "${this.#client.prefix}${this.#name}" error recording key "${key}"`);
+  }
+  async #removeKey(key) {
+    await logPromiseError((async () => {
+      const result = await this.#client.getc(this.#name);
+      if (!result)
+        return;
+      const keys = result.value.split("\0").filter((k) => k !== key).join("\0");
+      await this.#client.set(this.#name, keys, { cas: result.cas, ttl: this.#ttl });
+    })(), `Bundle "${this.#client.prefix}${this.#name}" error clearing key "${key}"`);
+  }
+  async add(key, value) {
+    await this.#client.set(`${this.#name}:${key}`, value, { ttl: this.#ttl });
+    await this.#appendKey(key);
+  }
+  async get(key) {
+    const result = await this.#client.getc(`${this.#name}:${key}`);
+    if (result)
+      return result.value;
+    await this.#removeKey(key);
+  }
+  async delete(key) {
+    await this.#client.delete(`${this.#name}:${key}`);
+    await this.#removeKey(key);
+  }
+  async list() {
+    const result = await this.#client.getc(this.#name);
+    if (!result)
+      return {};
+    const results = {};
+    const promises = [];
+    for (const key of new Set(result.value.split("\0"))) {
+      promises.push(this.#client.getc(`${this.#name}:${key}`).then((result2) => {
+        if (result2)
+          results[key] = result2.value;
+      }));
+    }
+    await Promise.all(promises);
+    await logPromiseError(this.#client.set(this.#name, Object.keys(results).join("\0"), { cas: result.cas, ttl: this.#ttl }), `Bundle "${this.#client.prefix}${this.#name}" error compacting keys`);
+    return results;
+  }
+};
+var PoorManLock = class {
+  #client;
+  #name;
+  constructor(client, name) {
+    assert6(client, "No client specified");
+    assert6(name, "No lock name specified");
+    this.#client = client;
+    this.#name = name;
+  }
+  async execute(executor, options) {
+    const { timeout = 5e3, owner = false } = options || {};
+    const end = Date.now() + timeout;
+    let cas;
+    do {
+      cas = await this.#client.add(this.#name, owner, { ttl: 2 });
+      if (cas !== void 0)
+        break;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } while (Date.now() < end);
+    if (cas === void 0) {
+      const other = await this.#client.getc(this.#name);
+      const owner2 = other && other.value ? `"${other.value}"` : "anonymous";
+      throw new Error(`Lock "${this.#client.prefix}${this.#name}" timeout (owner=${owner2})`);
+    }
+    const interval = setInterval(() => {
+      void logPromiseError((async () => {
+        const replaced = await this.#client.replace(this.#name, owner, { ttl: 2, cas });
+        assert6(replaced !== void 0, `Lock "${this.#client.prefix}${this.#name}" not replaced`);
+        cas = replaced;
+      })(), `Error extending lock "${this.#client.prefix}${this.#name}"`);
+    }, 100);
+    try {
+      return await executor();
+    } finally {
+      clearInterval(interval);
+      await logPromiseError(this.#client.delete(this.#name, { cas }), `Error deleting lock "${this.#client.prefix}${this.#name}"`);
+    }
+  }
+};
 export {
+  Bundle,
   Client,
   ClusterAdapter,
+  Factory,
+  FakeAdapter,
+  PoorManLock,
   ServerAdapter,
   connection_exports as connection,
   constants_exports as constants,