memx 0.0.7 → 0.1.0

package/package.json

@@ -1,48 +1,50 @@
 {
   "name": "memx",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "Simple and fast memcached client",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "commonjs",
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
     }
   },
-  "types": "./index.d.ts",
   "scripts": {
-    "build": "./build.sh",
-    "dev": "nodemon -e ts -x ./build.sh -w src -w test",
-    "lint": "eslint src test",
-    "prepare": "patch -N -p0 -i .nyc.patch || true"
+    "build": "plug",
+    "coverage": "plug coverage",
+    "dev": "plug coverage -w src -w test",
+    "lint": "plug lint",
+    "test": "plug test",
+    "transpile": "plug transpile"
   },
   "author": "Juit Developers <developers@juit.com>",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.19.5",
-    "@types/chai": "^4.3.0",
+    "@plugjs/build": "^0.2.2",
+    "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
-    "@types/memjs": "^1.2.4",
-    "@types/mocha": "^9.1.0",
-    "@types/node": "~16.11.26",
-    "@types/source-map-support": "^0.5.4",
-    "@typescript-eslint/eslint-plugin": "^5.17.0",
-    "@typescript-eslint/parser": "^5.17.0",
-    "chai": "^4.3.6",
+    "@types/memjs": "^1.3.0",
+    "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-exclude": "^2.1.0",
-    "esbuild": "^0.14.28",
-    "eslint": "^8.12.0",
-    "eslint-config-google": "^0.14.0",
     "memjs": "^1.3.0",
-    "mocha": "^9.2.2",
-    "nodemon": "^2.0.15",
-    "nyc": "^15.1.0",
-    "source-map-support": "^0.5.21",
-    "typescript": "^4.6.3"
+    "typescript": "^4.9.5"
   },
   "directories": {
     "test": "test"
-  }
+  },
+  "files": [
+    "*.md",
+    "dist/",
+    "src/"
+  ]
 }

package/src/client.ts

@@ -1,10 +1,12 @@
-import assert from 'assert'
-import { types } from 'util'
+import assert from 'node:assert'
+import { types } from 'node:util'
 
-import { ClusterAdapter, ClusterOptions } from './cluster'
+import { ClusterAdapter } from './cluster'
 import { EMPTY_BUFFER, FLAGS } from './constants'
 import { typedArrayFlags } from './internals'
