memx 0.0.1

package/src/constants.ts

@@ -0,0 +1,103 @@
+export const EMPTY_BUFFER = Buffer.alloc(0)
+
+export enum FLAGS {
+  // by default everything is a "buffer"
+  BUFFER = 0x00000000,
+
+  // from "typeof" we get bigint, boolean, number and string
+  BIGINT = 0xCACA0000,
+  BOOLEAN = 0xCACA0001,
+  NUMBER = 0xCACA0002,
+  STRING = 0xCACA0003,
+
+  // typeof null === object
+  NULL = 0xCACA000E,
+
+  // objects become JSON
+  JSON = 0xCACA000F,
+
+  // typed arrays
+  UINT8ARRAY = 0xCACA0010,
+  UINT8CLAMPEDARRAY = 0xCACA0011,
+  UINT16ARRAY = 0xCACA0012,
+  UINT32ARRAY = 0xCACA0013,
+  INT8ARRAY = 0xCACA0014,
+  INT16ARRAY = 0xCACA0015,
+  INT32ARRAY = 0xCACA0016,
+  BIGUINT64ARRAY = 0xCACA0017,
+  BIGINT64ARRAY = 0xCACA0018,
+  FLOAT32ARRAY = 0xCACA0019,
+  FLOAT64ARRAY = 0xCACA001A,
+}
+
+export enum BUFFERS {
+  POOL_SIZE = 64,
+  BUFFER_SIZE = 8192,
+  HEADER_SIZE = 24,
+  KEY_SIZE = 250,
+  KEY_TOO_BIG = 251,
+}
+
+export enum OFFSETS {
+  MAGIC_$8 = 0,
+  OPCODE_$8 = 1,
+  KEY_LENGTH_$16 = 2,
+  EXTRAS_LENGTH_$8 = 4,
+  DATA_TYPE_$8 = 5,
+  STATUS_$16 = 6,
+  BODY_LENGTH_$32 = 8,
+  SEQUENCE_$32 = 12,
+  CAS_$64 = 16,
+  BODY = 24,
+}
+
+export enum MAGIC {
+  REQUEST = 0x80, // Request packet for this protocol version
+  RESPONSE = 0x81, // Response packet for this protocol version
+}
+
+export enum STATUS {
+  OK = 0x0000, // No error
+  KEY_NOT_FOUND = 0x0001, // Key not found
+  KEY_EXISTS = 0x0002, // Key exists
+  TOO_LARGE = 0x0003, // Value too large
+  INVALID_ARGS = 0x0004, // Invalid arguments
+  ITEM_NOT_STORED = 0x0005, // Item not stored
+  NON_NUMERIC_VALUE = 0x0006, // Incr/Decr on non-numeric value
+  WRONG_VBUCKET = 0x0007, // The vbucket belongs to another server
+  AUTH_ERROR = 0x0008, // Authentication error
+  AUTH_CONTINUE = 0x0009, // Authentication continue
+  UNKNOWN_COMMAND = 0x0081, // Unknown command
+  OUT_OF_MEMORY = 0x0082, // Out of memory
+  NOT_SUPPORTED = 0x0083, // Not supported
+  INTERNAL_ERROR = 0x0084, // Internal error
+  BUSY = 0x0085, // Busy
+  TEMPORARY_FAILURE = 0x0086, // Temporary failure
+}
+
+export enum OPCODE {
+  GET = 0x00,
+  SET = 0x01,
+  ADD = 0x02,
+  REPLACE = 0x03,
+  DELETE = 0x04,
+  INCREMENT = 0x05,
+  DECREMENT = 0x06,
+  QUIT = 0x07,
+  FLUSH = 0x08,
+  NOOP = 0x0a,
+  VERSION = 0x0b,
+  APPEND = 0x0e,
+  PREPEND = 0x0f,
+  STAT = 0x10,
+  TOUCH = 0x1c,
+  GAT = 0x1d,
+}
+
+export enum DATA_TYPE {
+  RAW = 0x00,
+}
+
+export enum VBUCKET {
+  NIL = 0x00,
+}

package/src/decode.ts

