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

package/ArrayEventEmitter.js

@@ -0,0 +1,21 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,38 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,75 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,54 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,292 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,101 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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