presidium-db-client-server 0.0.0-stage → 0.0.0

package/ArrayEventEmitter.js

@@ -0,0 +1,17 @@
+const stream = require("stream")
+
+/**
+ * @name ArrayEventEmitter
+ *
+ * @docs
+ * ```specscript
+ * module EventEmitter "./specscript/EventEmitter.ss"
+ *
+ * ArrayEventEmitter(array Array<string|Buffer>) -> EventEmitter
+ * ```
+ */
+function ArrayEventEmitter(array) {
+  return stream.Readable.from(array)
+}
+
+module.exports = ArrayEventEmitter

package/AsyncIterator.js

@@ -0,0 +1,34 @@
+const AsyncIterator = {}
+
+function sleep(time) {
+  return new Promise(resolve => setTimeout(resolve, time))
+}
+
+/**
+ * @name fromEvents
+ *
+ * @docs
+ * ```specscript
+ * module EventEmitter "./specscript/EventEmitter.ss"
+ *
+ * fromEvents(events EventEmitter) -> AsyncIterator
+ * fromEvents(events EventEmitter, dataEventName string) -> AsyncIterator
+ * ```
+ */
+async function* fromEvents(events, dataEventName = "data") {
+  let buffer = []
+  events.on(dataEventName, data => buffer.push(data))
+  let streaming = true
+  events.on("end", () => (streaming = false))
+  while (streaming || buffer.length > 0) {
+    while (buffer.length > 0) {
+      yield* buffer
+      buffer = []
+    }
+    await sleep(1)
+  }
+}
+
+AsyncIterator.fromEvents = fromEvents
+
+module.exports = AsyncIterator

package/BinaryEntriesStream.js

@@ -0,0 +1,71 @@
+const EventEmitter = require("events")
+
+/**
+ * @name BinaryEntriesStream
+ *
+ * @docs
+ * ```coffeescript [specscript]
+ * module stream 'https://nodejs.org/docs/latest-v26.x/api/stream.html'
+ * module events 'https://nodejs.org/docs/latest-v26.x/api/events.html'
+ *
+ * BinaryEntriesStream(
+ *   readable stream.Readable,
+ *   entryLength number,
+ *   delimiter string
+ * ) -> binaryEntriesStream events.EventEmitter
+ *
+ * binaryEntriesStream.on("entry", (entry Array<Buffer>, keyEncoding string) -> ())
+ *
+ * binaryEntriesStream.on("end", () -> ())
+ * ```
+ */
+class BinaryEntriesStream extends EventEmitter {
+  constructor(readable, entryLength, delimiter, encoding) {
+    super()
+
+    delimiter ??= ""
+    encoding ??= "utf8"
+
+    let buffer = Buffer.from("")
+    let entry = []
+
+    readable.on('data', (chunk, encoding) => {
+      if (typeof chunk == 'string') {
+        buffer = Buffer.concat([buffer, Buffer.from(chunk, encoding)])
+      } else {
+        buffer = Buffer.concat([buffer, chunk])
+      }
+
+      let delimiterIndex = buffer.indexOf(delimiter)
+      while (delimiterIndex > -1) {
+        const slice = buffer.slice(0, delimiterIndex)
+        entry.push(slice)
+        if (entry.length == entryLength) {
+          this.emit("entry", entry, encoding)
+          entry = []
+        }
+        buffer = buffer.slice(delimiterIndex + 1)
+        delimiterIndex = buffer.indexOf(delimiter)
+      }
+    })
+
+    readable.on('end', () => {
+      if (buffer.length > 0) {
+        entry.push(buffer)
+      }
+      if (entry.length == entryLength) {
+        this.emit("entry", entry, encoding)
+        this.emit("end")
+        entry = []
+      } else if (entry.length > 0) {
+        const error = new Error("last entry")
+        error.entry = entry
+        this.emit("error", error)
+      } else {
+        this.emit("end")
+      }
+    })
+  }
+}
+
+module.exports = BinaryEntriesStream

package/BinaryStream.js

