velocious 1.0.1 → 1.0.3

package/src/database/record/index.mjs

@@ -0,0 +1,187 @@
+import DatabasePool from "../pool/index.mjs"
+import Handler from "../handler.mjs"
+import inflection from "inflection"
+import Query from "../query/index.mjs"
+import RecordNotFoundError from "./record-not-found-error.mjs"
+
+export default class VelociousDatabaseRecord {
+  static connection() {
+    const connection = DatabasePool.current().getCurrentConnection()
+
+    if (!connection) throw new Error("No connection?")
+
+    return connection
+  }
+
+  static async find(recordId) {
+    const conditions = {}
+
+    conditions[this.primaryKey()] = recordId
+
+    const record = await this.where(conditions).first()
+
+    if (!record) {
+      throw new RecordNotFoundError(`Couldn't find ${this.name} with '${this.primaryKey()}'=${recordId}`)
+    }
+
+    return record
+  }
+
+  static async last() {
+    const query = this._newQuery().order(this.primaryKey()).limit(1)
+    const record = await query.last()
+
+    return record
+  }
+
+  static primaryKey() {
+    return "id"
+  }
+
+  async save() {
+    if (this.isPersisted()) {
+      return await this._updateRecordWithChanges()
+    } else {
+      return await this._createNewRecord()
+    }
+  }
+
+  static tableName() {
+    return inflection.underscore(inflection.pluralize(this.name))
+  }
+
+  static _newQuery() {
+    const handler = new Handler()
+    const query = new Query({
+      driver: this.connection(),
+      handler,
+      modelClass: this
+    })
+
+    return query.from(this.tableName())
+  }
+
+  static orderableColumn() {
+    // Allow to change to 'created_at' if using UUID?
+
+    return this.primaryKey()
+  }
+
+  static where(object) {
+    const query = this._newQuery().where(object)
+
+    return query
+  }
+
+  constructor(attributes = {}) {
+    this._attributes = attributes
+    this._changes = {}
+  }
+
+  assign(attributesToAssign) {
+    for (const attributeToAssign in attributesToAssign) {
+      this._changes[attributeToAssign] = attributesToAssign[attributeToAssign]
+    }
+  }
+
+  attributes() {
+    return Object.assign({}, this._attributes, this._changes)
+  }
+
+  _connection() {
+    if (this.__connection) return this.__connection
+
+    return this.constructor.connection()
+  }
+
+  async destroy() {
+    const conditions = {}
+
+    conditions[this.constructor.primaryKey()] = this.id()
+
+    const sql = this._connection().deleteSql({
+      conditions,
+      tableName: this._tableName()
+    })
+
+    await this._connection().query(sql)
+  }
+
+  _tableName() {
+    if (this.__tableName) return this.__tableName
+
+    return this.constructor.tableName()
+  }
+
+  readAttribute(attributeName) {
+    if (attributeName in this._changes) return this._changes[attributeName]
+
+    return this._attributes[attributeName]
+  }
+
+  async _createNewRecord() {
+    if (!this.constructor.connection()["insertSql"]) {
+      throw new Error(`No insertSql on ${this.constructor.connection().constructor.name}`)
+    }
+
+    const sql = this._connection().insertSql({
+      tableName: this._tableName(),
+      data: this.attributes()
+    })
+    const result = await this._connection().query(sql)
+    const id = result.insertId
+
+    await this._reloadWithId(id)
+  }
+
+  async _updateRecordWithChanges() {
+    const conditions = {}
+
+    conditions[this.constructor.primaryKey()] = this.id()
+
+    const sql = this._connection().updateSql({
+      tableName: this._tableName(),
+      data: this._changes,
+      conditions
+    })
+    await this._connection().query(sql)
+    await this._reloadWithId(this.id())
+  }
+
+  id() {
+    return this.readAttribute(this.constructor.primaryKey())
+  }
+
+  isPersisted() {
+    if (this.id()) return true
+
+    return false
+  }
+
+  isNewRecord() {
+    return !this.isPersisted()
+  }
+
+  async _reloadWithId(id) {
+    const primaryKey = this.constructor.primaryKey()
+    const whereObject = {}
+
+    whereObject[primaryKey] = id
+
+    const query = this.constructor.where(whereObject)
+    const reloadedModel = await query.first()
+
+    this._attributes = reloadedModel.attributes()
+    this._changes = {}
+  }
+
+  async reload() {
+    this._reloadWithId(this.readAttribute("id"))
+  }
+
+  async update(attributesToAssign) {
+    if (attributesToAssign) this.assign(attributesToAssign)
+
+    await this.save()
+  }
+}

package/src/database/record/record-not-found-error.mjs

@@ -0,0 +1 @@
+export default class RecordNotFoundError extends Error {}

