presidium-db-client-server 0.3.1 → 0.5.0

package/DatabaseHandler.js

@@ -111,181 +111,173 @@ function DatabaseHandler(options) {
     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)
+    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, {
-            "Content-Type": "text/plain",
-          })
-          response.end("OK")
-        },
+      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, {
+      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("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.end("Resource Not Found")
+        } else {
           response.writeHead(200, {
-            "Content-Type": "application/octet-stream",
+            "Content-Type": "text/plain",
           })
           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("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("count"), async () => {
-          const count = ht.count()
-          response.writeHead(200, {
-            "Content-Type": "text/plain",
-          })
-          response.end(String(count))
-        },
+      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("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("count"), async () => {
+        const count = ht.count()
+        response.writeHead(200, {
+          "Content-Type": "text/plain",
+        })
+        response.end(String(count))
+      },
 
-        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("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("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("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("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("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("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("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("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 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()
+      },
 
-        async () => {
-          const error = new Error("Forbidden: Hash Table Method")
-          error.code = "403"
-          throw error
-        },
-      )
+      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")
-    }
   }
 }
 

package/DatabaseServer.js

@@ -7,12 +7,18 @@ 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")
 
 /**
  * @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 +27,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 +39,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,8 +74,16 @@ class DatabaseServer {
       hts: this.hts,
     })
 
-    const handler = tryCatch(
-      databaseHandler,
+    const router = tryCatch(
+      switchCase(
+        request => request.path == "/health",
+        healthCheckHandler,
+
+        request => request.pathDepth == 2,
+        databaseHandler,
+
+        notFoundHandler,
+      ),
       function errorHandler(error, request, response) {
         response.writeHead(error.code ?? 500, {
           "Content-Type": "text/plain",
@@ -77,6 +92,21 @@ class DatabaseServer {
       }
     )
 
+    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/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/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.3.1",
+  "version": "0.5.0",
   "description": "Presidium DB client and server library",
   "author": "Richard Tong",
   "license": "CFOSS",
@@ -21,7 +21,9 @@
     "TextEntriesStream.js",
     "TextStream.js",
     "buffersToEntry.js",
-    "handleServerResponse.js"
+    "handleServerResponse.js",
+    "healthCheckHandler.js",
+    "notFoundHandler.js"
   ],
   "keywords": [
     "presidium",