@@ -0,0 +1,50 @@
+const EventEmitter = require("events")
+
+/**
+ * @name BinaryStream
+ *
+ * @docs
+ * ```coffeescript [specscript]
+ * module stream 'https://nodejs.org/docs/latest-v26.x/api/stream.html'
+ * module events 'https://nodejs.org/docs/latest-v26.x/api/events.html'
+ *
+ * BinaryStream(readable stream.Readable, delimiter string) -> binaryStream events.EventEmitter
+ *
+ * textStream.on("data", chunk Buffer -> ())
+ *
+ * textStream.on("end", () -> ())
+ * ```
+ */
+class BinaryStream extends EventEmitter {
+  constructor(readable, delimiter) {
+    super()
+
+    delimiter ??= ""
+
+    let buffer = Buffer.from("")
+    readable.on('data', (chunk, encoding) => {
+      if (typeof chunk == 'string') {
+        buffer = Buffer.concat([buffer, Buffer.from(chunk, encoding)])
+      } else {
+        buffer = Buffer.concat([buffer, chunk])
+      }
+
+      let delimiterIndex = buffer.indexOf(delimiter)
+      while (delimiterIndex > -1) {
+        const slice = buffer.slice(0, delimiterIndex)
+        this.emit("data", slice)
+        buffer = buffer.slice(delimiterIndex + 1)
+        delimiterIndex = buffer.indexOf(delimiter)
+      }
+    })
+
+    readable.on('end', () => {
+      if (buffer.length > 0) {
+        this.emit("data", buffer)
+      }
+      this.emit("end")
+    })
+  }
+}
+
+module.exports = BinaryStream

package/DatabaseHandler.js