package/src/database/table-data/index.mjs

@@ -0,0 +1,83 @@
+class TableColumn {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+class TableIndex {
+  constructor(columns, args) {
+    this.args = args
+    this.columns = columns
+  }
+
+  getColumns = () => this.columns
+  getName = () => this.args.name
+  getUnique = () => Boolean(this.args.unique)
+}
+
+class TableReference {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+export default class TableData {
+  _columns = []
+  _indexes = []
+  _references = []
+
+  constructor(name, args = {}) {
+    this.args = args
+    this._name = name
+  }
+
+  getColumns = () => this._columns
+  getName = () => this._name
+  getIfNotExists = () => this.args.ifNotExists
+  getIndexes = () => this._indexes
+  getReferences = () => this._references
+
+  bigint(name, args = {}) {
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  references(name, args = {}) {
+    const columnName = `${name}_id`
+    const indexName = `index_on_${columnName}`
+    const reference = new TableReference(name, args)
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(columnName, columnArgs)
+    const index = new TableIndex([column], {name: indexName})
+
+    this._columns.push(column)
+    this._indexes.push(index)
+    this._references.push(reference)
+  }
+
+  string(name, args) {
+    const columnArgs = Object.assign({type: "string"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  text(name, args) {
+    const columnArgs = Object.assign({type: "text"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  timestamps() {
+    const createdAtColumn = new TableColumn("created_at", {type: "datetime"})
+    const updatedAtColumn = new TableColumn("updated_at", {type: "datetime"})
+
+    this._columns.push(createdAtColumn)
+    this._columns.push(updatedAtColumn)
+  }
+}

package/src/{error-logger.js → error-logger.mjs}

@@ -1,4 +1,4 @@
-module.exports = function errorLogger(callback) {
+export default function errorLogger(callback) {
   return async function(...args) {
     try {
       await callback(...args)

package/src/http-server/client/{index.cjs → index.mjs}

@@ -1,11 +1,10 @@
-const Configuration = require("../../configuration.cjs")
-const {digg} = require("diggerize")
-const {EventEmitter} = require("events")
-const logger = require("../../logger.cjs")
-const Request = require("./request.cjs")
-const RequestRunner = require("./request-runner.cjs")
+import {digg} from "diggerize"
+import {EventEmitter} from "events"
+import logger from "../../logger.mjs"
+import Request from "./request.mjs"
+import RequestRunner from "./request-runner.mjs"
 
-module.exports = class VeoliciousHttpServerClient {
+export default class VeoliciousHttpServerClient {
   events = new EventEmitter()
   state = "initial"
 
@@ -17,7 +16,7 @@ module.exports = class VeoliciousHttpServerClient {
     this.onExecuteRequest = onExecuteRequest
   }
 
-  executeCurrentRequest() {
+  executeCurrentRequest = () => {
     logger(this, "executeCurrentRequest")
 
     this.state = "response"
@@ -28,7 +27,7 @@ module.exports = class VeoliciousHttpServerClient {
       routes: this.routes
     })
 
-    requestRunner.events.on("done", (requestRunner) => this.sendResponse(requestRunner))
+    requestRunner.events.on("done", this.sendResponse)
     requestRunner.run()
   }
 
@@ -37,7 +36,7 @@ module.exports = class VeoliciousHttpServerClient {
       this.currentRequest = new Request({
         configuration: this.configuration
       })
-      this.currentRequest.requestParser.events.on("done", () => this.executeCurrentRequest())
+      this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest)
       this.currentRequest.feed(data)
       this.state = "requestStarted"
     } else if (this.state == "requestStarted") {
@@ -47,7 +46,7 @@ module.exports = class VeoliciousHttpServerClient {
     }
   }
 
-  sendResponse(requestRunner) {
+  sendResponse = (requestRunner) => {
     const response = digg(requestRunner, "response")
     const body = response.getBody()
     const date = new Date()

package/src/http-server/client/params-to-object.mjs

@@ -0,0 +1,68 @@
+export default class ParamsToObject {
+  constructor(object) {
+    this.object = object
+  }
+
+  toObject() {
+    const result = {}
+
+    for(const key in this.object) {
+      const value = this.object[key]
+
+      this.treatInitial(key, value, result)
+    }
+
+    return result
+  }
+
+  treatInitial(key, value, result) {
+    const firstMatch = key.match(/^(.+?)(\[([\s\S]+$))/)
+
+    if (firstMatch) {
+      const inputName = firstMatch[1]
+      const rest = firstMatch[2]
+
+      let newResult
+
+      if (inputName in result) {
+        newResult = result[inputName]
+      } else if (rest == "[]") {
+        newResult = []
+        result[inputName] = newResult
+      } else {
+        newResult = {}
+        result[inputName] = newResult
+      }
+
+      this.treatSecond(value, rest, newResult)
+    } else {
+      result[key] = value
+    }
+  }
+
+  treatSecond(value, rest, result) {
+    const secondMatch = rest.match(/^\[(.*?)\]([\s\S]*)$/)
+    const key = secondMatch[1]
+    const newRest = secondMatch[2]
+
+    let newResult
+
+    if (rest == "[]") {
+      result.push(value)
+    } else if (newRest == "") {
+      result[key] = value
+    } else {
+      if (typeof result == "object" && key in result) {
+        newResult = result[key]
+      } else if (newRest == "[]") {
+        newResult = []
+        result[key] = newResult
+      } else {
+        newResult = {}
+        result[key] = newResult
+      }
+
+      this.treatSecond(value, newRest, newResult)
+    }
+  }
+}

package/src/http-server/client/request-buffer/form-data-part.mjs

@@ -0,0 +1,42 @@
+export default class FormDataPart {
+  headers = {}
+  body = []
+
+  addHeader(header) {
+    const name = header.formattedName
+
+    this.headers[name] = header
+
+    if (name == "content-disposition") {
+      const match = header.value.match(/^form-data; name="(.+)"$/)
+
+      if (match) {
+        this.name = match[1]
+      } else {
+        console.error(`Couldn't match name from content-disposition: ${header.value}`)
+      }
+    } else if (name == "content-length") {
+      this.contentLength = parseInt(header.value)
+    }
+  }
+
+  finish() {
+    this.value = String.fromCharCode.apply(null, this.body)
+  }
+
+  getName() {
+    if (!this.name) throw new Error("Name hasn't been set")
+
+    return this.name
+  }
+
+  getValue() {
+    if (!this.value) throw new Error("Value hasn't been set")
+
+    return this.value
+  }
+
+  removeFromBody(text) {
+    this.body = this.body.slice(0, this.body.length - text.length)
+  }
+}

package/src/http-server/client/request-buffer/header.mjs

@@ -0,0 +1,7 @@
+export default class Header {
+  constructor(name, value) {
+    this.formattedName = name.toLowerCase().trim()
+    this.name = name
+    this.value = value
+  }
+}

package/src/http-server/client/request-buffer/index.mjs

@@ -0,0 +1,229 @@
+import {EventEmitter} from "events"
+import FormDataPart from "./form-data-part.mjs"
+import Header from "./header.mjs"
+import Incorporator from "incorporator"
+import logger from "../../../logger.mjs"
+import ParamsToObject from "../params-to-object.mjs"
+import querystring from "querystring"
+
+export default class RequestBuffer {
+  bodyLength = 0
+  data = []
+  events = new EventEmitter()
+  headers = []
+  headersByName = {}
+  params = {}
+  postBody = ""
+  postBodyChars = []
+  readingBody = false
+  state = "status"
+
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  feed(data) {
+    for (const char of data) {
+      if (this.readingBody) this.bodyLength += 1
+
+      switch(this.state) {
+        case "status":
+        case "headers":
+        case "multi-part-form-data":
+        case "multi-part-form-data-header":
+          this.data.push(char)
+
+          if (char == 10) {
+            const line = String.fromCharCode.apply(null, this.data)
+
+            this.data = []
+            this.parse(line)
+          }
+
+          break
+        case "multi-part-form-data-body":
+          const body = this.formDataPart.body
+
+          body.push(char)
+
+          const possibleBoundaryEndPosition = body.length - this.boundaryLineEnd.length
+          const possibleBoundaryEndChars = body.slice(possibleBoundaryEndPosition, body.length)
+          const possibleBoundaryEnd = String.fromCharCode.apply(null, possibleBoundaryEndChars)
+
+          const possibleBoundaryNextPosition = body.length - this.boundaryLineNext.length
+          const possibleBoundaryNextChars = body.slice(possibleBoundaryNextPosition, body.length)
+          const possibleBoundaryNext = String.fromCharCode.apply(null, possibleBoundaryNextChars)
+
+          if (possibleBoundaryEnd == this.boundaryLineEnd) {
+            this.formDataPart.removeFromBody(possibleBoundaryEnd)
+            this.formDataPartDone()
+            this.completeRequest()
+          } else if (possibleBoundaryNext == this.boundaryLineNext) {
+            this.formDataPart.removeFromBody(possibleBoundaryNext)
+            this.formDataPartDone()
+            this.newFormDataPart()
+          } else if (this.contentLength && this.bodyLength >= this.contentLength) {
+            this.formDataPartDone()
+            this.completeRequest()
+          } else if (this.formDataPart.contentLength && this.bodyLength >= this.formDataPart.contentLength) {
+            this.formDataPartDone()
+
+            throw new Error("stub")
+          }
+
+          break
+        case "post-body":
+          this.bodyLength += 1
+          this.postBodyChars.push(char)
+
+          if (this.contentLength && this.postBodyChars.length >= this.contentLength) {
+            this.postRequestDone()
+          }
+
+          break
+        default:
+          console.error(`Unknown state: ${this.state}`)
+      }
+    }
+  }
+
+  getHeader = (name) => this.headersByName[name.toLowerCase().trim()]
+
+  formDataPartDone() {
+    const formDataPart = this.formDataPart
+
+    this.formDataPart = undefined
+    formDataPart.finish()
+
+    this.events.emit("form-data-part", formDataPart)
+  }
+
+  isMultiPartyFormData = () => this.multiPartyFormData
+
+  newFormDataPart() {
+    this.formDataPart = new FormDataPart()
+    this.setState("multi-part-form-data-header")
+  }
+
+  parse(line) {
+    if (this.state == "status") {
+      this.parseStatusLine(line)
+    } else if (this.state == "headers") {
+      this.parseHeader(line)
+    } else if (this.state == "multi-part-form-data") {
+      if (line == this.boundaryLine) {
+        this.newFormDataPart()
+      } else if (line == "\r\n") {
+        this.setState("done")
+      } else {
+        throw new Error(`Expected boundary line but didn't get it: ${line}`)
+      }
+    } else if (this.state == "multi-part-form-data-header") {
+      const header = this.readHeaderFromLine(line)
+
+      if (header) {
+        this.formDataPart.addHeader(header)
+        this.state == "multi-part-form-data"
+      } else if (line == "\r\n") {
+        this.setState("multi-part-form-data-body")
+      }
+    } else {
+      throw new Error(`Unknown state: ${this.state}`)
+    }
+  }
+
+  readHeaderFromLine(line) {
+    let match
+
+    if (match = line.match(/^(.+): (.+)\r\n/)) {
+      const header = new Header(match[1], match[2])
+
+      return header
+    }
+  }
+
+  parseHeader(line) {
+    const header = this.readHeaderFromLine(line)
+
+    if (header) {
+      this.headersByName[header.formattedName] = header
+
+      if (header.formattedName == "content-length") this.contentLength = parseInt(header.value)
+
+      this.events.emit("header", header)
+    } else if (line == "\r\n") {
+      if (this.httpMethod.toUpperCase() == "GET") {
+        this.completeRequest()
+      } else if (this.httpMethod.toUpperCase() == "POST") {
+        this.readingBody = true
+
+        const match = this.getHeader("content-type").value.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
+
+        if (match) {
+          this.boundary = match[1]
+          this.boundaryLine = `--${this.boundary}\r\n`
+          this.boundaryLineNext = `\r\n--${this.boundary}\r\n`
+          this.boundaryLineEnd = `\r\n--${this.boundary}--`
+          this.multiPartyFormData = true
+          this.setState("multi-part-form-data")
+        } else {
+          this.setState("post-body")
+        }
+      } else {
+        throw new Error(`Unknown HTTP method: ${this.httpMethod}`)
+      }
+    }
+  }
+
+  parseStatusLine(line) {
+    const match = line.match(/^(GET|POST) (.+?) HTTP\/1\.1\r\n/)
+
+    if (!match) {
+      throw new Error(`Couldn't match status line from: ${line}`)
+    }
+
+    this.httpMethod = match[1]
+    this.path = match[2]
+    this.setState("headers")
+  }
+
+  postRequestDone() {
+    this.postBody += String.fromCharCode.apply(null, this.postBodyChars)
+    this.parseQueryStringPostParams()
+    this.completeRequest()
+  }
+
+  setState(newState) {
+    logger(this, `Changing state from ${this.state} to ${newState}`)
+
+    this.state = newState
+  }
+
+  completeRequest = () => {
+    this.state = "completed"
+
+    if (this.getHeader("content-type")?.value?.startsWith("application/json")) {
+      this.parseApplicationJsonParams()
+    } else if (this.multiPartyFormData) {
+      // Done after each new form data part
+    }
+
+    this.events.emit("completed")
+  }
+
+  parseApplicationJsonParams() {
+    const newParams = JSON.parse(this.postBody)
+    const incorporator = new Incorporator({objects: [this.params, newParams]})
+
+    incorporator.merge()
+  }
+
+  parseQueryStringPostParams() {
+    const unparsedParams = querystring.parse(this.postBody)
+    const paramsToObject = new ParamsToObject(unparsedParams)
+    const newParams = paramsToObject.toObject()
+    const incorporator = new Incorporator({objects: [this.params, newParams]})
+
+    incorporator.merge()
+  }
+}