memx 0.0.1 → 0.0.5

package/src/server.ts

@@ -107,14 +107,12 @@ export class ServerAdapter implements Adapter {
 
   /* ======================================================================== */
 
-  async get(
+  async #get(
     key: string,
-    options: { ttl?: number } = {},
-  ): Promise<AdapterResult | void> {
-    const { ttl } = options
-
+    ttl?: number,
+  ): Promise<AdapterResult | undefined> {
     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,13 +140,26 @@ 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,
-    options: { ttl?: number } = {},
+    ttl?: number,
   ): Promise<boolean> {
-    const { ttl = this.#ttl } = options
+    const timeToLive = ttl ?? this.#ttl
 
-    const keyOffset = this.#buffer.writeUInt32BE(ttl)
+    const keyOffset = this.#buffer.writeUInt32BE(timeToLive)
     const keyLength = this.#writeKey(key, keyOffset)
 
     const [ response ] = await this.#connection.send({
@@ -182,7 +193,7 @@ export class ServerAdapter implements Adapter {
     key: string,
     value: Buffer,
     options: { flags?: number, cas?: bigint, ttl?: number },
-  ): Promise<bigint | void> {
+  ): Promise<bigint | undefined> {
     const { flags = 0, cas = 0n, ttl = this.#ttl } = options
 
     let keyOffset: number
@@ -221,15 +232,15 @@ export class ServerAdapter implements Adapter {
     key: string,
     value: Buffer,
     options: { flags?: number, cas?: bigint, ttl?: number } = {},
-  ): Promise<bigint | void> {
+  ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.SET, key, value, options)
   }
 
   add(
     key: string,
     value: Buffer,
-    options: { flags?: number, cas?: bigint, ttl?: number } = {},
-  ): Promise<bigint | void> {
+    options: { flags?: number, ttl?: number } = {},
+  ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.ADD, key, value, options)
   }
 
@@ -237,7 +248,7 @@ export class ServerAdapter implements Adapter {
     key: string,
     value: Buffer,
     options: { flags?: number, cas?: bigint, ttl?: number } = {},
-  ): Promise<bigint | void> {
+  ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.REPLACE, key, value, options)
   }
 
@@ -300,7 +311,7 @@ export class ServerAdapter implements Adapter {
     key: string,
     delta: bigint | number,
     options: { initial?: bigint | number, cas?: bigint, ttl?: number },
-  ): Promise<Counter | void> {
+  ): Promise<Counter | undefined> {
     const {
       initial,
       cas = 0n,
@@ -346,7 +357,7 @@ export class ServerAdapter implements Adapter {
     key: string,
     delta: bigint | number = 1,
     options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
-  ): Promise<Counter | void> {
+  ): Promise<Counter | undefined> {
     return this.#counter(OPCODE.INCREMENT, key, delta, options)
   }
 
@@ -354,7 +365,7 @@ export class ServerAdapter implements Adapter {
     key: string,
     delta: bigint | number = 1,
     options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
-  ): Promise<Counter | void> {
+  ): Promise<Counter | undefined> {
     return this.#counter(OPCODE.DECREMENT, key, delta, options)
   }
 

package/src/types.ts

@@ -194,33 +194,39 @@ export interface Stats {
 }
 
 export interface Adapter {
+  readonly ttl: number
+
   get(
     key: string,
-    options?: { ttl?: number },
-  ): Promise<AdapterResult | void>
+  ): Promise<AdapterResult | undefined>
+
+  gat(
+    key: string,
+    ttl: number,
+  ): Promise<AdapterResult | undefined>
 
   touch(
     key: string,
-    options?: { ttl?: number },
+    ttl?: number,
   ): Promise<boolean>
 
   set(
     key: string,
     value: Buffer,
     options?: { flags?: number, cas?: bigint, ttl?: number },
-  ): Promise<bigint | void>
+  ): Promise<bigint | undefined>
 
   add(
     key: string,
     value: Buffer,
-    options?: { flags?: number, cas?: bigint, ttl?: number },
-  ): Promise<bigint | void>
+    options?: { flags?: number, ttl?: number },
+  ): Promise<bigint | undefined>
 
   replace(
     key: string,
     value: Buffer,
     options?: { flags?: number, cas?: bigint, ttl?: number },
-  ): Promise<bigint | void>
+  ): Promise<bigint | undefined>
 
   append(
     key: string,
@@ -238,13 +244,13 @@ export interface Adapter {
     key: string,
     delta?: bigint | number,
     options?: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean },
-  ): Promise<Counter | void>
+  ): Promise<Counter | undefined>
 
   decrement(
     key: string,
     delta?: bigint | number,
     options?: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean },
-  ): Promise<Counter | void>
+  ): Promise<Counter | undefined>
 
   delete(
     key: string,

package/src/utils.ts

@@ -0,0 +1,161 @@
+/* eslint-disable no-console */
+
+import assert from 'assert'
+import { Client, Serializable } from './client'
+import { logPromiseError } from './internals'
+
+export class Factory<T extends Serializable> {
+  #factory: (key: string) => T | Promise<T>
+  #client: Client
+  #ttl?: number
+
+  constructor(client: Client, factory: (key: string) => T | Promise<T>, ttl?: number) {
+    assert(typeof factory === 'function', 'Invalid or no factory specified')
+    assert(client, 'No client specified')
+
+    this.#factory = factory
+    this.#client = client
+    this.#ttl = ttl
+  }
+
+  async get(key: string): Promise<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) {
+      void logPromiseError(
+          this.#client.set(key, created, { ttl: this.#ttl }),
+          `Factory error setting key "${this.#client.prefix}${key}"`)
+    }
+    return created
+  }
+}
+
+export class Bundle<T extends Serializable = Serializable> {
+  #client: Client
+  #name: string
+  #ttl: number
+
+  constructor(client: Client, name: string, ttl?: number) {
+    assert(client, 'No client specified')
+    assert(name, 'No bundle name specified')
+
+    this.#client = client
+    this.#name = name
+    this.#ttl = ttl || 0
+  }
+
+  async #appendKey(key: string): Promise<void> {
+    await logPromiseError((async (): Promise<void> => {
+      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: string): Promise<void> {
+    await logPromiseError((async (): Promise<void> => {
+      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 })
+    })(), `Bundle "${this.#client.prefix}${this.#name}" error clearing key "${key}"`)
+  }
+
+  async add(key: string, value: T): Promise<void> {
+    await this.#client.set(`${this.#name}:${key}`, value, { ttl: this.#ttl })
+    await this.#appendKey(key)
+  }
+
+  async get(key: string): Promise<T | undefined> {
+    const result = await this.#client.getc<T>(`${this.#name}:${key}`)
+    if (result) return result.value
+    await this.#removeKey(key)
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.#client.delete(`${this.#name}:${key}`)
+    await this.#removeKey(key)
+  }
+
+  async list(): Promise<Record<string, T>> {
+    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.getc<T>(`${this.#name}:${key}`).then((result) => {
+        if (result) results[key] = result.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
+  }
+}
+
+export class PoorManLock {
+  #client: Client
+  #name: string
+
+  constructor(client: Client, name: string) {
+    assert(client, 'No client specified')
+    assert(name, 'No lock name specified')
+
+    this.#client = client
+    this.#name = name
+  }
+
+  async execute<T>(
+    executor: () => T | Promise<T>,
+    options?: { timeout?: number, owner?: string },
+  ): Promise<T> {
+    const { timeout = 5000, owner = false } = options || {}
+    const end = Date.now() + timeout
+
+    let cas: bigint | undefined
+    do {
+      cas = await this.#client.add(this.#name, owner, { ttl: 2 })
+      if (cas !== undefined) break
+      await new Promise((resolve) => setTimeout(resolve, 100))
+    } while (Date.now() < end)
+
+    if (cas === undefined) {
+      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})`)
+    }
+
+    const interval = setInterval(() => {
+      void logPromiseError((async (): Promise<void> => {
+        const replaced = await this.#client.replace(this.#name, owner, { ttl: 2, cas })
+        assert(replaced !== undefined, `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}"`)
+    }
+  }
+}