@@ -0,0 +1,288 @@
+require("rubico/global")
+const DiskHashTable = require("presidium/DiskHashTable")
+const DiskSortedHashTable = require("presidium/DiskSortedHashTable")
+const Readable = require("presidium/Readable")
+
+/**
+ * @name DatabaseHandler
+ *
+ * @docs
+ * ```specscript
+ * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * DatabaseHandler(options {
+ *   databasePath: string,
+ *   manifestTableName: string,
+ *   manifestTableInitialLength: number,
+ *   manifestTableItemSize: number,
+ *   defaultTableInitialLength: number,
+ *   defaultTableItemSize: number,
+ *   manifestHt: DiskHashTable,
+ *   hts: Map<tableName string, DiskHashTable>,
+ * }) -> databaseHandler HTTP.AsyncHandler
+ * ```
+ */
+function DatabaseHandler(options) {
+  const {
+    databasePath,
+    manifestTableName,
+    manifestTableInitialLength,
+    manifestTableItemSize,
+    defaultTableInitialLength,
+    defaultTableItemSize,
+    manifestHt,
+    hts,
+  } = options
+
+  /**
+   * @name getHt
+   *
+   * @docs
+   * ```specscript
+   * module HTTP "https://presidium.services/docs/HTTP"
+   *
+   * getHt(tableName string, request HTTP.Request) -> ht DiskHashTable|DiskSortedHashTable
+   * ```
+   */
+  async function getHt(tableName, request, manifestHt) {
+    const htConfigString = await manifestHt.get(tableName)
+    let ht
+    if (htConfigString) {
+      const config = JSON.parse(htConfigString)
+      if (request.headers["client-name"] == "DiskHashTableClient") {
+        ht = new DiskHashTable(config)
+        await ht.init()
+        hts.set(tableName, ht)
+      } else if (request.headers["client-name"] == "DiskSortedHashTableClient") {
+        ht = new DiskSortedHashTable(config)
+        await ht.init()
+        hts.set(tableName, ht)
+      } else {
+        const error = new Error("Forbidden: Client-Name")
+        error.code = 403
+        throw error
+      }
+    } else {
+      if (request.headers["client-name"] == "DiskHashTableClient") {
+        const config = {
+          storagePath: `${databasePath}/${tableName}/storage`,
+          headerPath: `${databasePath}/${tableName}/header`,
+          initialLength: defaultTableInitialLength,
+          itemSize: defaultTableItemSize,
+        }
+        ht = new DiskHashTable(config)
+        await manifestHt.set(tableName, JSON.stringify(config))
+        await ht.init()
+        hts.set(tableName, ht)
+      } else if (request.headers["client-name"] == "DiskSortedHashTableClient") {
+        const config = {
+          storagePath: `${databasePath}/${tableName}/storage`,
+          headerPath: `${databasePath}/${tableName}/header`,
+          initialLength: defaultTableInitialLength,
+          itemSize: defaultTableItemSize,
+          sortValueType: request.headers["sort-value-type"],
+          degree: Number(request.headers["degree"]),
+        }
+        ht = new DiskSortedHashTable(config)
+        await manifestHt.set(tableName, JSON.stringify(config))
+        await ht.init()
+        hts.set(tableName, ht)
+      } else {
+        const error = new Error("Forbidden: Client-Name")
+        error.code = 403
+        throw error
+      }
+    }
+    return ht
+  }
+
+  return async function databaseHandler(request, response) {
+    const { pathname } = new URL(`http://*${request.url}`)
+    request.path = decodeURIComponent(
+      pathname == "/" ? pathname
+      : pathname.endsWith("/") ? pathname.slice(0, -1)
+      : pathname
+    )
+    request.pathSegments = request.path.slice(1).split("/")
+    request.pathDepth = request.pathSegments.length
+
+    if (request.pathDepth == 2) {
+      const tableName = request.pathSegments[0]
+      const fname = request.pathSegments[1]
+      const ht = hts.get(tableName)
+        ?? await getHt(tableName, request, manifestHt)
+
+      await switchCase(
+        fname,
+
+        eq("clear"), async () => {
+          await ht.clear()
+          response.writeHead(200, {
+            "Content-Type": "text/plain",
+          })
+          response.end("OK")
+        },
+
+        eq("set"), async () => {
+          const { key, value, sortValue } = await Readable.JSON(request)
+          await ht.set(key, value, sortValue)
+          response.writeHead(200, {
+            "Content-Type": "text/plain",
+          })
+          response.end("OK")
+        },
+
+        eq("get"), async () => {
+          const { key } = await Readable.JSON(request)
+          const value = await ht.get(key)
+          if (value === undefined) {
+            response.writeHead(499, {
+              "Content-Type": "text/plain",
+            })
+            response.end("Resource Not Found")
+          } else {
+            response.writeHead(200, {
+              "Content-Type": "text/plain",
+            })
+            response.end(value)
+          }
+        },
+
+        eq("getBinary"), async () => {
+          const { key } = await Readable.JSON(request)
+          const value = await ht.getBinary(key)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+          })
+          response.end(value)
+        },
+
+        eq("delete"), async () => {
+          const { key } = await Readable.JSON(request)
+          const didDelete = await ht.delete(key)
+          response.writeHead(200, {
+            "Content-Type": "text/plain",
+          })
+          response.end(String(didDelete))
+        },
+
+        eq("count"), async () => {
+          const count = ht.count()
+          response.writeHead(200, {
+            "Content-Type": "text/plain",
+          })
+          response.end(String(count))
+        },
+
+        eq("iterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const value of ht.iterator(options)) {
+            response.write(value)
+            response.write("")
+          }
+          response.end()
+        },
+
+        eq("entriesIterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const [key, value] of ht.entriesIterator(options)) {
+            response.write(key)
+            response.write("")
+            response.write(value)
+            response.write("")
+          }
+          response.end()
+        },
+
+        eq("forwardIterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const value of ht.forwardIterator(options)) {
+            response.write(value)
+            response.write("")
+          }
+          response.end()
+        },
+
+        eq("reverseIterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const value of ht.reverseIterator(options)) {
+            response.write(value)
+            response.write("")
+          }
+          response.end()
+        },
+
+        eq("forwardEntriesIterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const [key, value, sortValue] of ht.forwardEntriesIterator(options)) {
+            response.write(key)
+            response.write("")
+            response.write(value)
+            response.write("")
+            response.write(String(sortValue))
+            response.write("")
+          }
+          response.end()
+        },
+
+        eq("reverseEntriesIterator"), async () => {
+          const options = await Readable.JSON(request)
+          response.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Encoding": "utf8",
+          })
+          const count = ht.count()
+          for await (const [key, value, sortValue] of ht.reverseEntriesIterator(options)) {
+            response.write(key)
+            response.write("")
+            response.write(value)
+            response.write("")
+            response.write(String(sortValue))
+            response.write("")
+          }
+          response.end()
+        },
+
+        async () => {
+          const error = new Error("Forbidden: Hash Table Method")
+          error.code = "403"
+          throw error
+        },
+      )
+
+    } else {
+      response.writeHead(404, {
+        "Content-Type": "text/plain",
+      })
+      response.end("Not Found")
+    }
+  }
+}
+
+module.exports = DatabaseHandler

package/DatabaseServer.js

