memx 0.0.6 → 0.1.0

package/package.json

@@ -1,48 +1,50 @@
 {
   "name": "memx",
-  "version": "0.0.6",
+  "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.15.0",
-    "@typescript-eslint/parser": "^5.15.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.27",
-    "eslint": "^8.11.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.2"
+    "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
@@ -130,15 +132,15 @@ function makeTypedArray<T extends NodeJS.TypedArray>(
 
 /* ========================================================================== */
 
-/** Types that can be serialized by our {@link Client}. */
+/** Types that can be serialized by our {@link MemxClient}. */
 export type Serializable = bigint | string | number | boolean | null | object
 
-/** Types that can be appended/prepended by our {@link Client}. */
+/** Types that can be appended/prepended by our {@link MemxClient}. */
 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} */
+  /** The value returned by the {@link MemxClient} */
   value: T
   /** The _CAS_ of the value being returned */
   cas: bigint
@@ -147,15 +149,15 @@ export interface ClientResult<T extends Serializable> {
 /**
  * A `Client` represents a high-level client for a _Memcached_ server.
  */
-export class Client {
+export class MemxClient {
   #adapter!: Adapter
   #prefix: string
 
-  /** Construct a new {@link Client} from environment variables */
+  /** Construct a new {@link MemxClient} from environment variables */
   constructor()
-  /** Construct a new {@link Client} wrapping an existing {@link Adapter} */
+  /** Construct a new {@link MemxClient} wrapping an existing {@link Adapter} */
   constructor(adapter: Adapter)
-  /** Construct a new {@link Client} given the specified {@link ClusterOptions} */
+  /** Construct a new {@link MemxClient} given the specified {@link ClusterOptions} */
   constructor(options: ClusterOptions)
 
   constructor(adapterOrOptions?: Adapter | ClusterOptions) {
@@ -172,20 +174,20 @@ export class Client {
     assert(this.#adapter, 'Invalid client constructor arguments')
   }
 
-  /** Return the {@link Adapter} backing this {@link Client} instance */
+  /** Return the {@link Adapter} backing this {@link MemxClient} instance */
   get adapter(): Adapter {
     return this.#adapter
   }
 
-  /** Return the prefix prepended to all keys managed by this {@link Client} */
+  /** Return the prefix prepended to all keys managed by this {@link MemxClient} */
   get prefix(): string {
     return this.#prefix
   }
 
-  /** Return a new {@link Client} prefixing keys with the specified `string` */
-  withPrefix(prefix: string): Client {
+  /** Return a new {@link MemxClient} prefixing keys with the specified `string` */
+  withPrefix(prefix: string): MemxClient {
     assert(prefix, 'Invalid prefix')
-    const client = new Client(this.#adapter)
+    const client = new MemxClient(this.#adapter)
     client.#prefix = prefix
     return client
   }
@@ -227,25 +229,25 @@ export class Client {
   }
 
   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 Client {
   }
 
   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 Client {
   }
 
   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,4 +1,6 @@
-import { Adapter, AdapterResult, Counter, Stats } from './types'
+import { MemxClient } from './client'
+
+import type { Adapter, AdapterResult, Counter, Stats } from './types'
 
 interface Entry {
   value: Buffer,
@@ -42,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
@@ -56,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
@@ -73,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)
@@ -82,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)) {
@@ -95,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
@@ -127,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
@@ -141,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)
 
@@ -169,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)) {
@@ -197,7 +199,7 @@ export class FakeAdapter implements Adapter {
   }
 
   async flush(
-    ttl?: number,
+      ttl?: number,
   ): Promise<void> {
     if (! ttl) return this.#cache.clear()
 
@@ -220,3 +222,9 @@ export class FakeAdapter implements Adapter {
     return { fake: { version: '0.0.0-fake' } as Stats }
   }
 }
+
+export class MemxFakeClient extends MemxClient {
+  constructor() {
+    super(new FakeAdapter())
+  }
+}

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)
 }