presidium-db-client-server 0.5.0 → 0.6.1

package/DatabaseHandler.js

@@ -127,7 +127,11 @@ function DatabaseHandler(options) {
       },
 
       eq("set"), async () => {
-        const { key, value, sortValue } = await Readable.JSON(request)
+        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",
@@ -136,7 +140,7 @@ function DatabaseHandler(options) {
       },
 
       eq("get"), async () => {
-        const { key } = await Readable.JSON(request)
+        const key = request.headers["key"]
         const value = await ht.get(key)
         if (value === undefined) {
           response.writeHead(499, {
@@ -152,7 +156,7 @@ function DatabaseHandler(options) {
       },
 
       eq("getBinary"), async () => {
-        const { key } = await Readable.JSON(request)
+        const key = request.headers["key"]
         const value = await ht.getBinary(key)
         response.writeHead(200, {
           "Content-Type": "application/octet-stream",
@@ -161,7 +165,7 @@ function DatabaseHandler(options) {
       },
 
       eq("delete"), async () => {
-        const { key } = await Readable.JSON(request)
+        const key = request.headers["key"]
         const didDelete = await ht.delete(key)
         response.writeHead(200, {
           "Content-Type": "text/plain",
@@ -178,7 +182,8 @@ function DatabaseHandler(options) {
       },
 
       eq("iterator"), async () => {
-        const options = await Readable.JSON(request)
+        const valueType = request.headers["value-type"]
+        const options = filter({ valueType }, __)
         response.writeHead(200, {
           "Content-Type": "application/octet-stream",
           "Content-Encoding": "utf8",
@@ -192,7 +197,8 @@ function DatabaseHandler(options) {
       },
 
       eq("entriesIterator"), async () => {
-        const options = await Readable.JSON(request)
+        const valueType = request.headers["value-type"]
+        const options = filter({ valueType }, __)
         response.writeHead(200, {
           "Content-Type": "application/octet-stream",
           "Content-Encoding": "utf8",
@@ -208,7 +214,17 @@ function DatabaseHandler(options) {
       },
 
       eq("forwardIterator"), async () => {
-        const options = await Readable.JSON(request)
+        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",
@@ -222,7 +238,17 @@ function DatabaseHandler(options) {
       },
 
       eq("reverseIterator"), async () => {
-        const options = await Readable.JSON(request)
+        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",
@@ -236,7 +262,17 @@ function DatabaseHandler(options) {
       },
 
       eq("forwardEntriesIterator"), async () => {
-        const options = await Readable.JSON(request)
+        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",
@@ -254,7 +290,17 @@ function DatabaseHandler(options) {
       },
 
       eq("reverseEntriesIterator"), async () => {
-        const options = await Readable.JSON(request)
+        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",

package/DatabaseLoadBalancer.js

@@ -0,0 +1,97 @@
+/**
+ * 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()
+    this.closed = false
+
+    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()
+    this.closed = true
+  }
+
+}
+
+module.exports = DatabaseLoadbalancer

package/DatabaseServer.js

@@ -9,6 +9,7 @@ const DiskSortedHashTable = require("presidium/DiskSortedHashTable")
 const DatabaseHandler = require("./DatabaseHandler")
 const healthCheckHandler = require("./healthCheckHandler")
 const notFoundHandler = require("./notFoundHandler")
+const errorHandler = require("./errorHandler")
 
 /**
  * @name DatabaseServer
@@ -84,12 +85,7 @@ class DatabaseServer {
 
         notFoundHandler,
       ),
-      function errorHandler(error, request, response) {
-        response.writeHead(error.code ?? 500, {
-          "Content-Type": "text/plain",
-        })
-        response.end(error.message)
-      }
+      errorHandler
     )
 
     const handler = all.series([

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presidium-db-client-server",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Presidium DB client and server library",
   "author": "Richard Tong",
   "license": "CFOSS",
@@ -14,8 +14,10 @@
     "AsyncIterator.js",
     "BinaryEntriesStream.js",
     "BinaryStream.js",
-    "DatabaseHandler.js",
     "DatabaseServer.js",
+    "DatabaseHandler.js",
+    "DatabaseLoadBalancer.js",
+    "loadBalancerHandler.js",
     "DiskHashTableClient.js",
     "DiskSortedHashTableClient.js",
     "TextEntriesStream.js",
@@ -23,7 +25,9 @@
     "buffersToEntry.js",
     "handleServerResponse.js",
     "healthCheckHandler.js",
-    "notFoundHandler.js"
+    "notFoundHandler.js",
+    "errorHandler.js",
+    "parseString.js"
   ],
   "keywords": [
     "presidium",
@@ -41,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