@@ -0,0 +1,97 @@
+const HTTP = require("presidium/HTTP")
+const DiskHashTable = require("presidium/DiskHashTable")
+const DatabaseHandler = require("./DatabaseHandler")
+
+/**
+ * @name DatabaseServer
+ *
+ * @docs
+ * ```specscript
+ * new DatabaseServer(options {
+ *   databasePath: string,
+ *   manifestTableName: string,
+ *   manifestTableInitialLength: number,
+ *   manifestTableItemSize: number,
+ *   defaultTableInitialLength: number,
+ *   defaultTableItemSize: number,
+ *   defaultDiskSortedHashTableDegree: number,
+ * }) -> server DatabaseServer
+ * ```
+ */
+class DatabaseServer {
+  constructor(options) {
+    this.databasePath = options.databasePath
+    this.manifestTableName = options.manifestTableName ?? "Manifest"
+    this.manifestTableInitialLength = options.manifestTableInitialLength ?? 1048576
+    this.manifestTableItemSize = options.manifestTableItemSize ?? 1024
+    this.defaultTableInitialLength = options.defaultTableInitialLength ?? 1048576
+    this.defaultTableItemSize = options.defaultTableItemSize ?? 1024
+    this.defaultDiskSortedHashTableDegree = options.defaultDiskSortedHashTableDegree ?? 2
+    this.server = null
+    this.hts = new Map()
+  }
+
+  /**
+   * @name init
+   *
+   * @docs
+   * ```specscript
+   * init() -> Promise<>
+   * ```
+   */
+  async init() {
+    const manifestHt = new DiskHashTable({
+      storagePath: `${this.databasePath}/${this.manifestTableName}/storage`,
+      headerPath: `${this.databasePath}/${this.manifestTableName}/header`,
+      initialLength: this.manifestTableInitialLength,
+      itemSize: this.manifestTableItemSize,
+    })
+    await manifestHt.init()
+    this.manifestHt = manifestHt
+
+    const databaseHandler = DatabaseHandler({
+      databasePath: this.databasePath,
+      manifestTableName: this.manifestTableName,
+      manifestTableInitialLength: this.manifestTableInitialLength,
+      manifestTableItemSize: this.manifestTableItemSize,
+      defaultTableInitialLength: this.defaultTableInitialLength,
+      defaultTableItemSize: this.defaultTableItemSize,
+      defaultDiskSortedHashTableDegree: this.defaultDiskSortedHashTableDegree,
+      manifestHt: this.manifestHt,
+      hts: this.hts,
+    })
+
+    this.server = HTTP.Server(databaseHandler)
+  }
+
+  /**
+   * @name listen
+   *
+   * @docs
+   * ```specscript
+   * listen(port number) -> ()
+   * listen(port number, callback function) -> ()
+   * ```
+   */
+  listen(port, callback) {
+    this.server.listen(port, callback)
+  }
+
+  /**
+   * @name close
+   *
+   * @docs
+   * ```specscript
+   * close() -> ()
+   * ```
+   */
+  close() {
+    this.manifestHt.close()
+    for (const ht of this.hts.values()) {
+      ht.close()
+    }
+    this.server.close()
+  }
+}
+
+module.exports = DatabaseServer

package/DiskHashTableClient.js

