memx 0.0.4 → 0.0.5

package/src/client.ts

@@ -4,7 +4,7 @@ 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 {
@@ -68,6 +68,56 @@ type TypedArrayConstructor<T extends NodeJS.TypedArray> = {
   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: TypedArrayConstructor<T>,
@@ -140,57 +190,24 @@ export class Client {
     return client
   }
 
-  async get<T extends Serializable>(key: string, options?: { ttl?: number }): Promise<ClientResult<T> | undefined> {
-    const result = await this.#adapter.get(this.#prefix + 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' ), 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()
-    }
+  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 | undefined> {

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,8 +83,12 @@ export class ClusterAdapter implements Adapter {
     return this.servers[hash % this.servers.length]
   }
 
-  get(key: string, options?: { ttl?: number }): Promise<AdapterResult | undefined> {
-    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, ttl?: number): Promise<boolean> {

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/fake.ts

@@ -16,6 +16,8 @@ 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)
@@ -41,15 +43,26 @@ export class FakeAdapter implements Adapter {
 
   async get(
     key: string,
-    options: { ttl?: number } = {},
   ): Promise<AdapterResult | undefined> {
     const entry = this.#get(key)
     if (! entry) return
 
-    if (options.ttl !== undefined) {
-      const exp = toExp(options.ttl)
-      entry.exp = exp
+    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,

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'

package/src/server.ts

@@ -107,14 +107,12 @@ export class ServerAdapter implements Adapter {
 
   /* ======================================================================== */
 
-  async get(
+  async #get(
     key: string,
-    options: { ttl?: number } = {},
+    ttl?: number,
   ): Promise<AdapterResult | undefined> {
-    const { ttl } = options
-
     let keyOffset = 0
-    if (ttl) keyOffset = this.#buffer.writeUInt32BE(ttl)
+    if (ttl !== undefined) keyOffset = this.#buffer.writeUInt32BE(ttl)
     const keyLength = this.#writeKey(key, keyOffset)
 
     const [ response ] = await this.#connection.send({
@@ -142,11 +140,24 @@ export class ServerAdapter implements Adapter {
     }
   }
 
+  async get(
+    key: string,
+  ): Promise<AdapterResult | undefined> {
+    return this.#get(key)
+  }
+
+  async gat(
+    key: string,
+    ttl: number,
+  ): Promise<AdapterResult | undefined> {
+    return this.#get(key, ttl || 2592000) // TTL 0 is "invalid arg"
+  }
+
   async touch(
     key: string,
     ttl?: number,
   ): Promise<boolean> {
-    const timeToLive = ttl === undefined ? this.#ttl : ttl
+    const timeToLive = ttl ?? this.#ttl
 
     const keyOffset = this.#buffer.writeUInt32BE(timeToLive)
     const keyLength = this.#writeKey(key, keyOffset)

package/src/types.ts

@@ -194,9 +194,15 @@ export interface Stats {
 }
 
 export interface Adapter {
+  readonly ttl: number
+
   get(
     key: string,
-    options?: { ttl?: number },
+  ): Promise<AdapterResult | undefined>
+
+  gat(
+    key: string,
+    ttl: number,
   ): Promise<AdapterResult | undefined>
 
   touch(

package/src/utils.ts

@@ -19,8 +19,13 @@ export class Factory<T extends Serializable> {
   }
 
   async get(key: string): Promise<T> {
-    const cached = await this.#client.get(key, { ttl: this.#ttl })
-    if (cached) return cached.value as T
+    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 as T
+    }
 
     const created = await this.#factory(key)
     if (created) {
@@ -58,7 +63,7 @@ export class Bundle<T extends Serializable = Serializable> {
 
   async #removeKey(key: string): Promise<void> {
     await logPromiseError((async (): Promise<void> => {
-      const result = await this.#client.get<string>(this.#name)
+      const result = await this.#client.getc<string>(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 })
@@ -71,7 +76,7 @@ export class Bundle<T extends Serializable = Serializable> {
   }
 
   async get(key: string): Promise<T | undefined> {
-    const result = await this.#client.get<T>(`${this.#name}:${key}`)
+    const result = await this.#client.getc<T>(`${this.#name}:${key}`)
     if (result) return result.value
     await this.#removeKey(key)
   }
@@ -82,14 +87,14 @@ export class Bundle<T extends Serializable = Serializable> {
   }
 
   async list(): Promise<Record<string, T>> {
-    const result = await this.#client.get<string>(this.#name)
+    const result = await this.#client.getc<string>(this.#name)
     if (! result) return {}
 
     const results: Record<string, T> = {}
     const promises: Promise<void>[] = []
 
     for (const key of new Set(result.value.split('\0'))) {
-      promises.push(this.#client.get<T>(`${this.#name}:${key}`).then((result) => {
+      promises.push(this.#client.getc<T>(`${this.#name}:${key}`).then((result) => {
         if (result) results[key] = result.value
       }))
     }
@@ -131,7 +136,7 @@ export class PoorManLock {
     } while (Date.now() < end)
 
     if (cas === undefined) {
-      const other = await this.#client.get(this.#name)
+      const other = await this.#client.getc(this.#name)
       const owner = (other && other.value) ? `"${other.value}"` : 'anonymous'
       throw new Error(`Lock "${this.#client.prefix}${this.#name}" timeout (owner=${owner})`)
     }