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

package/DiskHashTableClient.js

@@ -0,0 +1,224 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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,321 @@
+/**
+ * Presidium DB Client and Server may be freely distributed under the CFOSS license.
+ */
+
+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/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# Presidium DB Client and Server
+![presidium](https://rubico.land/assets/presidium-logo-3-w200.jpg)
 
-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.
+Source code: [GitHub](https://github.com/richytong/presidium-websocket) |
+License: [CFOSS](https://cloutsworld.com/en-us/legal/license/cfoss)
+
+![Node.js CI](https://github.com/richytong/presidium-db-client-server/workflows/Node.js%20CI/badge.svg)
+[![codecov](https://codecov.io/gh/richytong/presidium-db-client-server/graph/badge.svg?token=07P6G8GIOQ)](https://codecov.io/gh/richytong/presidium-db-client-server)
+[![npm version](https://img.shields.io/npm/v/presidium-db-client-server.svg?style=flat)](https://www.npmjs.com/package/presidium-db-client-server)
+
+Presidium DB Client and Server.
+
+```javascript
+const DatabaseServer = require("presidium-db-client-server/DatabaseServer")
+const DiskHashTableClient = require("presidium-db-client-server/DiskHashTableClient")
+
+const server = new DatabaseServer({
+  databasePath: `${__dirname}/database`,
+})
+await server.init()
+
+server.listen(5000, () => {
+  console.log("Database server listening on port 5000")
+})
+
+const sessionHt = new DiskHashTableClient({
+  serverUrl: "http://localhost:7357",
+  tableName: "Session",
+})
+
+const accessToken = "token"
+const session = { accessToken }
+
+await sessionHt.set(accessToken, JSON.stringify(session))
+
+const sessionJson = await sessionHt.get(accessToken)
+
+await sessionHt.delete(accessToken)
+```
+
+## Docs
+Coming soon.
+
+## Installation
+
+with [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm):
+```bash
+npm i presidium-db-client-server
+```
+
+## License
+Presidium DB Client and Server is distributed under the [CFOSS License](https://cloutsworld.com/en-us/legal/license/cfoss).
+
+## Support
+ * minimum Node.js version: 16

package/TextEntriesStream.js

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