@@ -0,0 +1,220 @@
+require("rubico/global")
+const HTTP = require("presidium/HTTP")
+const Readable = require("presidium/Readable")
+const handleServerResponse = require("./handleServerResponse")
+const buffersToEntry = require("./buffersToEntry")
+
+/**
+ * @name DiskHashTableClient
+ *
+ * @docs
+ * ```specscript
+ * new DiskHashTableClient(options {
+ *   serverUrl: string,
+ *   tableName: string,
+ *   delimiter: string,
+ * }) -> DiskHashTableClient
+ * ```
+ */
+class DiskHashTableClient {
+  constructor(options) {
+    this.serverUrl = options.serverUrl
+    this.tableName = options.tableName
+    this.delimiter = options.delimiter ?? ""
+    this.http = new HTTP(this.serverUrl)
+  }
+
+  /**
+   * @name clear
+   *
+   * @docs
+   * ```specscript
+   * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+   *
+   * clear DiskHashTable.clear
+   * ```
+   */
+  async clear() {
+    const response = await this.http.POST(`/${this.tableName}/clear`, {
+      headers: {
+        "Client-Name": "DiskHashTableClient",
+      },
+    })
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name set
+   *
+   * @docs
+   * ```specscript
+   * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+   *
+   * set DiskHashTable.set
+   * ```
+   */
+  async set(key, value) {
+    const response = await this.http.POST(`/${this.tableName}/set`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify({ key, value }),
+    })
+    await handleServerResponse(response)
+  }
+
+  /**
+   * @name get
+   *
+   * @docs
+   * ```specscript
+   * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+   *
+   * get DiskHashTable.get
+   * ```
+   */
+  async get(key) {
+    const response = await this.http.POST(`/${this.tableName}/get`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify({ key }),
+    })
+    if (response.status == 499) {
+      return undefined
+    }
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name getBinary
+   *
+   * @docs
+   * ```specscript
+   * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+   *
+   * getBinary DiskHashTable.getBinary
+   * ```
+   */
+  async getBinary(key) {
+    const response = await this.http.POST(`/${this.tableName}/getBinary`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify({ key }),
+    })
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name delete
+   *
+   * @docs
+   * ```specscript
+   * module DiskHashTable "https://presidium.services/docs/DiskHashTable"
+   *
+   * delete DiskHashTable.delete
+   * ```
+   */
+  async delete(key) {
+    const response = await this.http.POST(`/${this.tableName}/delete`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify({ key }),
+    })
+    const didDeleteText = await handleServerResponse(response)
+    return didDeleteText == "true"
+  }
+
+  /**
+   * @name count
+   *
+   * @docs
+   * ```specscript
+   * count() -> Promise<number>
+   * ```
+   */
+  async count() {
+    const response = await this.http.POST(`/${this.tableName}/count`, {
+      headers: {
+        "Client-Name": "DiskHashTableClient",
+      },
+    })
+    const scount = await handleServerResponse(response)
+    return Number(scount)
+  }
+
+  /**
+   * @name iterator
+   *
+   * @docs
+   * ```specscript
+   * iterator(options {
+   *   valueType: "string"|"binary",
+   * }) -> values AsyncIterator<string|Buffer>
+   * ```
+   */
+  async iterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/iterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify(options),
+    })
+    if (valueType == "binary") {
+      return handleServerResponse(response, {
+        binaryStream: true,
+        delimiter: this.delimiter,
+      })
+    }
+    return handleServerResponse(response, {
+      textStream: true,
+      delimiter: this.delimiter,
+    })
+  }
+
+  /**
+   * @name entriesIterator
+   *
+   * @docs
+   * ```specscript
+   * entriesIterator(options {
+   *   valueType: 'string'|'binary',
+   * }) -> entries AsyncIterator<[key string, value string|Buffer]>
+   * ```
+   */
+  async entriesIterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/entriesIterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskHashTableClient",
+      },
+      body: JSON.stringify({ valueType }),
+    })
+
+    if (valueType == "binary") {
+      const iter = await handleServerResponse(response, {
+        binaryEntriesStream: true,
+        delimiter: this.delimiter,
+        entryLength: 2,
+      })
+      return map(iter, curry.arity(4, buffersToEntry, __, 2, "utf8", valueType))
+    }
+    const iter = await handleServerResponse(response, {
+      textEntriesStream: true,
+      delimiter: this.delimiter,
+      entryLength: 2,
+    })
+    return map(iter, curry.arity(4, buffersToEntry, __, 2, "utf8", valueType))
+  }
+}
+
+module.exports = DiskHashTableClient

package/DiskSortedHashTableClient.js