@@ -0,0 +1,95 @@
+import { DATA_TYPE, EMPTY_BUFFER, MAGIC, OFFSETS } from './constants'
+import assert from 'assert'
+import { allocateBuffer, RecyclableBuffer } from './buffers'
+
+// Reading the full header would be like
+// const magic =         header.readUInt8        (0)
+// const opcode =        header.readUInt8        (1)
+// const key_length =    header.readUInt16BE     (2)
+// const extras_length = header.readUInt8        (4)
+// const data_type =     header.readUInt8        (5)
+// const status =        header.readUInt16BE     (6)
+// const body_length =   header.readUInt32BE     (8)
+// const sequence =      header.readUInt32BE    (12)
+// const cas =           header.readBigUInt64BE (16)
+
+export interface RawIncomingPacket {
+  readonly opcode: number
+  readonly status: number
+  readonly sequence: number
+  readonly cas: bigint
+  readonly extras: Buffer
+  readonly key: Buffer
+  readonly value: Buffer
+  recycle: () => void
+}
+
+export class Decoder {
+  #consumer: (packet: RawIncomingPacket) => void
+  #header = Buffer.allocUnsafeSlow(24)
+  #body?: RecyclableBuffer
+  #pos = 0
+
+  constructor(consumer: (packet: RawIncomingPacket) => void) {
+    this.#consumer = consumer
+  }
+
+  append(buffer: Buffer, start: number, end: number): void {
+    const header = this.#header
+
+    while (start < end) {
+      if (this.#pos < 24) {
+        const copied = buffer.copy(header, this.#pos, start, end)
+        this.#pos += copied
+        start += copied
+      }
+
+      if (this.#pos < 24) return
+
+      let extras = EMPTY_BUFFER
+      let key = EMPTY_BUFFER
+      let value = EMPTY_BUFFER
+      let recycle = () => void 0
+
+      const bodyLength = header.readUInt32BE(OFFSETS.BODY_LENGTH_$32)
+      if (bodyLength) {
+        const body = this.#body || (this.#body = allocateBuffer(bodyLength))
+
+        const copied = buffer.copy(body, this.#pos - 24, start, end)
+        this.#pos += copied
+        start += copied
+
+        if (this.#pos - 24 < body.length) return
+
+        const keyLength = header.readUInt16BE(OFFSETS.KEY_LENGTH_$16)
+        const extrasLength = header.readUInt8(OFFSETS.EXTRAS_LENGTH_$8)
+        const valueLength = bodyLength - keyLength - extrasLength
+
+        key = keyLength ? body.subarray(extrasLength, extrasLength + keyLength) : EMPTY_BUFFER
+        value = valueLength ? body.subarray(extrasLength + keyLength) : EMPTY_BUFFER
+        extras = extrasLength ? body.subarray(0, extrasLength) : EMPTY_BUFFER
+        recycle = () => void body.recycle()
+      }
+
+      const packet: RawIncomingPacket = {
+        opcode: header.readUInt8(OFFSETS.OPCODE_$8),
+        status: header.readUInt16BE(OFFSETS.STATUS_$16),
+        sequence: header.readUInt32BE(OFFSETS.SEQUENCE_$32),
+        cas: header.readBigUInt64BE(OFFSETS.CAS_$64),
+        extras,
+        key,
+        value,
+        recycle,
+      }
+
+      const magic = header.readUInt8(OFFSETS.MAGIC_$8)
+      const dataType = header.readUInt8(OFFSETS.DATA_TYPE_$8)
+      assert.equal(magic, MAGIC.RESPONSE, 'Invalid magic in header')
+      assert.equal(dataType, DATA_TYPE.RAW, 'Invalid data type in header')
+
+      this.#pos = 0
+      this.#body = undefined
+      this.#consumer(packet)
+    }
+  }
+}

package/src/encode.ts

@@ -0,0 +1,81 @@
+import { allocateBuffer, RecyclableBuffer } from './buffers'
+import { DATA_TYPE, EMPTY_BUFFER, MAGIC, VBUCKET, OPCODE, OFFSETS } from './constants'
+
+// Writing the full header would be like
+// header.writeUInt8       (magic,         0)
+// header.writeUInt8       (opcode,        1)
+// header.writeUInt16BE    (key_length,    2)
+// header.writeUInt8       (extras_length, 4)
+// header.writeUInt8       (data_type,     5)
+// header.writeUInt16BE    (status,        6)
+// header.writeUInt32BE    (body_length,   8)
+// header.writeUInt32BE    (sequence,     12)
+// header.writeBigUInt64BE (cas,          16)
+
+// keep as an "enum", the compiler will replace with values
+enum CONSTANTS {
+  HEADER_SIZE = 24, // header size
+}
+
+export interface RawOutgoingPacket {
+  readonly opcode: OPCODE
+  readonly sequence?: number
+  readonly cas?: bigint
+
+  readonly extras?: Buffer
+  readonly extrasOffset?: number
+  readonly extrasLength?: number
+
+  readonly key?: Buffer
+  readonly keyOffset?: number
+  readonly keyLength?: number
+
+  readonly value?: Buffer
+  readonly valueOffset?: number
+  readonly valueLength?: number
+}
+
+export class Encoder {
+  encode(packet: RawOutgoingPacket, seq: number = 0): RecyclableBuffer {
+    const {
+      opcode,
+      sequence = seq,
+      cas = 0n,
+
+      extras = EMPTY_BUFFER,
+      extrasOffset = 0,
+      extrasLength = extras.length,
+
+      key = EMPTY_BUFFER,
+      keyOffset = 0,
+      keyLength = key.length,
+
+      value = EMPTY_BUFFER,
+      valueOffset = 0,
+      valueLength = value.length,
+    } = packet
+
+    const bodyLength = extrasLength + keyLength + valueLength
+    const length = bodyLength + CONSTANTS.HEADER_SIZE
+
+    const buffer = allocateBuffer(length) // /* length <= buffer.length ? buffer : */ Buffer.allocUnsafe(length)
+
+    buffer.writeUInt8(MAGIC.REQUEST, OFFSETS.MAGIC_$8)
+    buffer.writeUInt8(opcode, OFFSETS.OPCODE_$8)
+    buffer.writeUInt16BE(keyLength, OFFSETS.KEY_LENGTH_$16)
+    buffer.writeUInt8(extrasLength, OFFSETS.EXTRAS_LENGTH_$8)
+    buffer.writeUInt8(DATA_TYPE.RAW, OFFSETS.DATA_TYPE_$8)
+    buffer.writeUInt16BE(VBUCKET.NIL, OFFSETS.STATUS_$16)
+    buffer.writeUInt32BE(bodyLength, OFFSETS.BODY_LENGTH_$32)
+    buffer.writeUInt32BE(sequence, OFFSETS.SEQUENCE_$32)
+    buffer.writeBigUInt64BE(cas, OFFSETS.CAS_$64)
+
+    let pos = 24
+    if (extrasLength) pos += extras.copy(buffer, pos, extrasOffset, extrasOffset + extrasLength)
+    if (keyLength) pos += key.copy(buffer, pos, keyOffset, keyOffset + keyLength)
+    if (valueLength) pos += value.copy(buffer, pos, valueOffset, valueOffset + valueLength)
+    void pos
+
+    return buffer // .length === length ? buffer : buffer.subarray(0, length)
+  }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import * as decode from './decode'
+import * as encode from './encode'
+import * as constants from './constants'
+import * as connection from './connection'
+
+export {
+  decode,
+  encode,
+  constants,
+  connection,
+}
+
+export * from './types'
+export * from './cluster'
+export * from './server'
+export * from './client'

package/src/internals.ts

@@ -0,0 +1,41 @@
+// 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 {
+  isUint8Array,
+  isUint8ClampedArray,
+  isUint16Array,
+  isUint32Array,
+  isInt8Array,
+  isInt16Array,
+  isInt32Array,
+  isBigUint64Array,
+  isBigInt64Array,
+  isFloat32Array,
+  isFloat64Array,
+} from 'util/types'
+
+import { FLAGS } from './constants'
+
+export const socketFinalizationRegistry = new FinalizationRegistry((socket: Socket): void => {
+  if (! socket.destroyed) socket.destroy()
+})
+
+export function typedArrayFlags(value: NodeJS.TypedArray): FLAGS {
+  const flags =
+    isUint8Array(value) ? FLAGS.UINT8ARRAY :
+    isUint8ClampedArray(value) ? FLAGS.UINT8CLAMPEDARRAY :
+    isUint16Array(value) ? FLAGS.UINT16ARRAY :
+    isUint32Array(value) ? FLAGS.UINT32ARRAY :
+    isInt8Array(value) ? FLAGS.INT8ARRAY :
+    isInt16Array(value) ? FLAGS.INT16ARRAY :
+    isInt32Array(value) ? FLAGS.INT32ARRAY :
+    isBigUint64Array(value) ? FLAGS.BIGUINT64ARRAY :
+    isBigInt64Array(value) ? FLAGS.BIGINT64ARRAY :
+    isFloat32Array(value) ? FLAGS.FLOAT32ARRAY :
+    isFloat64Array(value) ? FLAGS.FLOAT64ARRAY :
+    assert.fail('Unsupported kind of TypedArray')
+  return flags
+}