velocious 1.0.5 → 1.0.7

package/src/database/drivers/sqlite/query.web.mjs

@@ -1,9 +0,0 @@
-export default async function query(connection, sql) {
-  const rows = []
-
-  for await (const entry of connection.exec(sql)) {
-    rows.push(entry)
-  }
-
-  return rows
-}

package/src/database/drivers/sqlite/table.mjs

@@ -1,9 +0,0 @@
-import {digg} from "diggerize"
-
-export default class VelociousDatabaseDriversSqliteTable {
-  constructor(row) {
-    this.row = row
-  }
-
-  getName = () => digg(this, "row", "name")
-}

package/src/database/migration/index.mjs

@@ -1,18 +0,0 @@
-import TableData from "../table-data/index.mjs"
-
-export default class VelociousDatabaseMigration {
-  constructor({configuration}) {
-    this.configuration = configuration
-  }
-
-  async createTable(tableName, callback) {
-    const tableData = new TableData(tableName)
-
-    callback(tableData)
-
-    const databasePool = this.configuration.getDatabasePool()
-    const sql = databasePool.createTableSql(tableData)
-
-    await databasePool.query(sql)
-  }
-}

package/src/database/query/create-table-base.mjs

@@ -1,69 +0,0 @@
-import QueryBase from "./base.mjs"
-
-export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
-  constructor({driver, ifNotExists, tableData}) {
-    super({driver})
-    this.ifNotExists = ifNotExists
-    this.tableData = tableData
-  }
-
-  toSql() {
-    const {tableData} = this
-    let sql = "CREATE TABLE"
-
-    if (this.ifNotExists || tableData.getIfNotExists()) sql += " IF NOT EXISTS"
-
-    sql += ` ${tableData.getName()} (`
-
-    let columnCount = 0
-
-    for (const column of tableData.getColumns()) {
-      columnCount++
-
-      let maxlength = column.args.maxlength
-      let type = column.args.type
-
-      if (type == "string") {
-        type = "varchar"
-        maxlength ||= 255
-      }
-
-      if (columnCount > 1) sql += ", "
-
-      sql += `${this.driver.quoteColumn(column.name)} ${type}`
-
-      if (maxlength !== undefined) sql += `(${maxlength})`
-
-      if (column.args.autoIncrement) sql += " AUTO_INCREMENT"
-      if (column.args.primaryKey) sql += " PRIMARY KEY"
-    }
-
-    for (const index of tableData.getIndexes()) {
-      sql += ","
-
-      if (index.getUnique()) {
-        sql += " UNIQUE"
-      }
-
-      sql += " INDEX"
-
-      if (index.getName()) {
-        sql += ` ${index.getName()}`
-      }
-
-      sql += " ("
-
-      index.getColumns().forEach((column, columnIndex) => {
-        if (columnIndex > 0) sql += ", "
-
-        sql += this.driver.quoteColumn(column.name)
-      })
-
-      sql += ")"
-    }
-
-    sql += ")"
-
-    return sql
-  }
-}

package/src/database/query/index.mjs

@@ -1,144 +0,0 @@
-import FromPlain from "./from-plain.mjs"
-import JoinPlain from "./join-plain.mjs"
-import OrderPlain from "./order-plain.mjs"
-import SelectPlain from "./select-plain.mjs"
-
-export default class VelociousDatabaseQuery {
-  constructor({driver, froms = [], joins = [], handler, limits = [], modelClass, orders = [], selects = [], wheres = []}) {
-    if (!driver) throw new Error("No driver given")
-    if (!handler) throw new Error("No handler given")
-
-    this.driver = driver
-    this.handler = handler
-    this.modelClass = modelClass
-    this._froms = froms
-    this._joins = joins
-    this._limits = limits
-    this._orders = orders
-    this._selects = selects
-    this._wheres = wheres
-  }
-
-  clone() {
-    const newQuery = new VelociousDatabaseQuery({
-      driver: this.driver,
-      froms: [...this._froms],
-      handler: this.handler.clone(),
-      joins: [...this._joins],
-      limits: [...this._limits],
-      modelClass: this.modelClass,
-      orders: [...this._orders],
-      selects: [...this._selects],
-      wheres: [...this._wheres]
-    })
-
-    return newQuery
-  }
-
-  getOptions() {
-    return this.driver.options()
-  }
-
-  async first() {
-    const newQuery = this.clone()
-    const results = await newQuery.limit(1).reorder(this.modelClass.orderableColumn()).toArray()
-
-    return results[0]
-  }
-
-  from(from) {
-    if (typeof from == "string") from = new FromPlain({plain: from, query: this})
-
-    from.query = this
-
-    this._froms.push(from)
-    return this
-  }
-
-  async last() {
-    return await this.clone().reverseOrder().first()
-  }
-
-  limit(value) {
-    this._limits.push(value)
-    return this
-  }
-
-  joins(join) {
-    if (typeof join == "string") join = new JoinPlain({plain: join, query: this})
-
-    join.query = this
-
-    this._joins.push(join)
-    return this
-  }
-
-  order(order) {
-    if (typeof order == "number" || typeof order == "string") order = new OrderPlain({plain: order, query: this})
-
-    order.query = this
-
-    this._orders.push(order)
-    return this
-  }
-
-  reorder(order) {
-    this._orders = []
-    this.order(order)
-    return this
-  }
-
-  reverseOrder() {
-    for (const order of this._orders) {
-      order.setReverseOrder(true)
-    }
-
-    return this
-  }
-
-  select(select) {
-    if (Array.isArray(select)) {
-      for (const selectInArray of select) {
-        this.select(selectInArray)
-      }
-
-      return this
-    }
-
-    if (typeof select == "string") select = new SelectPlain({plain: select})
-
-    select.query = this
-
-    this._selects.push(select)
-    return this
-  }
-
-  async toArray() {
-    const sql = this.toSql()
-    const results = await this.driver.query(sql)
-    const models = []
-
-    for (const result of results) {
-      const model = new this.modelClass(result)
-
-      models.push(model)
-    }
-
-    return models
-  }
-
-  toSql() {
-    return this.driver.queryToSql(this)
-  }
-
-  where(where) {
-    if (typeof where == "string") {
-      where = new WherePlain({plain: where})
-    } else if (typeof where == "object" && where.constructor.name == "object") {
-      where = new WhereHash({hash: where})
-    }
-
-    this._wheres.push(where)
-    return this
-  }
-}

package/src/database/query-parser/joins-parser.mjs

@@ -1,30 +0,0 @@
-import {digs} from "diggerize"
-
-export default class VelocuiousDatabaseQueryParserJoinsParser {
-  constructor({pretty, query}) {
-    this.pretty = pretty
-    this.query = query
-  }
-
-  toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
-
-    let sql = ""
-
-    for (const joinKey in query._joins) {
-      const join = query._joins[joinKey]
-
-      if (joinKey == 0) {
-        if (pretty) {
-          sql += "\n\n"
-        } else {
-          sql += " "
-        }
-      }
-
-      sql += join.toSql()
-    }
-
-    return sql
-  }
-}

package/src/database/record/index.mjs

@@ -1,187 +0,0 @@
-import Configuration from "../../configuration.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 = Configuration.current().getDatabasePoolType().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/templates/generate-model.mjs

@@ -1,4 +0,0 @@
-import Record from "velocious/src/database/record/index.mjs"
-
-export default class __MODEL_NAME__ extends Record {
-}