presidium-db-client-server 0.4.0 → 0.6.0

package/DatabaseHandler.js

@@ -111,186 +111,219 @@ function DatabaseHandler(options) {
     request.pathSegments = request.path.slice(1).split("/")
     request.pathDepth = request.pathSegments.length
 
-    if (request.path == "/health") {
-      response.writeHead(200, {
-        "Content-Type": "text/plain",
-      })
-      response.end("OK")
-    } else if (request.pathDepth == 2) {
-      const tableName = request.pathSegments[0]
-      const fname = request.pathSegments[1]
-      const ht = hts.get(tableName)
-        ?? await getHt(tableName, request, manifestHt)
+    const tableName = request.pathSegments[0]
+    const fname = request.pathSegments[1]
+    const ht = hts.get(tableName) ?? await getHt(tableName, request, manifestHt)
 
-      await switchCase(
-        fname,
+    await switchCase(
+      fname,
 
-        eq("clear"), async () => {
-          await ht.clear()
-          response.writeHead(200, {
+      eq("clear"), async () => {
+        await ht.clear()
+        response.writeHead(200, {
+          "Content-Type": "text/plain",
+        })
+        response.end("OK")
+      },
+
+      eq("set"), async () => {
+        const key = request.headers["key"]
+        const sortValue = request.headers["sort-value"]
+        const value = request.headers["content-type"] == "text/plain"
+          ? await Readable.Text(request)
+          : await Readable.Buffer(request)
+        await ht.set(key, value, sortValue)
+        response.writeHead(200, {
+          "Content-Type": "text/plain",
+        })
+        response.end("OK")
+      },
+
+      eq("get"), async () => {
+        const key = request.headers["key"]
+        const value = await ht.get(key)
+        if (value === undefined) {
+          response.writeHead(499, {
             "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.end("Resource Not Found")
+        } else {
           response.writeHead(200, {
             "Content-Type": "text/plain",
           })
-          response.end("OK")
-        },
+          response.end(value)
+        }
+      },
 
-        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 = request.headers["key"]
+        const value = await ht.getBinary(key)
+        response.writeHead(200, {
+          "Content-Type": "application/octet-stream",
+        })
+        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 = request.headers["key"]
+        const didDelete = await ht.delete(key)
+        response.writeHead(200, {
+          "Content-Type": "text/plain",
+        })
+        response.end(String(didDelete))
+      },
 
-        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("count"), async () => {
-          const count = ht.count()
-          response.writeHead(200, {
-            "Content-Type": "text/plain",
-          })
-          response.end(String(count))
-        },
+      eq("iterator"), async () => {
+        const valueType = request.headers["value-type"]
+        const options = filter({ valueType }, __)
+        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("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 valueType = request.headers["value-type"]
+        const options = filter({ valueType }, __)
+        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("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 valueType = request.headers["value-type"]
+        const exclusiveStartKey = request.headers["exclusive-start-key"]
+        const startingSortValue = request.headers["starting-sort-value"]
+        const endingSortValue = request.headers["ending-sort-value"]
+        const options = filter({
+          valueType,
+          exclusiveStartKey,
+          startingSortValue,
+          endingSortValue,
+        }, __)
 
-        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()
-        },
+        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("reverseIterator"), async () => {
+        const valueType = request.headers["value-type"]
+        const exclusiveStartKey = request.headers["exclusive-start-key"]
+        const startingSortValue = request.headers["starting-sort-value"]
+        const endingSortValue = request.headers["ending-sort-value"]
+        const options = filter({
+          valueType,
+          exclusiveStartKey,
+          startingSortValue,
+          endingSortValue,
+        }, __)
 
-        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()
-        },
+        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("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()
-        },
+      eq("forwardEntriesIterator"), async () => {
+        const valueType = request.headers["value-type"]
+        const exclusiveStartKey = request.headers["exclusive-start-key"]
+        const startingSortValue = request.headers["starting-sort-value"]
+        const endingSortValue = request.headers["ending-sort-value"]
+        const options = filter({
+          valueType,
+          exclusiveStartKey,
+          startingSortValue,
+          endingSortValue,
+        }, __)
 
-        async () => {
-          const error = new Error("Forbidden: Hash Table Method")
-          error.code = "403"
-          throw error
-        },
-      )
+        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 valueType = request.headers["value-type"]
+        const exclusiveStartKey = request.headers["exclusive-start-key"]
+        const startingSortValue = request.headers["starting-sort-value"]
+        const endingSortValue = request.headers["ending-sort-value"]
+        const options = filter({
+          valueType,
+          exclusiveStartKey,
+          startingSortValue,
+          endingSortValue,
+        }, __)
+
+        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")
-    }
   }
 }
 

package/DatabaseLoadBalancer.js

@@ -0,0 +1,95 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+require("rubico/global")
+const HTTP = require("presidium/HTTP")
+const loadBalancerHandler = require("./loadBalancerHandler")
+const healthCheckHandler = require("./healthCheckHandler")
+const notFoundHandler = require("./notFoundHandler")
+const errorHandler = require("./errorHandler")
+
+/**
+ * @name DatabaseLoadbalancer
+ *
+ * @docs
+ * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * HTTP.Handler(HTTP.Request, HTTP.Response) -> ()
+ *
+ * new DatabaseLoadbalancer(
+ *   hash(tableName string, key string, length number) -> Promise|number,
+ *   options {
+ *     serverIps: Array<string>,
+ *   },
+ *   ...handlers Arguments<HTTP.Handler>
+ * )
+ * ```
+ */
+class DatabaseLoadbalancer {
+  constructor(hash, options, ...handlers) {
+    this.hash = hash
+    this.serverIps = options.serverIps
+    this.handlers = handlers
+    this.clients = new Map()
+
+    const router = tryCatch(
+      switchCase(
+        request => request.path == "/health",
+        healthCheckHandler,
+
+        request => request.pathDepth == 2,
+        curry.call(loadBalancerHandler, this),
+
+        notFoundHandler,
+      ),
+      errorHandler
+    )
+
+    const handler = all.series([
+      ...this.handlers,
+      request => {
+        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
+      },
+      router,
+    ])
+
+    this.server = HTTP.Server(handler)
+  }
+
+  /**
+   * @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.server.close()
+  }
+
+}
+
+module.exports = DatabaseLoadbalancer

package/DatabaseServer.js

@@ -7,12 +7,19 @@ const HTTP = require("presidium/HTTP")
 const DiskHashTable = require("presidium/DiskHashTable")
 const DiskSortedHashTable = require("presidium/DiskSortedHashTable")
 const DatabaseHandler = require("./DatabaseHandler")
+const healthCheckHandler = require("./healthCheckHandler")
+const notFoundHandler = require("./notFoundHandler")
+const errorHandler = require("./errorHandler")
 
 /**
  * @name DatabaseServer
  *
  * @docs
  * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * HTTP.Handler(request HTTP.Request, response HTTP.Response) -> ()
+ *
  * new DatabaseServer(options {
  *   databasePath: string,
  *   manifestTableName: string,
@@ -21,11 +28,11 @@ const DatabaseHandler = require("./DatabaseHandler")
  *   defaultTableInitialLength: number,
  *   defaultTableItemSize: number,
  *   defaultDiskSortedHashTableDegree: number,
- * }) -> server DatabaseServer
+ * }, ...handlers Arguments<HTTP.Handler>) -> server DatabaseServer
  * ```
  */
 class DatabaseServer {
-  constructor(options) {
+  constructor(options, ...handlers) {
     this.databasePath = options.databasePath
     this.manifestTableName = options.manifestTableName ?? "Manifest"
     this.manifestTableInitialLength = options.manifestTableInitialLength ?? 1048576
@@ -33,6 +40,7 @@ class DatabaseServer {
     this.defaultTableInitialLength = options.defaultTableInitialLength ?? 1048576
     this.defaultTableItemSize = options.defaultTableItemSize ?? 1024
     this.defaultDiskSortedHashTableDegree = options.defaultDiskSortedHashTableDegree ?? 2
+    this.handlers = handlers
     this.server = null
     this.hts = new Map()
   }
@@ -67,16 +75,34 @@ class DatabaseServer {
       hts: this.hts,
     })
 
-    const handler = tryCatch(
-      databaseHandler,
-      function errorHandler(error, request, response) {
-        response.writeHead(error.code ?? 500, {
-          "Content-Type": "text/plain",
-        })
-        response.end(error.message)
-      }
+    const router = tryCatch(
+      switchCase(
+        request => request.path == "/health",
+        healthCheckHandler,
+
+        request => request.pathDepth == 2,
+        databaseHandler,
+
+        notFoundHandler,
+      ),
+      errorHandler
     )
 
+    const handler = all.series([
+      ...this.handlers,
+      request => {
+        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
+      },
+      router,
+    ])
+
     this.server = HTTP.Server(handler)
   }
 

package/DiskHashTableClient.js

@@ -41,6 +41,7 @@ class DiskHashTableClient {
   async clear() {
     const response = await this.http.POST(`/${this.tableName}/clear`, {
       headers: {
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
       },
     })
@@ -60,10 +61,13 @@ class DiskHashTableClient {
   async set(key, value) {
     const response = await this.http.POST(`/${this.tableName}/set`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": Buffer.isBuffer(value)
+          ? "application/octet-stream"
+          : "text/plain",
         "Client-Name": "DiskHashTableClient",
+        "Key": key,
       },
-      body: JSON.stringify({ key, value }),
+      body: value,
     })
     await handleServerResponse(response)
   }
@@ -81,10 +85,10 @@ class DiskHashTableClient {
   async get(key) {
     const response = await this.http.POST(`/${this.tableName}/get`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
+        "Key": key,
       },
-      body: JSON.stringify({ key }),
     })
     if (response.status == 499) {
       return undefined
@@ -105,10 +109,10 @@ class DiskHashTableClient {
   async getBinary(key) {
     const response = await this.http.POST(`/${this.tableName}/getBinary`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
+        "Key": key,
       },
-      body: JSON.stringify({ key }),
     })
     return handleServerResponse(response)
   }
@@ -126,10 +130,10 @@ class DiskHashTableClient {
   async delete(key) {
     const response = await this.http.POST(`/${this.tableName}/delete`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
+        "Key": key,
       },
-      body: JSON.stringify({ key }),
     })
     const didDeleteText = await handleServerResponse(response)
     return didDeleteText == "true"
@@ -146,6 +150,7 @@ class DiskHashTableClient {
   async count() {
     const response = await this.http.POST(`/${this.tableName}/count`, {
       headers: {
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
       },
     })
@@ -167,10 +172,10 @@ class DiskHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/iterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
+        ...valueType ? { "Value-Type": valueType } : {},
       },
-      body: JSON.stringify(options),
     })
     if (valueType == "binary") {
       return handleServerResponse(response, {
@@ -198,10 +203,10 @@ class DiskHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/entriesIterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskHashTableClient",
+        ...valueType ? { "Value-Type": valueType } : {},
       },
-      body: JSON.stringify({ valueType }),
     })
 
     if (valueType == "binary") {

package/DiskSortedHashTableClient.js

@@ -6,6 +6,7 @@ require("rubico/global")
 const HTTP = require("presidium/HTTP")
 const handleServerResponse = require("./handleServerResponse")
 const buffersToEntry = require("./buffersToEntry")
+const parseString = require("./parseString")
 
 /**
  * @name DiskSortedHashTableClient
@@ -44,13 +45,14 @@ class DiskSortedHashTableClient {
   async clear() {
     const response = await this.http.POST(`/${this.tableName}/clear`, {
       headers: {
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
     })
     return handleServerResponse(response)
@@ -69,16 +71,20 @@ class DiskSortedHashTableClient {
   async set(key, value, sortValue) {
     const response = await this.http.POST(`/${this.tableName}/set`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": Buffer.isBuffer(value)
+          ? "application/octet-stream"
+          : "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+        "Key": key,
+        "Sort-Value": sortValue,
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify({ key, value, sortValue }),
+      body: value,
     })
     await handleServerResponse(response)
   }
@@ -96,16 +102,16 @@ class DiskSortedHashTableClient {
   async get(key) {
     const response = await this.http.POST(`/${this.tableName}/get`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+        "Key": key,
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify({ key }),
     })
     if (response.status == 499) {
       return undefined
@@ -126,16 +132,16 @@ class DiskSortedHashTableClient {
   async getBinary(key) {
     const response = await this.http.POST(`/${this.tableName}/getBinary`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+        "Key": key,
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify({ key }),
     })
     return handleServerResponse(response)
   }
@@ -157,16 +163,22 @@ class DiskSortedHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/forwardIterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(options, all({
+          "Exclusive-Start-Key": get("exclusiveStartKey"),
+          "Starting-Sort-Value": get("startingSortValue"),
+          "Ending-Sort-Value": get("endingSortValue"),
+          "Value-Type": get("valueType"),
+        }), filter(__), map(parseString)),
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify(options),
     })
     if (valueType == "binary") {
       return handleServerResponse(response, {
@@ -197,16 +209,22 @@ class DiskSortedHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/reverseIterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(options, all({
+          "Exclusive-Start-Key": get("exclusiveStartKey"),
+          "Starting-Sort-Value": get("startingSortValue"),
+          "Ending-Sort-Value": get("endingSortValue"),
+          "Value-Type": get("valueType"),
+        }), filter(__), map(parseString)),
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify(options),
     })
     if (valueType == "binary") {
       return handleServerResponse(response, {
@@ -237,16 +255,22 @@ class DiskSortedHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/forwardEntriesIterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(options, all({
+          "Exclusive-Start-Key": get("exclusiveStartKey"),
+          "Starting-Sort-Value": get("startingSortValue"),
+          "Ending-Sort-Value": get("endingSortValue"),
+          "Value-Type": get("valueType"),
+        }), filter(__), map(parseString)),
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify(options),
     })
     if (valueType == "binary") {
       const iter = await handleServerResponse(response, {
@@ -278,16 +302,22 @@ class DiskSortedHashTableClient {
     const { valueType } = options
     const response = await this.http.POST(`/${this.tableName}/reverseEntriesIterator`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(options, all({
+          "Exclusive-Start-Key": get("exclusiveStartKey"),
+          "Starting-Sort-Value": get("startingSortValue"),
+          "Ending-Sort-Value": get("endingSortValue"),
+          "Value-Type": get("valueType"),
+        }), filter(__), map(parseString)),
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify(options),
     })
 
     if (valueType == "binary") {
@@ -319,16 +349,16 @@ class DiskSortedHashTableClient {
   async delete(key) {
     const response = await this.http.POST(`/${this.tableName}/delete`, {
       headers: {
-        "Content-Type": "application/json",
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+        "Key": key,
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
-      body: JSON.stringify({ key }),
     })
     const didDeleteText = await handleServerResponse(response)
     return didDeleteText == "true"
@@ -345,13 +375,14 @@ class DiskSortedHashTableClient {
   async count() {
     const response = await this.http.POST(`/${this.tableName}/count`, {
       headers: {
+        "Content-Type": "text/plain",
         "Client-Name": "DiskSortedHashTableClient",
-        ...this.sortValueType ? {
-          "Sort-Value-Type": this.sortValueType,
-        } : {},
-        ...this.degree ? {
-          "Degree": Number(this.degree),
-        } : {},
+
+        ...pipe(this, all({
+          "Sort-Value-Type": get("sortValueType"),
+          "Degree": get("degree"),
+        }), filter(__), map(parseString)),
+
       },
     })
     return Number(await handleServerResponse(response))

package/errorHandler.js

@@ -0,0 +1,18 @@
+/**
+ * @name errorHandler
+ *
+ * @docs
+ * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * errorHandler(error Error, request HTTP.Request, response HTTP.Response) -> ()
+ * ```
+ */
+function errorHandler(error, request, response) {
+  response.writeHead(error.code ?? 500, {
+    "Content-Type": "text/plain",
+  })
+  response.end(error.message)
+}
+
+module.exports = errorHandler

package/healthCheckHandler.js

@@ -0,0 +1,18 @@
+/**
+ * @name healthCheckHandler
+ *
+ * @docs
+ * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * healthCheckHandler(request HTTP.Request, response HTTP.Response) -> ()
+ * ```
+ */
+function healthCheckHandler(request, response) {
+  response.writeHead(200, {
+    'Content-Type': 'text/plain',
+  })
+  response.end('OK')
+}
+
+module.exports = healthCheckHandler

package/loadBalancerHandler.js

@@ -0,0 +1,40 @@
+const HTTP = require("presidium/HTTP")
+
+/**
+ * @name loadBalancerHandler
+ *
+ * @docs
+ * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * loadBalancerHandler(HTTP.Request, HTTP.Response) -> ()
+ * ```
+ */
+async function loadBalancerHandler(request, response) {
+  const tableName = request.pathSegments[0]
+  const key = request.headers["key"]
+
+  let index = this.hash(tableName, key)
+  if (typeof index.then == "function") {
+    index = await index
+  }
+
+  const serverIp = this.serverIps[index]
+  let client
+  if (this.clients.has(serverIp)) {
+    client = this.clients.get(serverIp)
+  } else {
+    client = new HTTP(serverIp)
+    this.clients.set(serverIp, client)
+  }
+
+  const serverResponse = await client[request.method](request.url, {
+    headers: request.headers,
+    body: request,
+  })
+
+  response.writeHead(serverResponse.status, serverResponse.headers)
+  serverResponse.pipe(response)
+}
+
+module.exports = loadBalancerHandler

package/notFoundHandler.js

@@ -0,0 +1,18 @@
+/**
+ * @name notFoundHandler
+ *
+ * @docs
+ * ```specscript
+ * module HTTP "https://presidium.services/docs/HTTP"
+ *
+ * notFoundHandler(request HTTP.Request, response HTTP.Response) -> ()
+ * ```
+ */
+function notFoundHandler(request, response) {
+  response.writeHead(404, {
+    "Content-Type": "text/plain",
+  })
+  response.end("Not Found")
+}
+
+module.exports = notFoundHandler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presidium-db-client-server",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Presidium DB client and server library",
   "author": "Richard Tong",
   "license": "CFOSS",
@@ -14,14 +14,20 @@
     "AsyncIterator.js",
     "BinaryEntriesStream.js",
     "BinaryStream.js",
-    "DatabaseHandler.js",
     "DatabaseServer.js",
+    "DatabaseHandler.js",
+    "DatabaseLoadBalancer.js",
+    "loadBalancerHandler.js",
     "DiskHashTableClient.js",
     "DiskSortedHashTableClient.js",
     "TextEntriesStream.js",
     "TextStream.js",
     "buffersToEntry.js",
-    "handleServerResponse.js"
+    "handleServerResponse.js",
+    "healthCheckHandler.js",
+    "notFoundHandler.js",
+    "errorHandler.js",
+    "parseString.js"
   ],
   "keywords": [
     "presidium",
@@ -39,7 +45,7 @@
   },
   "dependencies": {
     "presidium": "^4.5.0",
-    "rubico": "^2.20.0"
+    "rubico": "^2.21.0"
   },
   "devDependencies": {
     "codecov": "^3.8.2"

package/parseString.js

@@ -0,0 +1,18 @@
+const numberRegex = /^[0-9\.]+$/
+
+/**
+ * @name parseString
+ *
+ * @docs
+ * ```specscript
+ * parseString(s string) -> number|string
+ * ```
+ */
+function parseString(s) {
+  if (numberRegex.test(s)) {
+    return Number(s)
+  }
+  return s
+}
+
+module.exports = parseString