memx 0.0.1 → 0.0.5

package/src/client.ts

@@ -4,9 +4,32 @@ import { isTypedArray } from 'util/types'
 import { ClusterAdapter, ClusterOptions } from './cluster'
 import { EMPTY_BUFFER, FLAGS } from './constants'
 import { typedArrayFlags } from './internals'
-import { Adapter, Counter, Stats } from './types'
+import { Adapter, AdapterResult, Counter, Stats } from './types'
+
+/** JSON replacere function serializing `bigint`, {@link Date}, {@link Set} and {@link Map}. */
+function replacer(this: any, key: string, value: any): any {
+  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 toBuffer<T>(value: any, options: T): [ Buffer, T & { flags: number } ] {
+/** JSON reviver function deserializing `bigint`, {@link Date}, {@link Set} and {@link Map}. */
+function reviver(this: any, key: string, value: any): any {
+  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
+}
+
+/** Convert a {@link Serializable} or {@link Appendable} value into a {@link Buffer}. */
+function toBuffer<T>(value: Serializable | Appendable, options: T): [ Buffer, T & { flags: number } ] {
   if (Buffer.isBuffer(value)) return [ value, { ...options, flags: FLAGS.BUFFER } ]
 
   switch (typeof value) {
@@ -35,32 +58,104 @@ function toBuffer<T>(value: any, options: T): [ Buffer, T & { flags: number } ]
   if (value === null) return [ EMPTY_BUFFER, { ...options, flags: FLAGS.NULL } ]
 
   // any other "object" gets serialized as JSON
-  return [ Buffer.from(JSON.stringify(value), 'utf-8'), { ...options, flags: FLAGS.JSON } ]
+  const json = JSON.stringify(value, replacer)
+  return [ Buffer.from(json, 'utf-8'), { ...options, flags: FLAGS.JSON } ]
+}
+
+/** Node's own types doesn't provide this... Make our own */
+type TypedArrayConstructor<T extends NodeJS.TypedArray> = {
+  new (buffer: ArrayBuffer, offset?: number, length?: number): T
+  BYTES_PER_ELEMENT: number
 }
 
+function fromBuffer<T extends Serializable>(result: AdapterResult): ClientResult<T> {
+  try {
+    const { flags, value, cas } = result
+    switch (flags) {
+      case FLAGS.BIGINT:
+        return { value: BigInt(value.toString('utf-8')) as T, cas }
+      case FLAGS.BOOLEAN:
+        return { value: !!value[0] as T, cas }
+      case FLAGS.NUMBER:
+        return { value: Number(value.toString('utf-8' )) as T, cas }
+      case FLAGS.STRING:
+        return { value: value.toString('utf-8' ) as T, cas }
+
+      case FLAGS.NULL:
+        return { value: null as T, cas }
+      case FLAGS.JSON:
+        return { value: JSON.parse(value.toString('utf-8' ), reviver) as T, cas }
+
+      case FLAGS.UINT8ARRAY:
+        return { value: makeTypedArray(Uint8Array, value) as T, cas }
+      case FLAGS.UINT8CLAMPEDARRAY:
+        return { value: makeTypedArray(Uint8ClampedArray, value) as T, cas }
+      case FLAGS.UINT16ARRAY:
+        return { value: makeTypedArray(Uint16Array, value) as T, cas }
+      case FLAGS.UINT32ARRAY:
+        return { value: makeTypedArray(Uint32Array, value) as T, cas }
+      case FLAGS.INT8ARRAY:
+        return { value: makeTypedArray(Int8Array, value) as T, cas }
+      case FLAGS.INT16ARRAY:
+        return { value: makeTypedArray(Int16Array, value) as T, cas }
+      case FLAGS.INT32ARRAY:
+        return { value: makeTypedArray(Int32Array, value) as T, cas }
+      case FLAGS.BIGUINT64ARRAY:
+        return { value: makeTypedArray(BigUint64Array, value) as T, cas }
+      case FLAGS.BIGINT64ARRAY:
+        return { value: makeTypedArray(BigInt64Array, value) as T, cas }
+      case FLAGS.FLOAT32ARRAY:
+        return { value: makeTypedArray(Float32Array, value) as T, cas }
+      case FLAGS.FLOAT64ARRAY:
+        return { value: makeTypedArray(Float64Array, value) as T, cas }
+
+      case FLAGS.BUFFER:
+      default:
+        return { value: Buffer.from(value) as T, cas }
+    }
+  } finally {
+    result.recycle()
+  }
+}
+
+/** Create a {@link NodeJS.TypedArray} copying the contents of its source {@link Buffer} */
 function makeTypedArray<T extends NodeJS.TypedArray>(
-  constructor: new (buffer: ArrayBuffer, offset?: number, length?: number) => T,
+  constructor: TypedArrayConstructor<T>,
   source: Buffer,
-  bytesPerValue: number,
 ): T {
   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)
 }
 
+/* ========================================================================== */
+
+/** Types that can be serialized by our {@link Client}. */
 export type Serializable = bigint | string | number | boolean | null | object
+
+/** Types that can be appended/prepended by our {@link Client}. */
 export type Appendable = string | NodeJS.TypedArray
 
+/** The `ClientResult` interface associate a value with its _CAS_. */
 export interface ClientResult<T extends Serializable> {
+  /** The value returned by the {@link Client} */
   value: T
+  /** The _CAS_ of the value being returned */
   cas: bigint
 }
 
+/**
+ * A `Client` represents a high-level client for a _Memcached_ server.
+ */
 export class Client {
   #adapter!: Adapter
+  #prefix: string
 
+  /** Construct a new {@link Client} from environment variables */
   constructor()
+  /** Construct a new {@link Client} wrapping an existing `Adapter` */
   constructor(adapter: Adapter)
+  /** Construct a new {@link Client} given the specified {@link ClusterOptions} */
   constructor(options: ClusterOptions)
 
   constructor(adapterOrOptions?: Adapter | ClusterOptions) {
@@ -72,76 +167,59 @@ export class Client {
       this.#adapter = new ClusterAdapter(adapterOrOptions)
     }
 
+    this.#prefix = ''
+
     assert(this.#adapter, 'Invalid client constructor arguments')
   }
 
+  /** Return the {@link Adapter} backing this {@link Client} instance */
   get adapter(): Adapter {
     return this.#adapter
   }
 
-  async get<T extends Serializable>(key: string, options?: { ttl?: number }): Promise<ClientResult<T> | void> {
-    const result = await this.#adapter.get(key, options)
-    if (! result) return
-
-    try {
-      const { flags, value, cas } = result
-      switch (flags) {
-        case FLAGS.BIGINT:
-          return { value: BigInt(value.toString('utf-8')) as T, cas }
-        case FLAGS.BOOLEAN:
-          return { value: !!value[0] as T, cas }
-        case FLAGS.NUMBER:
-          return { value: Number(value.toString('utf-8' )) as T, cas }
-        case FLAGS.STRING:
-          return { value: value.toString('utf-8' ) as T, cas }
-
-        case FLAGS.NULL:
-          return { value: null as T, cas }
-        case FLAGS.JSON:
-          return { value: JSON.parse(value.toString('utf-8' )) as T, cas }
-
-        case FLAGS.UINT8ARRAY:
-          return { value: makeTypedArray(Uint8Array, value, 1) as T, cas }
-        case FLAGS.UINT8CLAMPEDARRAY:
-          return { value: makeTypedArray(Uint8ClampedArray, value, 1) as T, cas }
-        case FLAGS.UINT16ARRAY:
-          return { value: makeTypedArray(Uint16Array, value, 2) as T, cas }
-        case FLAGS.UINT32ARRAY:
-          return { value: makeTypedArray(Uint32Array, value, 4) as T, cas }
-        case FLAGS.INT8ARRAY:
-          return { value: makeTypedArray(Int8Array, value, 1) as T, cas }
-        case FLAGS.INT16ARRAY:
-          return { value: makeTypedArray(Int16Array, value, 2) as T, cas }
-        case FLAGS.INT32ARRAY:
-          return { value: makeTypedArray(Int32Array, value, 4) as T, cas }
-        case FLAGS.BIGUINT64ARRAY:
-          return { value: makeTypedArray(BigUint64Array, value, 8) as T, cas }
-        case FLAGS.BIGINT64ARRAY:
-          return { value: makeTypedArray(BigInt64Array, value, 8) as T, cas }
-        case FLAGS.FLOAT32ARRAY:
-          return { value: makeTypedArray(Float32Array, value, 4) as T, cas }
-        case FLAGS.FLOAT64ARRAY:
-          return { value: makeTypedArray(Float64Array, value, 8) as T, cas }
-
-        case FLAGS.BUFFER:
-        default:
-          return { value: Buffer.from(value) as T, cas }
-      }
-    } finally {
-      result.recycle()
-    }
+  /** Return the prefix prepended to all keys managed by this {@link Client} */
+  get prefix(): string {
+    return this.#prefix
+  }
+
+  /** Return a new {@link Client} prefixing keys with the specified `string` */
+  withPrefix(prefix: string): Client {
+    assert(prefix, 'Invalid prefix')
+    const client = new Client(this.#adapter)
+    client.#prefix = prefix
+    return client
+  }
+
+  async get<T extends Serializable>(key: string): Promise<T | undefined> {
+    const result = await this.#adapter.get(this.#prefix + key)
+    return result && fromBuffer<T>(result).value
+  }
+
+  async gat<T extends Serializable>(key: string, ttl: number): Promise<T | undefined> {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl)
+    return result && fromBuffer<T>(result).value
+  }
+
+  async getc<T extends Serializable>(key: string): Promise<ClientResult<T> | undefined> {
+    const result = await this.#adapter.get(this.#prefix + key)
+    return result && fromBuffer(result)
+  }
+
+  async gatc<T extends Serializable>(key: string, ttl: number): Promise<ClientResult<T> | undefined> {
+    const result = await this.#adapter.gat(this.#prefix + key, ttl)
+    return result && fromBuffer(result)
   }
 
-  async set(key: string, value: Serializable, options?: { cas?: bigint, ttl?: number }): Promise<bigint | void> {
-    return this.#adapter.set(key, ...toBuffer(value, options))
+  async set(key: string, value: Serializable, options?: { cas?: bigint, ttl?: number }): Promise<bigint | undefined> {
+    return this.#adapter.set(this.#prefix + key, ...toBuffer(value, options))
   }
 
-  async add(key: string, value: Serializable, options?: { cas?: bigint, ttl?: number }): Promise<bigint | void> {
-    return this.#adapter.add(key, ...toBuffer(value, options))
+  async add(key: string, value: Serializable, options?: { ttl?: number }): Promise<bigint | undefined> {
+    return this.#adapter.add(this.#prefix + key, ...toBuffer(value, options))
   }
 
-  async replace(key: string, value: Serializable, options?: { cas?: bigint, ttl?: number }): Promise<bigint | void> {
-    return this.#adapter.replace(key, ...toBuffer(value, options))
+  async replace(key: string, value: Serializable, options?: { cas?: bigint, ttl?: number }): Promise<bigint | undefined> {
+    return this.#adapter.replace(this.#prefix + key, ...toBuffer(value, options))
   }
 
   append(
@@ -149,7 +227,7 @@ export class Client {
     value: Appendable,
     options?: { cas?: bigint },
   ): Promise<boolean> {
-    return this.#adapter.append(key, ...toBuffer(value, options))
+    return this.#adapter.append(this.#prefix + key, ...toBuffer(value, options))
   }
 
   prepend(
@@ -157,19 +235,17 @@ export class Client {
     value: Appendable,
     options?: { cas?: bigint },
   ): Promise<boolean> {
-    return this.#adapter.prepend(key, ...toBuffer(value, options))
+    return this.#adapter.prepend(this.#prefix + key, ...toBuffer(value, options))
   }
 
   async increment(
     key: string,
     delta?: bigint | number,
     options?: { initial?: bigint | number, cas?: bigint, ttl?: number },
-  ): Promise<Counter | void> {
-    const counter = await this.#adapter.increment(key, delta, options)
+  ): Promise<Counter | undefined> {
+    const counter = await this.#adapter.increment(this.#prefix + key, delta, options)
 
-    if (counter && options &&
-        (options.initial !== undefined) &&
-        (counter.value === BigInt(options.initial))) {
+    if ((options?.initial !== undefined) && (counter?.value === BigInt(options.initial))) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl })
       counter.cas = cas ?? counter.cas
     }
@@ -180,12 +256,10 @@ export class Client {
     key: string,
     delta?: bigint | number,
     options?: { initial?: bigint | number, cas?: bigint, ttl?: number },
-  ): Promise<Counter | void> {
-    const counter = await this.#adapter.decrement(key, delta, options)
+  ): Promise<Counter | undefined> {
+    const counter = await this.#adapter.decrement(this.#prefix + key, delta, options)
 
-    if (counter && options &&
-        (options.initial !== undefined) &&
-        (counter.value === BigInt(options.initial))) {
+    if ((options?.initial !== undefined) && (counter?.value === BigInt(options.initial))) {
       const cas = await this.replace(key, counter.value, { cas: counter.cas, ttl: options.ttl })
       counter.cas = cas ?? counter.cas
     }
@@ -194,16 +268,16 @@ export class Client {
 
   touch(
     key: string,
-    options?: { ttl?: number },
+    ttl?: number,
   ): Promise<boolean> {
-    return this.#adapter.touch(key, options)
+    return this.#adapter.touch(this.#prefix + key, ttl)
   }
 
   delete(
     key: string,
     options?: { cas?: bigint },
   ): Promise<boolean> {
-    return this.#adapter.delete(key, options)
+    return this.#adapter.delete(this.#prefix + key, options)
   }
 
   flush(ttl?: number): Promise<void> {

package/src/cluster.ts

@@ -1,5 +1,6 @@
 import { Adapter, Counter, AdapterResult, Stats } from './types'
 import { ServerAdapter, ServerOptions } from './server'
+import assert from 'assert'
 
 function parseHosts(hosts?: string): ServerOptions[] {
   const result: { host: string, port?: number }[] = []
@@ -23,6 +24,7 @@ export interface ClusterOptions {
 
 export class ClusterAdapter implements Adapter {
   readonly servers: readonly ServerAdapter[]
+  readonly ttl: number
 
   constructor()
   constructor(servers: ServerAdapter[])
@@ -62,6 +64,12 @@ export class ClusterAdapter implements Adapter {
     if (this.servers.length < 1) throw new Error('No hosts configured')
     if (this.servers.length === 1) this.server = (): ServerAdapter => this.servers[0]
 
+    // Check TTLs are all the same
+    this.ttl = this.servers[0].ttl
+    this.servers.slice(1).forEach((server) => {
+      assert.equal(server.ttl, this.ttl, `TTL Mismatch (${server.ttl} != ${this.ttl})`)
+    })
+
     // Freeze our lists of servers
     Object.freeze(this.servers)
   }
@@ -75,43 +83,47 @@ export class ClusterAdapter implements Adapter {
     return this.servers[hash % this.servers.length]
   }
 
-  get(key: string, options?: { ttl?: number | undefined }): Promise<void | AdapterResult> {
-    return this.server(key).get(key, options)
+  get(key: string): Promise<AdapterResult | undefined> {
+    return this.server(key).get(key)
+  }
+
+  gat(key: string, ttl: number): Promise<AdapterResult | undefined> {
+    return this.server(key).gat(key, ttl)
   }
 
-  touch(key: string, options?: { ttl?: number | undefined }): Promise<boolean> {
-    return this.server(key).touch(key, options)
+  touch(key: string, ttl?: number): Promise<boolean> {
+    return this.server(key).touch(key, ttl)
   }
 
-  set(key: string, value: Buffer, options?: { flags?: number | undefined; cas?: bigint | undefined; ttl?: number | undefined }): Promise<bigint | void> {
+  set(key: string, value: Buffer, options?: { flags?: number; cas?: bigint; ttl?: number }): Promise<bigint | undefined> {
     return this.server(key).set(key, value, options)
   }
 
-  add(key: string, value: Buffer, options?: { flags?: number | undefined; cas?: bigint | undefined; ttl?: number | undefined }): Promise<bigint | void> {
+  add(key: string, value: Buffer, options?: { flags?: number; ttl?: number }): Promise<bigint | undefined> {
     return this.server(key).add(key, value, options)
   }
 
-  replace(key: string, value: Buffer, options?: { flags?: number | undefined; cas?: bigint | undefined; ttl?: number | undefined }): Promise<bigint | void> {
+  replace(key: string, value: Buffer, options?: { flags?: number; cas?: bigint; ttl?: number }): Promise<bigint | undefined> {
     return this.server(key).replace(key, value, options)
   }
 
-  append(key: string, value: Buffer, options?: { cas?: bigint | undefined }): Promise<boolean> {
+  append(key: string, value: Buffer, options?: { cas?: bigint }): Promise<boolean> {
     return this.server(key).append(key, value, options)
   }
 
-  prepend(key: string, value: Buffer, options?: { cas?: bigint | undefined }): Promise<boolean> {
+  prepend(key: string, value: Buffer, options?: { cas?: bigint }): Promise<boolean> {
     return this.server(key).prepend(key, value, options)
   }
 
-  increment(key: string, delta?: number | bigint, options?: { initial?: number | bigint | undefined; cas?: bigint | undefined; ttl?: number | undefined; create?: boolean | undefined }): Promise<void | Counter> {
+  increment(key: string, delta?: number | bigint, options?: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean }): Promise<Counter | undefined> {
     return this.server(key).increment(key, delta, options)
   }
 
-  decrement(key: string, delta?: number | bigint, options?: { initial?: number | bigint | undefined; cas?: bigint | undefined; ttl?: number | undefined; create?: boolean | undefined }): Promise<void | Counter> {
+  decrement(key: string, delta?: number | bigint, options?: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean }): Promise<Counter | undefined> {
     return this.server(key).decrement(key, delta, options)
   }
 
-  delete(key: string, options?: { cas?: bigint | undefined }): Promise<boolean> {
+  delete(key: string, options?: { cas?: bigint }): Promise<boolean> {
     return this.server(key).delete(key, options)
   }
 

package/src/connection.ts

@@ -6,7 +6,7 @@ import { Decoder, RawIncomingPacket } from './decode'
 import { BUFFERS, OPCODE } from './constants'
 import { socketFinalizationRegistry } from './internals'
 
-type RawIncomingPackets = [ RawIncomingPacket, ...RawIncomingPacket[] ]
+export type RawIncomingPackets = [ RawIncomingPacket, ...RawIncomingPacket[] ]
 
 class Deferred {
   #resolve!: (value: RawIncomingPackets) => void

package/src/encode.ts

@@ -58,7 +58,7 @@ export class Encoder {
     const bodyLength = extrasLength + keyLength + valueLength
     const length = bodyLength + CONSTANTS.HEADER_SIZE
 
-    const buffer = allocateBuffer(length) // /* length <= buffer.length ? buffer : */ Buffer.allocUnsafe(length)
+    const buffer = allocateBuffer(length)
 
     buffer.writeUInt8(MAGIC.REQUEST, OFFSETS.MAGIC_$8)
     buffer.writeUInt8(opcode, OFFSETS.OPCODE_$8)

package/src/fake.ts

@@ -0,0 +1,222 @@
+import { Adapter, AdapterResult, Counter, Stats } from './types'
+
+interface Entry {
+  value: Buffer,
+  flags: number,
+  cas: bigint,
+  exp: number,
+}
+
+function toExp(ttl: number = 0): number {
+  if (ttl === 0) return Number.MAX_SAFE_INTEGER
+  return Date.now() + (ttl * 1000)
+}
+
+export class FakeAdapter implements Adapter {
+  #cache = new Map<string, Entry>()
+  #cas = 1n
+
+  readonly ttl = 0
+
+  #get(key: string): Entry | undefined {
+    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: string, value: Buffer, flags?: number, ttl?: number): bigint {
+    this.#cache.set(key, {
+      value: value,
+      flags: flags || 0,
+      cas: ++this.#cas,
+      exp: toExp(ttl),
+    })
+    return this.#cas
+  }
+
+  async get(
+    key: string,
+  ): Promise<AdapterResult | undefined> {
+    const entry = this.#get(key)
+    if (! entry) return
+
+    return {
+      value: entry.value,
+      flags: entry.flags,
+      cas: entry.cas,
+      recycle: () => void 0,
+    }
+  }
+
+  async gat(
+    key: string,
+    ttl: number,
+  ): Promise<AdapterResult | undefined> {
+    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: string,
+    ttl: number,
+  ): Promise<boolean> {
+    const entry = this.#get(key)
+    if (entry) entry.exp = toExp(ttl)
+    return !! entry
+  }
+
+  async set(
+    key: string,
+    value: Buffer,
+    options: { flags?: number; cas?: bigint; ttl?: number } = {},
+  ): Promise<bigint | undefined> {
+    const entry = this.#get(key)
+    if (entry && (options.cas !== undefined) && (entry.cas !== options.cas)) {
+      return
+    }
+
+    return this.#set(key, value, options.flags, options.ttl)
+  }
+
+  async add(
+    key: string,
+    value: Buffer,
+    options: { flags?: number; ttl?: number } = {},
+  ): Promise<bigint | undefined> {
+    if (this.#get(key)) return
+    return this.#set(key, value, options.flags, options.ttl)
+  }
+
+  async replace(
+    key: string,
+    value: Buffer,
+    options: { flags?: number; cas?: bigint; ttl?: number } = {},
+  ): Promise<bigint | undefined> {
+    if (! this.#get(key)) return
+    return this.#set(key, value, options.flags, options.ttl)
+  }
+
+  async append(
+    key: string,
+    value: Buffer,
+    options: { cas?: bigint } = {},
+  ): Promise<boolean> {
+    const entry = this.#get(key)
+    if (! entry) return false
+
+    if ((options.cas !== undefined) && (options.cas !== entry.cas)) return false
+
+    entry.value = Buffer.concat([ entry.value, value ])
+    return true
+  }
+
+  async prepend(
+    key: string,
+    value: Buffer,
+    options: { cas?: bigint } = {},
+  ): Promise<boolean> {
+    const entry = this.#get(key)
+    if (! entry) return false
+
+    if ((options.cas !== undefined) && (options.cas !== entry.cas)) return false
+
+    entry.value = Buffer.concat([ value, entry.value ])
+    return true
+  }
+
+  async #counter(
+    key: string,
+    delta: number | bigint,
+    options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean },
+  ): Promise<Counter | undefined> {
+    const entry = this.#get(key)
+
+    if (! entry) {
+      if (options.initial !== undefined) {
+        const value = Buffer.from(options.initial.toString())
+        this.#set(key, value, undefined, options.ttl)
+        return { value: BigInt(options.initial), cas: this.#cas }
+      } else {
+        return
+      }
+    }
+
+    if ((options.cas !== undefined) && (options.cas !== entry.cas)) return
+
+    try {
+      const value = BigInt(entry.value.toString('utf-8')) + BigInt(delta)
+      this.#set(key, Buffer.from(value.toString()), undefined, options.ttl)
+      return { value, cas: this.#cas }
+    } catch (error: any) {
+      throw new TypeError(`${error.message} (status=NON_NUMERIC_VALUE, key=${key})`)
+    }
+  }
+
+  increment(
+    key: string,
+    delta: number | bigint = 1n,
+    options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean } = {},
+  ): Promise<Counter | undefined> {
+    return this.#counter(key, delta, options)
+  }
+
+  decrement(
+    key: string,
+    delta: number | bigint = 1n,
+    options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean } = {},
+  ): Promise<Counter | undefined> {
+    return this.#counter(key, -delta, options)
+  }
+
+  async delete(
+    key: string,
+    options: { cas?: bigint } = {},
+  ): Promise<boolean> {
+    const entry = this.#get(key)
+    if (entry && (options.cas !== undefined) && (entry.cas !== options.cas)) {
+      return false
+    }
+
+    return this.#cache.delete(key)
+  }
+
+  async flush(
+    ttl?: number,
+  ): Promise<void> {
+    if (! ttl) return this.#cache.clear()
+
+    const wait = toExp(ttl) - Date.now()
+    setTimeout(() => this.#cache.clear(), wait)
+  }
+
+  async noop(): Promise<void> {
+    // noop!
+  }
+  async quit(): Promise<void> {
+    // noop!
+  }
+
+  async version(): Promise<Record<string, string>> {
+    return { fake: '0.0.0-fake' }
+  }
+
+  async stats(): Promise<Record<string, Stats>> {
+    return { fake: { version: '0.0.0-fake' } as Stats }
+  }
+}

package/src/index.ts

@@ -1,3 +1,5 @@
+export type { RecyclableBuffer } from './buffers'
+
 import * as decode from './decode'
 import * as encode from './encode'
 import * as constants from './constants'
@@ -10,7 +12,9 @@ export {
   connection,
 }
 
+export * from './fake'
 export * from './types'
 export * from './cluster'
 export * from './server'
 export * from './client'
+export * from './utils'

package/src/internals.ts

@@ -39,3 +39,8 @@ export function typedArrayFlags(value: NodeJS.TypedArray): FLAGS {
     assert.fail('Unsupported kind of TypedArray')
   return flags
 }
+
+export function logPromiseError(promise: Promise<any>, message: string): Promise<void> {
+  // eslint-disable-next-line no-console
+  return promise.catch((error) => console.log(message, error)).then(() => void 0)
+}