velocious 1.0.0 → 1.0.2

package/src/database/query/join-plain.mjs

@@ -0,0 +1,12 @@
+import JoinBase from "./join-base.mjs"
+
+export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/order-base.mjs

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQueryOrderBase {
+  getOptions() {
+    return this.query.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/order-plain.mjs

@@ -0,0 +1,21 @@
+import OrderBase from "./order-base.mjs"
+
+export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+    this.reverseOrder = false
+  }
+
+  setReverseOrder() {
+    this.reverseOrder = true
+  }
+
+  toSql() {
+    if (this.reverseOrder) {
+      return `${this.plain} DESC`
+    }
+
+    return this.plain
+  }
+}

package/src/database/query/select-base.mjs

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQuerySelectBase {
+  getOptions() {
+    return this.query.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/select-plain.mjs

@@ -0,0 +1,12 @@
+import SelectBase from "./select-base.mjs"
+
+export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/{select-table-and-column.cjs → select-table-and-column.mjs}

@@ -1,8 +1,8 @@
-const SelectBase = require("./select-base.cjs")
+import SelectBase from "./select-base.mjs"
 
-module.exports = class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
-  constructor({tableName, columnName}) {
-    super()
+export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
+  constructor({query, tableName, columnName}) {
+    super({query})
     this.columnName = columnName
     this.tableName = tableName
   }

package/src/database/query/update-base.mjs

@@ -0,0 +1,16 @@
+export default class VelociousDatabaseQueryUpdateBase {
+  constructor({conditions, data, driver, tableName}) {
+    this.conditions = conditions
+    this.data = data
+    this.driver = driver
+    this.tableName = tableName
+  }
+
+  getOptions() {
+    return this.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query-parser/{from-parser.cjs → from-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserFromParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelociousDatabaseQueryParserFromParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -15,8 +14,6 @@ module.exports = class VelociousDatabaseQueryParserFromParser {
     for (const fromKey in query._froms) {
       const from = query._froms[fromKey]
 
-      from.setOptions(this.queryParserOptions)
-
       if (fromKey > 0) {
         sql += ","
       }

package/src/database/query-parser/{joins-parser.cjs → joins-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelocuiousDatabaseQueryParserJoinsParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelocuiousDatabaseQueryParserJoinsParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -15,8 +14,6 @@ module.exports = class VelocuiousDatabaseQueryParserJoinsParser {
     for (const joinKey in query._joins) {
       const join = query._joins[joinKey]
 
-      join.setOptions(this.queryParserOptions)
-
       if (joinKey == 0) {
         if (pretty) {
           sql += "\n\n"

package/src/database/query-parser/{options.cjs → options.mjs}

@@ -1,9 +1,13 @@
-const {digg} = require("diggerize")
+import {digg} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserOptions {
+export default class VelociousDatabaseQueryParserOptions {
   constructor(options) {
     this.columnQuote = digg(options, "columnQuote")
+    this.driver = digg(options, "driver")
     this.tableQuote = digg(options, "tableQuote")
+    this.stringQuote = digg(options, "stringQuote")
+
+    if (!this.driver) throw new Error("No driver given")
   }
 
   quoteColumnName(columnName) {
@@ -17,4 +21,11 @@ module.exports = class VelociousDatabaseQueryParserOptions {
 
     return `${this.tableQuote}${tableName}${this.tableQuote}`
   }
+
+  quote(value) {
+    if (typeof value == "number")
+      return value
+
+    return this.quoteString(value)
+  }
 }

package/src/database/query-parser/{select-parser.cjs → select-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserSelectParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelociousDatabaseQueryParserSelectParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -23,8 +22,6 @@ module.exports = class VelociousDatabaseQueryParserSelectParser {
     for (const selectKey in query._selects) {
       const selectValue = query._selects[selectKey]
 
-      selectValue.setOptions(this.queryParserOptions)
-
       sql += selectValue.toSql()
 
       if (selectKey + 1 < query._selects.length) {
@@ -37,6 +34,10 @@ module.exports = class VelociousDatabaseQueryParserSelectParser {
       }
     }
 
+    if (query._selects.length == 0) {
+      sql += "*"
+    }
+
     return sql
   }
 }

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().singleConnection()
+
+    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/{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
+  }
+}