@@ -0,0 +1,317 @@
+require("rubico/global")
+const HTTP = require("presidium/HTTP")
+const handleServerResponse = require("./handleServerResponse")
+const buffersToEntry = require("./buffersToEntry")
+
+/**
+ * @name DiskSortedHashTableClient
+ *
+ * @docs
+ * ```specscript
+ * new DiskSortedHashTableClient(options {
+ *   serverUrl: string,
+ *   tableName: string,
+ *   sortValueType: "string"|"number",
+ *   degree: number,
+ *   delimiter: string,
+ * }) -> DiskSortedHashTableClient
+ * ```
+ */
+class DiskSortedHashTableClient {
+  constructor(options) {
+    this.serverUrl = options.serverUrl
+    this.tableName = options.tableName
+    this.sortValueType = options.sortValueType
+    this.degree = options.degree ?? 2
+    this.delimiter = options.delimiter ?? ""
+    this.http = new HTTP(this.serverUrl)
+  }
+
+  /**
+   * @name clear
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * clear DiskSortedHashTable.clear
+   * ```
+   */
+  async clear() {
+    const response = await this.http.POST(`/${this.tableName}/clear`, {
+      headers: {
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+    })
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name set
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * set DiskSortedHashTable.set
+   * ```
+   */
+  async set(key, value, sortValue) {
+    const response = await this.http.POST(`/${this.tableName}/set`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify({ key, value, sortValue }),
+    })
+    await handleServerResponse(response)
+  }
+
+  /**
+   * @name get
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * get DiskSortedHashTable.get
+   * ```
+   */
+  async get(key) {
+    const response = await this.http.POST(`/${this.tableName}/get`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify({ key }),
+    })
+    if (response.status == 499) {
+      return undefined
+    }
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name getBinary
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * getBinary DiskSortedHashTable.getBinary
+   * ```
+   */
+  async getBinary(key) {
+    const response = await this.http.POST(`/${this.tableName}/getBinary`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify({ key }),
+    })
+    return handleServerResponse(response)
+  }
+
+  /**
+   * @name forwardIterator
+   *
+   * @docs
+   * ```specscript
+   * forwardIterator(options {
+   *   exclusiveStartKey: string, 
+   *   startingSortValue: string|number,
+   *   endingSortValue: string|number,
+   *   valueType: 'string'|'binary',
+   * }) -> values AsyncIterator<string|Buffer>
+   * ```
+   */
+  async forwardIterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/forwardIterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify(options),
+    })
+    if (valueType == "binary") {
+      return handleServerResponse(response, {
+        binaryStream: true,
+        delimiter: this.delimiter,
+      })
+    }
+    return handleServerResponse(response, {
+      textStream: true,
+      delimiter: this.delimiter,
+    })
+  }
+
+  /**
+   * @name reverseIterator
+   *
+   * @docs
+   * ```specscript
+   * reverseIterator(options {
+   *   exclusiveStartKey: string, 
+   *   startingSortValue: string|number,
+   *   endingSortValue: string|number,
+   *   valueType: 'string'|'binary',
+   * }) -> values AsyncIterator<string|Buffer>
+   * ```
+   */
+  async reverseIterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/reverseIterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify(options),
+    })
+    if (valueType == "binary") {
+      return handleServerResponse(response, {
+        binaryStream: true,
+        delimiter: this.delimiter,
+      })
+    }
+    return handleServerResponse(response, {
+      textStream: true,
+      delimiter: this.delimiter,
+    })
+  }
+
+  /**
+   * @name forwardEntriesIterator
+   *
+   * @docs
+   * ```specscript
+   * forwardEntriesIterator(options {
+   *   exclusiveStartKey: string, 
+   *   startingSortValue: string|number,
+   *   endingSortValue: string|number,
+   *   valueType: 'string'|'binary',
+   * }) -> values AsyncIterator<string|Buffer>
+   * ```
+   */
+  async forwardEntriesIterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/forwardEntriesIterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify(options),
+    })
+    if (valueType == "binary") {
+      const iter = await handleServerResponse(response, {
+        binaryEntriesStream: true,
+        delimiter: this.delimiter,
+        entryLength: 3,
+      })
+      return map(iter, curry(buffersToEntry, __, 3, "utf8", valueType, this.sortValueType))
+    }
+    const iter = await handleServerResponse(response, {
+      textEntriesStream: true,
+      delimiter: this.delimiter,
+      entryLength: 3,
+    })
+    return map(iter, curry(buffersToEntry, __, 3, "utf8", valueType, this.sortValueType))
+  }
+
+  /**
+   * @name reverseEntriesIterator
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * reverseEntriesIterator DiskSortedHashTable.reverseEntriesIterator
+   * ```
+   */
+  async reverseEntriesIterator(options = {}) {
+    const { valueType } = options
+    const response = await this.http.POST(`/${this.tableName}/reverseEntriesIterator`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify(options),
+    })
+
+    if (valueType == "binary") {
+      const iter = await handleServerResponse(response, {
+        binaryEntriesStream: true,
+        delimiter: this.delimiter,
+        entryLength: 3,
+      })
+      return map(iter, curry(buffersToEntry, __, 3, "utf8", valueType, this.sortValueType))
+    }
+    const iter = await handleServerResponse(response, {
+      textEntriesStream: true,
+      delimiter: this.delimiter,
+      entryLength: 3,
+    })
+    return map(iter, curry(buffersToEntry, __, 3, "utf8", valueType, this.sortValueType))
+  }
+
+  /**
+   * @name delete
+   *
+   * @docs
+   * ```specscript
+   * module DiskSortedHashTable "https://presidium.services/docs/DiskSortedHashTable"
+   *
+   * delete DiskSortedHashTable.delete
+   * ```
+   */
+  async delete(key) {
+    const response = await this.http.POST(`/${this.tableName}/delete`, {
+      headers: {
+        "Content-Type": "application/json",
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+      body: JSON.stringify({ key }),
+    })
+    const didDeleteText = await handleServerResponse(response)
+    return didDeleteText == "true"
+  }
+
+  /**
+   * @name count
+   *
+   * @docs
+   * ```specscript
+   * count() -> Promise<number>
+   * ```
+   */
+  async count() {
+    const response = await this.http.POST(`/${this.tableName}/count`, {
+      headers: {
+        "Client-Name": "DiskSortedHashTableClient",
+        "Sort-Value-Type": this.sortValueType,
+        "Degree": Number(this.degree),
+      },
+    })
+    return Number(await handleServerResponse(response))
+  }
+}
+
+module.exports = DiskSortedHashTableClient

package/TextEntriesStream.js

@@ -0,0 +1,69 @@
+const EventEmitter = require("events")
+
+/**
+ * @name TextEntriesStream
+ *
+ * @docs
+ * ```coffeescript [specscript]
+ * module EventEmitter "./specscript/EventEmitter.ss"
+ *
+ * TextEntriesStream(
+ *   readable stream.Readable,
+ *   entryLength number,
+ *   delimiter string
+ * ) -> textEntriesStream EventEmitter
+ *
+ * textEntriesStream.on("entry", (entry Array<string>, keyEncoding string) -> ())
+ *
+ * textEntriesStream.on("end", () -> ())
+ * ```
+ */
+class TextEntriesStream extends EventEmitter {
+  constructor(readable, entryLength, delimiter, encoding) {
+    super()
+
+    delimiter ??= ""
+    encoding ??= "utf8"
+
+    let s = ""
+    let entry = []
+    readable.on('data', (chunk, encoding) => {
+      if (typeof chunk == 'string') {
+        s += Buffer.from(chunk, encoding).toString(encoding)
+      } else {
+        s += chunk.toString(encoding)
+      }
+
+      let delimiterIndex = s.indexOf(delimiter)
+      while (delimiterIndex > -1) {
+        const text = s.slice(0, delimiterIndex)
+        entry.push(text)
+        if (entry.length == entryLength) {
+          this.emit("entry", entry, encoding)
+          entry = []
+        }
+        s = s.slice(delimiterIndex + 1)
+        delimiterIndex = s.indexOf(delimiter)
+      }
+    })
+
+    readable.on("end", () => {
+      if (s.length > 0) {
+        entry.push(s)
+      }
+      if (entry.length == entryLength) {
+        this.emit("entry", entry, encoding)
+        this.emit("end")
+        entry = []
+      } else if (entry.length > 0) {
+        const error = new Error("last entry")
+        error.entry = entry
+        this.emit("error", error)
+      } else {
+        this.emit("end")
+      }
+    })
+  }
+}
+
+module.exports = TextEntriesStream

package/TextStream.js

@@ -0,0 +1,51 @@
+const EventEmitter = require("events")
+
+/**
+ * @name TextStream
+ *
+ * @docs
+ * ```coffeescript [specscript]
+ * module stream 'https://nodejs.org/docs/latest-v26.x/api/stream.html'
+ * module events 'https://nodejs.org/docs/latest-v26.x/api/events.html'
+ *
+ * TextStream(readable stream.Readable, delimiter string) -> textStream events.EventEmitter
+ *
+ * textStream.on("data", (text string, encoding string) -> ())
+ *
+ * textStream.on("end", () -> ())
+ * ```
+ */
+class TextStream extends EventEmitter {
+  constructor(readable, delimiter, encoding) {
+    super()
+
+    delimiter ??= ""
+    encoding ??= "utf8"
+
+    let s = ""
+    readable.on('data', (chunk, encoding) => {
+      if (typeof chunk == 'string') {
+        s += Buffer.from(chunk, encoding).toString(encoding)
+      } else {
+        s += chunk.toString(encoding)
+      }
+
+      let delimiterIndex = s.indexOf(delimiter)
+      while (delimiterIndex > -1) {
+        const text = s.slice(0, delimiterIndex)
+        this.emit("data", text, encoding)
+        s = s.slice(delimiterIndex + 1)
+        delimiterIndex = s.indexOf(delimiter)
+      }
+    })
+
+    readable.on('end', () => {
+      if (s.length > 0) {
+        this.emit("data", s, encoding)
+      }
+      this.emit("end")
+    })
+  }
+}
+
+module.exports = TextStream

package/buffersToEntry.js

@@ -0,0 +1,40 @@
+/**
+ * @name buffersToEntry
+ *
+ * @docs
+ * ```specscript
+ * buffersToEntry(
+ *   buffers Array<Buffer>,
+ *   entryLength number,
+ *   encoding string,
+ *   valueType string,
+ * ) -> Array<string, Buffer>
+ *
+ * buffersToEntry(
+ *   buffers Array<Buffer>,
+ *   entryLength number,
+ *   encoding string,
+ *   valueType string,
+ *   sortValueType string
+ * ) -> Array<string, Buffer>
+ * ```
+ */
+function buffersToEntry(buffers, entryLength, encoding, valueType, sortValueType) {
+  if (entryLength == 3) {
+    const key = buffers[0].toString(encoding)
+    const value = valueType == "string"
+      ? buffers[1].toString(encoding)
+      : buffers[1]
+    const sortValue = sortValueType == "number"
+      ? Number(buffers[2].toString(encoding))
+      : buffers[2].toString(encoding)
+    return [key, value, sortValue]
+  }
+  const key = buffers[0].toString(encoding)
+  const value = valueType == "string"
+    ? buffers[1].toString(encoding)
+    : buffers[1]
+  return [key, value]
+}
+
+module.exports = buffersToEntry

package/handleServerResponse.js

@@ -0,0 +1,68 @@
+const Readable = require("presidium/Readable")
+const TextStream = require("./TextStream")
+const BinaryStream = require("./BinaryStream")
+const TextEntriesStream = require("./TextEntriesStream")
+const BinaryEntriesStream = require("./BinaryEntriesStream")
+const AsyncIterator = require("./AsyncIterator")
+
+/**
+ * @name handleServerResponse
+ *
+ * @docs
+ * ```specscript
+ * module http 'https://nodejs.org/docs/latest-v26.x/api/http.html'
+ * module events 'https://nodejs.org/docs/latest-v26.x/api/events.html'
+ *
+ * handleServerResponse(response http.ServerResponse, options {
+ *   textStream: boolean,
+ *   binaryStream: boolean,
+ *   textEntriesStream: boolean,
+ *   binaryEntriesStream: boolean,
+ *   delimiter: string,
+ *   entryLength: number,
+ * }) -> data object|events.EventEmitter
+ * ```
+ */
+async function handleServerResponse(response, options = {}) {
+  const {
+    textStream,
+    binaryStream,
+    textEntriesStream,
+    binaryEntriesStream,
+    delimiter = "",
+    entryLength,
+  } = options
+
+  const encoding = response.headers["content-encoding"] ?? "utf8"
+
+  if (response.ok) {
+    if (textStream) {
+      const stream = new TextStream(response, delimiter, encoding)
+      return AsyncIterator.fromEvents(stream)
+    }
+    if (binaryStream) {
+      const stream = new BinaryStream(response, delimiter)
+      return AsyncIterator.fromEvents(stream)
+    }
+    if (textEntriesStream) {
+      const stream = new TextEntriesStream(response, entryLength, delimiter, encoding)
+      return AsyncIterator.fromEvents(stream, "entry")
+    }
+    if (binaryEntriesStream) {
+      const stream = new BinaryEntriesStream(response, entryLength, delimiter, encoding)
+      return AsyncIterator.fromEvents(stream, "entry")
+    }
+    if (response.headers["content-type"] == "application/json") {
+      return Readable.JSON(response)
+    }
+    if (response.headers["content-type"] == "application/octet-stream") {
+      return Readable.Buffer(response)
+    }
+    return Readable.Text(response)
+  }
+  const message = await Readable.Text(response)
+  const error = new Error(message)
+  throw error
+}
+
+module.exports = handleServerResponse

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "presidium-db-client-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.0",
+  "description": "Presidium DB client and server library",
+  "author": "Richard Tong",
+  "license": "CFOSS",
+  "repository": {
+    "type": "git",
+    "url": "github:richytong/presidium-db-client-server"
+  },
+  "homepage": "https://github.com/richytong/presidium-db-client-server",
+  "files": [
+    "ArrayEventEmitter.js",
+    "AsyncIterator.js",
+    "BinaryEntriesStream.js",
+    "BinaryStream.js",
+    "DatabaseHandler.js",
+    "DatabaseServer.js",
+    "DiskHashTableClient.js",
+    "DiskSortedHashTableClient.js",
+    "TextEntriesStream.js",
+    "TextStream.js",
+    "buffersToEntry.js",
+    "handleServerResponse.js"
+  ],
+  "keywords": [
+    "presidium",
+    "db",
+    "database",
+    "client",
+    "server",
+    "key-value",
+    "node",
+    "nodejs",
+    "javascript"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "dependencies": {}
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.