-import { Adapter, AdapterResult, Counter, Stats } from './types'
+
+import type { ClusterOptions } from './cluster'
+import type { 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 {
@@ -16,7 +18,7 @@ function replacer(this: any, key: string, value: any): any {
 }
 
 /** JSON reviver function deserializing `bigint`, {@link Date}, {@link Set} and {@link Map}. */
-function reviver(this: any, key: string, value: any): any {
+function reviver(this: any, _key: string, value: any): any {
   if (Array.isArray(value)) {
     switch (value[0]) {
       case '\0__$BIGINT$__\0': return BigInt(value[1])
@@ -120,8 +122,8 @@ function fromBuffer<T extends Serializable>(result: AdapterResult): ClientResult
 
 /** Create a {@link NodeJS.TypedArray} copying the contents of its source {@link Buffer} */
 function makeTypedArray<T extends NodeJS.TypedArray>(
-  constructor: TypedArrayConstructor<T>,
-  source: Buffer,
+    constructor: TypedArrayConstructor<T>,
+    source: Buffer,
 ): T {
   const clone = Buffer.from(source)
   const { buffer, byteOffset, byteLength } = clone
@@ -227,25 +229,25 @@ export class MemxClient {
   }
 
   append(
-    key: string,
-    value: Appendable,
-    options?: { cas?: bigint },
+      key: string,
+      value: Appendable,
+      options?: { cas?: bigint },
   ): Promise<boolean> {
     return this.#adapter.append(this.#prefix + key, ...toBuffer(value, options))
   }
 
   prepend(
-    key: string,
-    value: Appendable,
-    options?: { cas?: bigint },
+      key: string,
+      value: Appendable,
+      options?: { cas?: bigint },
   ): Promise<boolean> {
     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 },
+      key: string,
+      delta?: bigint | number,
+      options?: { initial?: bigint | number, cas?: bigint, ttl?: number },
   ): Promise<Counter | undefined> {
     const counter = await this.#adapter.increment(this.#prefix + key, delta, options)
 
@@ -257,9 +259,9 @@ export class MemxClient {
   }
 
   async decrement(
-    key: string,
-    delta?: bigint | number,
-    options?: { initial?: bigint | number, cas?: bigint, ttl?: number },
+      key: string,
+      delta?: bigint | number,
+      options?: { initial?: bigint | number, cas?: bigint, ttl?: number },
   ): Promise<Counter | undefined> {
     const counter = await this.#adapter.decrement(this.#prefix + key, delta, options)
 
@@ -271,15 +273,15 @@ export class MemxClient {
   }
 
   touch(
-    key: string,
-    ttl?: number,
+      key: string,
+      ttl?: number,
   ): Promise<boolean> {
     return this.#adapter.touch(this.#prefix + key, ttl)
   }
 
   delete(
-    key: string,
-    options?: { cas?: bigint },
+      key: string,
+      options?: { cas?: bigint },
   ): Promise<boolean> {
     return this.#adapter.delete(this.#prefix + key, options)
   }

package/src/cluster.ts

@@ -1,6 +1,9 @@
-import { Adapter, Counter, AdapterResult, Stats } from './types'
-import { ServerAdapter, ServerOptions } from './server'
-import assert from 'assert'
+import assert from 'node:assert'
+
+import { ServerAdapter } from './server'
+
+import type { Adapter, Counter, AdapterResult, Stats } from './types'
+import type { ServerOptions } from './server'
 
 function parseHosts(hosts?: string): ServerOptions[] {
   const result: { host: string, port?: number }[] = []

package/src/connection.ts

@@ -1,11 +1,15 @@
-import assert from 'assert'
-import net, { Socket } from 'net'
+import assert from 'node:assert'
+import net from 'node:net'
 
-import { Encoder, RawOutgoingPacket } from './encode'
-import { Decoder, RawIncomingPacket } from './decode'
+import { Encoder } from './encode'
+import { Decoder } from './decode'
 import { BUFFERS, OPCODE } from './constants'
 import { socketFinalizationRegistry } from './internals'
 
+import type { RawIncomingPacket } from './decode'
+import type { RawOutgoingPacket } from './encode'
+import type { Socket } from 'node:net'
+
 export type RawIncomingPackets = [ RawIncomingPacket, ...RawIncomingPacket[] ]
 
 class Deferred {

package/src/decode.ts

@@ -1,6 +1,9 @@
+import assert from 'node:assert'
+
 import { DATA_TYPE, EMPTY_BUFFER, MAGIC, OFFSETS } from './constants'
-import assert from 'assert'
-import { allocateBuffer, RecyclableBuffer } from './buffers'
+import { allocateBuffer } from './buffers'
+
+import type { RecyclableBuffer } from './buffers'
 
 // Reading the full header would be like
 // const magic =         header.readUInt8        (0)

package/src/encode.ts

@@ -1,5 +1,8 @@
-import { allocateBuffer, RecyclableBuffer } from './buffers'
-import { DATA_TYPE, EMPTY_BUFFER, MAGIC, VBUCKET, OPCODE, OFFSETS } from './constants'
+import { allocateBuffer } from './buffers'
+import { DATA_TYPE, EMPTY_BUFFER, MAGIC, VBUCKET, OFFSETS } from './constants'
+
+import type { RecyclableBuffer } from './buffers'
+import type { OPCODE } from './constants'
 
 // Writing the full header would be like
 // header.writeUInt8       (magic,         0)

package/src/fake.ts

@@ -1,6 +1,7 @@
-import { Adapter, AdapterResult, Counter, Stats } from './types'
 import { MemxClient } from './client'
 
+import type { Adapter, AdapterResult, Counter, Stats } from './types'
+
 interface Entry {
   value: Buffer,
   flags: number,
@@ -43,7 +44,7 @@ export class FakeAdapter implements Adapter {
   }
 
   async get(
-    key: string,
+      key: string,
   ): Promise<AdapterResult | undefined> {
     const entry = this.#get(key)
     if (! entry) return
@@ -57,8 +58,8 @@ export class FakeAdapter implements Adapter {
   }
 
   async gat(
-    key: string,
-    ttl: number,
+      key: string,
+      ttl: number,
   ): Promise<AdapterResult | undefined> {
     const entry = this.#get(key)
     if (! entry) return
@@ -74,8 +75,8 @@ export class FakeAdapter implements Adapter {
   }
 
   async touch(
-    key: string,
-    ttl: number,
+      key: string,
+      ttl: number,
   ): Promise<boolean> {
     const entry = this.#get(key)
     if (entry) entry.exp = toExp(ttl)
@@ -83,9 +84,9 @@ export class FakeAdapter implements Adapter {
   }
 
   async set(
-    key: string,
-    value: Buffer,
-    options: { flags?: number; cas?: bigint; ttl?: number } = {},
+      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)) {
@@ -96,27 +97,27 @@ export class FakeAdapter implements Adapter {
   }
 
   async add(
-    key: string,
-    value: Buffer,
-    options: { flags?: number; ttl?: number } = {},
+      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 } = {},
+      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 } = {},
+      key: string,
+      value: Buffer,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     const entry = this.#get(key)
     if (! entry) return false
@@ -128,9 +129,9 @@ export class FakeAdapter implements Adapter {
   }
 
   async prepend(
-    key: string,
-    value: Buffer,
-    options: { cas?: bigint } = {},
+      key: string,
+      value: Buffer,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     const entry = this.#get(key)
     if (! entry) return false
@@ -142,9 +143,9 @@ export class FakeAdapter implements Adapter {
   }
 
   async #counter(
-    key: string,
-    delta: number | bigint,
-    options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean },
+      key: string,
+      delta: number | bigint,
+      options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean },
   ): Promise<Counter | undefined> {
     const entry = this.#get(key)
 
@@ -170,24 +171,24 @@ export class FakeAdapter implements Adapter {
   }
 
   increment(
-    key: string,
-    delta: number | bigint = 1n,
-    options: { initial?: number | bigint; cas?: bigint; ttl?: number; create?: boolean } = {},
+      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 } = {},
+      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 } = {},
+      key: string,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     const entry = this.#get(key)
     if (entry && (options.cas !== undefined) && (entry.cas !== options.cas)) {
@@ -198,7 +199,7 @@ export class FakeAdapter implements Adapter {
   }
 
   async flush(
-    ttl?: number,
+      ttl?: number,
   ): Promise<void> {
     if (! ttl) return this.#cache.clear()
 

package/src/internals.ts

@@ -1,12 +1,11 @@
-// Keep these here: they must be ignored by Istanbul, but ESBUILD swallows
-// commments (for a reason: https://github.com/evanw/esbuild/issues/578)
-
-import assert from 'assert'
-import type { Socket } from 'net'
-import { types } from 'util'
+import assert from 'node:assert'
+import { types } from 'node:util'
 
 import { FLAGS } from './constants'
 
+import type { Socket } from 'node:net'
+
+/* coverage ignore next */
 export const socketFinalizationRegistry = new FinalizationRegistry((socket: Socket): void => {
   if (! socket.destroyed) socket.destroy()
 })
@@ -28,7 +27,8 @@ export function typedArrayFlags(value: NodeJS.TypedArray): FLAGS {
   return flags
 }
 
+/* coverage ignore next */
 export function logPromiseError(promise: Promise<any>, message: string): Promise<void> {
-  // eslint-disable-next-line no-console
+  /* eslint-disable-next-line no-console */
   return promise.catch((error) => console.log(message, error)).then(() => void 0)
 }

package/src/server.ts

@@ -1,7 +1,9 @@
-import { Adapter, Counter, AdapterResult, Stats } from './types'
-import { Connection, ConnectionOptions } from './connection'
+import { Connection } from './connection'
 import { BUFFERS, OPCODE, STATUS } from './constants'
-import { RawIncomingPacket } from './decode'
+
+import type { Adapter, Counter, AdapterResult, Stats } from './types'
+import type { ConnectionOptions } from './connection'
+import type { RawIncomingPacket } from './decode'
 
 const statsBigInt: readonly string[] = [
   'auth_cmds', 'auth_errors', 'bytes', 'bytes_read', 'bytes_written', 'cas_badval', 'cas_hits', 'cas_misses',
@@ -108,8 +110,8 @@ export class ServerAdapter implements Adapter {
   /* ======================================================================== */
 
   async #get(
-    key: string,
-    ttl?: number,
+      key: string,
+      ttl?: number,
   ): Promise<AdapterResult | undefined> {
     let keyOffset = 0
     if (ttl !== undefined) keyOffset = this.#buffer.writeUInt32BE(ttl)
@@ -141,21 +143,21 @@ export class ServerAdapter implements Adapter {
   }
 
   async get(
-    key: string,
+      key: string,
   ): Promise<AdapterResult | undefined> {
     return this.#get(key)
   }
 
   async gat(
-    key: string,
-    ttl: number,
+      key: string,
+      ttl: number,
   ): Promise<AdapterResult | undefined> {
     return this.#get(key, ttl || 2592000) // TTL 0 is "invalid arg"
   }
 
   async touch(
-    key: string,
-    ttl?: number,
+      key: string,
+      ttl?: number,
   ): Promise<boolean> {
     const timeToLive = ttl ?? this.#ttl
 
@@ -189,10 +191,10 @@ export class ServerAdapter implements Adapter {
   /* ======================================================================== */
 
   async #sar(
-    opcode: OPCODE.SET | OPCODE.ADD | OPCODE.REPLACE,
-    key: string,
-    value: Buffer,
-    options: { flags?: number, cas?: bigint, ttl?: number },
+      opcode: OPCODE.SET | OPCODE.ADD | OPCODE.REPLACE,
+      key: string,
+      value: Buffer,
+      options: { flags?: number, cas?: bigint, ttl?: number },
   ): Promise<bigint | undefined> {
     const { flags = 0, cas = 0n, ttl = this.#ttl } = options
 
@@ -229,25 +231,25 @@ export class ServerAdapter implements Adapter {
   }
 
   set(
-    key: string,
-    value: Buffer,
-    options: { flags?: number, cas?: bigint, ttl?: number } = {},
+      key: string,
+      value: Buffer,
+      options: { flags?: number, cas?: bigint, ttl?: number } = {},
   ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.SET, key, value, options)
   }
 
   add(
-    key: string,
-    value: Buffer,
-    options: { flags?: number, ttl?: number } = {},
+      key: string,
+      value: Buffer,
+      options: { flags?: number, ttl?: number } = {},
   ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.ADD, key, value, options)
   }
 
   replace(
-    key: string,
-    value: Buffer,
-    options: { flags?: number, cas?: bigint, ttl?: number } = {},
+      key: string,
+      value: Buffer,
+      options: { flags?: number, cas?: bigint, ttl?: number } = {},
   ): Promise<bigint | undefined> {
     return this.#sar(OPCODE.REPLACE, key, value, options)
   }
@@ -255,10 +257,10 @@ export class ServerAdapter implements Adapter {
   /* ======================================================================== */
 
   async #pend(
-    opcode: OPCODE.APPEND | OPCODE.PREPEND,
-    key: string,
-    value: Buffer,
-    options: { cas?: bigint },
+      opcode: OPCODE.APPEND | OPCODE.PREPEND,
+      key: string,
+      value: Buffer,
+      options: { cas?: bigint },
   ): Promise<boolean> {
     const { cas = 0n } = options
 
@@ -289,17 +291,17 @@ export class ServerAdapter implements Adapter {
   }
 
   append(
-    key: string,
-    value: Buffer,
-    options: { cas?: bigint } = {},
+      key: string,
+      value: Buffer,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     return this.#pend(OPCODE.APPEND, key, value, options)
   }
 
   prepend(
-    key: string,
-    value: Buffer,
-    options: { cas?: bigint } = {},
+      key: string,
+      value: Buffer,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     return this.#pend(OPCODE.PREPEND, key, value, options)
   }
@@ -307,10 +309,10 @@ export class ServerAdapter implements Adapter {
   /* ======================================================================== */
 
   async #counter(
-    opcode: OPCODE.INCREMENT | OPCODE.DECREMENT,
-    key: string,
-    delta: bigint | number,
-    options: { initial?: bigint | number, cas?: bigint, ttl?: number },
+      opcode: OPCODE.INCREMENT | OPCODE.DECREMENT,
+      key: string,
+      delta: bigint | number,
+      options: { initial?: bigint | number, cas?: bigint, ttl?: number },
   ): Promise<Counter | undefined> {
     const {
       initial,
@@ -354,17 +356,17 @@ export class ServerAdapter implements Adapter {
   }
 
   increment(
-    key: string,
-    delta: bigint | number = 1,
-    options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
+      key: string,
+      delta: bigint | number = 1,
+      options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
   ): Promise<Counter | undefined> {
     return this.#counter(OPCODE.INCREMENT, key, delta, options)
   }
 
   decrement(
-    key: string,
-    delta: bigint | number = 1,
-    options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
+      key: string,
+      delta: bigint | number = 1,
+      options: { initial?: bigint | number, cas?: bigint, ttl?: number, create?: boolean } = {},
   ): Promise<Counter | undefined> {
     return this.#counter(OPCODE.DECREMENT, key, delta, options)
   }
@@ -372,8 +374,8 @@ export class ServerAdapter implements Adapter {
   /* ======================================================================== */
 
   async delete(
-    key: string,
-    options: { cas?: bigint } = {},
+      key: string,
+      options: { cas?: bigint } = {},
   ): Promise<boolean> {
     const { cas = 0n } = options
 

package/src/utils.ts

@@ -1,9 +1,11 @@
 /* eslint-disable no-console */
 
-import assert from 'assert'
-import { MemxClient, Serializable } from './client'
+import assert from 'node:assert'
+
 import { logPromiseError } from './internals'
 
+import type { MemxClient, Serializable } from './client'
+
 export class Factory<T extends Serializable> {
   #factory: (key: string) => T | Promise<T>
   #client: MemxClient
@@ -79,6 +81,7 @@ export class Bundle<T extends Serializable = Serializable> {
     const result = await this.#client.getc<T>(`${this.#name}:${key}`)
     if (result) return result.value
     await this.#removeKey(key)
+    return undefined
   }
 
   async delete(key: string): Promise<void> {
@@ -122,8 +125,8 @@ export class PoorManLock {
   }
 
   async execute<T>(
-    executor: () => T | Promise<T>,
-    options?: { timeout?: number, owner?: string },
+      executor: () => T | Promise<T>,
+      options?: { timeout?: number, owner?: string },
   ): Promise<T> {
     const { timeout = 5000, owner = false } = options || {}
     const end = Date.now() + timeout