velocious 1.0.4 → 1.0.6

package/src/database/migrator.mjs

@@ -0,0 +1,75 @@
+import {digg} from "diggerize"
+import TableData from "./table-data/index"
+
+export default class VelociousDatabaseMigrator {
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  async prepare() {
+    const exists = await this.migrationsTableExist()
+
+    if (!exists) await this.createMigrationsTable()
+
+    await this.loadMigrationsVersions()
+  }
+
+  async createMigrationsTable() {
+    const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
+
+    schemaMigrationsTable.string("version", {null: false, primaryKey: true})
+
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
+      const createSchemaMigrationsTableSqls = db.createTableSql(schemaMigrationsTable)
+
+      for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
+        await db.query(createSchemaMigrationsTableSql)
+      }
+    })
+  }
+
+  hasRunMigrationVersion(version) {
+    if (!this.migrationsVersions) {
+      throw new Error("Migrations versions hasn't been loaded yet")
+    }
+
+    if (version in this.migrationsVersions) {
+      return true
+    }
+
+    return false
+  }
+
+  async loadMigrationsVersions() {
+    const db = this.configuration.getDatabasePool()
+
+    this.migrationsVersions = {}
+
+    await db.withConnection(async () => {
+      const rows = await db.select("schema_migrations")
+
+      for (const row of rows) {
+        const version = digg(row, "version")
+
+        this.migrationsVersions[version] = true
+      }
+    })
+  }
+
+  async migrationsTableExist() {
+    let exists = false
+
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
+      const tables = await db.getTables()
+
+      for (const table of tables) {
+        if (table.getName() == "schema_migrations") {
+          exists = true
+          break
+        }
+      }
+    })
+
+    return exists
+  }
+}

package/src/database/pool/async-tracked-multi-connection.mjs

@@ -58,7 +58,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
 
     await this.asyncLocalStorage.run(id, async () => {
       try {
-        await callback()
+        await callback(connection)
       } finally {
         this.checkin(connection)
       }

package/src/database/pool/base.mjs

@@ -34,11 +34,29 @@ class VelociousDatabasePoolBase {
   }
 }
 
-const forwardMethods = ["createTableSql", "deleteSql", "insertSql", "query", "quote", "updateSql"]
+const forwardMethods = [
+  "createIndex",
+  "createIndexSql",
+  "createTable",
+  "createTableSql",
+  "delete",
+  "deleteSql",
+  "getTables",
+  "insert",
+  "insertSql",
+  "query",
+  "quote",
+  "select",
+  "update",
+  "updateSql"
+]
 
 for (const forwardMethod of forwardMethods) {
   VelociousDatabasePoolBase.prototype[forwardMethod] = function(...args) {
     const connection = this.getCurrentConnection()
+    const connectionMethod = connection[forwardMethod]
+
+    if (!connectionMethod) throw new Error(`${forwardMethod} isn't defined on driver`)
 
     return connection[forwardMethod](...args)
   }

package/src/database/pool/single-multi-use.mjs

@@ -27,7 +27,7 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
 
   async withConnection(callback) {
     await this.checkout() // Ensure a connection is present
-    await callback()
+    await callback(this.connection)
   }
 
   getCurrentConnection() {

package/src/database/query/base.mjs

@@ -3,7 +3,8 @@ export default class VelociousDatabaseQueryBase {
     this.driver = driver
   }
 
-  getOptions = () => this.driver?.options()
+  getDriver = () => this.driver
+  getOptions = () => this.getDriver()?.options()
 
   toSql() {
     throw new Error("'toSql' wasn't implemented")

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

@@ -0,0 +1,50 @@
+import {digs} from "diggerize"
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
+  constructor({columns, driver, ifNotExists, name, unique, tableName}) {
+    super({driver})
+    this.columns = columns
+    this.name = name
+    this.tableName = tableName
+    this.ifNotExists = ifNotExists
+    this.unique = unique
+  }
+
+  generateIndexName() {
+    let indexName = `index_on_${this.tableName}_`
+
+    for (const columnIndex in this.columns) {
+      if (columnIndex > 0) indexName += "_"
+
+      indexName += this.columns[columnIndex]
+    }
+
+    return indexName
+  }
+
+  toSql() {
+    const {tableName} = this
+    const {columnQuote, indexQuote, tableQuote} = digs(this.getOptions(), "columnQuote", "indexQuote", "tableQuote")
+    let sql = "CREATE"
+
+    if (this.unique) sql += " UNIQUE"
+
+    sql += " INDEX"
+
+    if (this.ifNotExists) sql += " IF NOT EXISTS"
+
+    sql += ` ${indexQuote}${this.name || this.generateIndexName()}${indexQuote}`
+    sql += ` ON ${tableQuote}${tableName}${tableQuote} (`
+
+    for (const columnIndex in this.columns) {
+      if (columnIndex > 0) sql += ", "
+
+      sql += `${columnQuote}${this.columns[columnIndex]}${columnQuote}`
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

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

@@ -1,14 +1,18 @@
+import CreateIndexBase from "./create-index-base.mjs"
 import QueryBase from "./base.mjs"
 
 export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
-  constructor({driver, ifNotExists, tableData}) {
+  constructor({driver, ifNotExists, indexInCreateTable = true, tableData}) {
     super({driver})
     this.ifNotExists = ifNotExists
+    this.indexInCreateTable = indexInCreateTable
     this.tableData = tableData
   }
 
   toSql() {
     const {tableData} = this
+    const sqls = []
+
     let sql = "CREATE TABLE"
 
     if (this.ifNotExists || tableData.getIfNotExists()) sql += " IF NOT EXISTS"
@@ -36,34 +40,53 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
 
       if (column.args.autoIncrement) sql += " AUTO_INCREMENT"
       if (column.args.primaryKey) sql += " PRIMARY KEY"
+      if (column.args.null === false) sql += " NOT NULL"
     }
 
-    for (const index of tableData.getIndexes()) {
-      sql += ","
+    if (this.indexInCreateTable) {
+      for (const index of tableData.getIndexes()) {
+        sql += ","
 
-      if (index.getUnique()) {
-        sql += " UNIQUE"
-      }
+        if (index.getUnique()) {
+          sql += " UNIQUE"
+        }
 
-      sql += " INDEX"
+        sql += " INDEX"
 
-      if (index.getName()) {
-        sql += ` ${index.getName()}`
-      }
+        if (index.getName()) {
+          sql += ` ${index.getName()}`
+        }
 
-      sql += " ("
+        sql += " ("
 
-      index.getColumns().forEach((column, columnIndex) => {
-        if (columnIndex > 0) sql += ", "
+        index.getColumns().forEach((column, columnIndex) => {
+          if (columnIndex > 0) sql += ", "
 
-        sql += this.driver.quoteColumn(column.name)
-      })
+          sql += this.driver.quoteColumn(column.name)
+        })
 
-      sql += ")"
+        sql += ")"
+      }
     }
 
     sql += ")"
 
-    return sql
+    sqls.push(sql)
+
+    if (!this.indexInCreateTable) {
+      for (const index of tableData.getIndexes()) {
+        const createIndexArgs = {
+          columns: index.getColumns(),
+          driver: this.getDriver(),
+          tableName: tableData.getName(),
+          unique: index.getUnique()
+        }
+        const sql = new CreateIndexBase(createIndexArgs).toSql()
+
+        sqls.push(sql)
+      }
+    }
+
+    return [sql]
   }
 }

package/src/database/query/index.mjs

@@ -1,20 +1,27 @@
 import FromPlain from "./from-plain.mjs"
+import {incorporate} from "incorporator"
+import * as inflection from "inflection"
 import JoinPlain from "./join-plain.mjs"
 import OrderPlain from "./order-plain.mjs"
+import Preloader from "./preloader.mjs"
 import SelectPlain from "./select-plain.mjs"
+import WhereHash from "./where-hash.mjs"
+import WherePlain from "./where-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")
+  constructor({driver, froms = [], groups = [], joins = [], handler, limits = [], modelClass, orders = [], preload = {}, selects = [], wheres = []}) {
+    if (!driver) throw new Error("No driver given to query")
+    if (!handler) throw new Error("No handler given to query")
 
     this.driver = driver
     this.handler = handler
     this.modelClass = modelClass
     this._froms = froms
+    this._groups = groups
     this._joins = joins
     this._limits = limits
     this._orders = orders
+    this._preload = preload
     this._selects = selects
     this._wheres = wheres
   }
@@ -24,10 +31,12 @@ export default class VelociousDatabaseQuery {
       driver: this.driver,
       froms: [...this._froms],
       handler: this.handler.clone(),
+      groups: [...this._groups],
       joins: [...this._joins],
       limits: [...this._limits],
       modelClass: this.modelClass,
       orders: [...this._orders],
+      preload: {...this._preload},
       selects: [...this._selects],
       wheres: [...this._wheres]
     })
@@ -35,8 +44,38 @@ export default class VelociousDatabaseQuery {
     return newQuery
   }
 
-  getOptions() {
-    return this.driver.options()
+  getOptions = () => this.driver.options()
+
+  async findBy(conditions) {
+    const newConditions = {}
+
+    for (const key in conditions) {
+      const keyUnderscore = inflection.underscore(key)
+
+      newConditions[keyUnderscore] = conditions[key]
+    }
+
+    return await this.clone().where(newConditions).first()
+  }
+
+  async findOrCreateBy(conditions) {
+    const record = await this.findOrInitializeBy(conditions)
+
+    if (record.isNewRecord()) {
+      await record.save()
+    }
+
+    return record
+  }
+
+  async findOrInitializeBy(conditions) {
+    const record = await this.findBy(conditions)
+
+    if (record) return record
+
+    const newRecord = new this.modelClass(conditions)
+
+    return newRecord
   }
 
   async first() {
@@ -55,24 +94,31 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
-  async last() {
-    return await this.clone().reverseOrder().first()
-  }
-
-  limit(value) {
-    this._limits.push(value)
+  group(group) {
+    this._groups.push(group)
     return this
   }
 
   joins(join) {
-    if (typeof join == "string") join = new JoinPlain({plain: join, query: this})
-
-    join.query = this
+    if (typeof join == "string") {
+      join = new JoinPlain({plain: join, query: this})
+    } else if (typeof join == "object") {
+      // Do nothing
+    } else {
+      throw new Error(`Unknown type of join: ${typeof join}`)
+    }
 
     this._joins.push(join)
     return this
   }
 
+  last = async () => await this.clone().reverseOrder().first()
+
+  limit(value) {
+    this._limits.push(value)
+    return this
+  }
+
   order(order) {
     if (typeof order == "number" || typeof order == "string") order = new OrderPlain({plain: order, query: this})
 
@@ -82,6 +128,11 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
+  preload(data) {
+    incorporate(this._preload, data)
+    return this
+  }
+
   reorder(order) {
     this._orders = []
     this.order(order)
@@ -119,23 +170,34 @@ export default class VelociousDatabaseQuery {
     const models = []
 
     for (const result of results) {
-      const model = new this.modelClass(result)
+      const model = new this.modelClass()
 
+      model.loadExistingRecord(result)
       models.push(model)
     }
 
+    if (Object.keys(this._preload).length > 0 && models.length > 0) {
+      const preloader = new Preloader({
+        modelClass: this.modelClass,
+        models,
+        preload: this._preload
+      })
+
+      await preloader.run()
+    }
+
     return models
   }
 
-  toSql() {
-    return this.driver.queryToSql(this)
-  }
+  toSql = () => 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})
+      where = new WherePlain(this, where)
+    } else if (typeof where == "object" && (where.constructor.name == "object" || where.constructor.name == "Object")) {
+      where = new WhereHash(this, where)
+    } else {
+      throw new Error(`Invalid type of where: ${typeof where} (${where.constructor.name})`)
     }
 
     this._wheres.push(where)

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

@@ -1,5 +1,9 @@
 export default class VelociousDatabaseQueryInsertBase {
   constructor({driver, tableName, data}) {
+    if (!driver) throw new Error("No driver given to insert base")
+    if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
+    if (!data) throw new Error("No data given to insert base")
+
     this.data = data
     this.driver = driver
     this.tableName = tableName

package/src/database/query/preloader/belongs-to.mjs

@@ -0,0 +1,52 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloaderBelongsTo {
+  constructor({models, relationship, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.models = models
+    this.relationship = relationship
+  }
+
+  async run() {
+    const foreignKeyValues = []
+    const modelsById = {}
+    const foreignKey = this.relationship.getForeignKey()
+    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const preloadCollections = {}
+
+    for (const model of this.models) {
+      const foreignKeyValue = model[foreignKeyCamelized]()
+
+      preloadCollections[model.id()] = []
+      foreignKeyValues.push(foreignKeyValue)
+      modelsById[model.id()] = model
+    }
+
+    const whereArgs = {}
+    const primaryKey = this.relationship.getPrimaryKey()
+
+    whereArgs[primaryKey] = foreignKeyValues
+
+    // Load target models to be preloaded on the given models
+    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+    const targetModelsById = {}
+
+    for (const targetModel of targetModels) {
+      targetModelsById[targetModel.id()] = targetModel
+    }
+
+    // Set the target preloaded models on the given models
+    for (const model of this.models) {
+      const foreignKeyValue = model[foreignKeyCamelized]()
+      const targetModel = targetModelsById[foreignKeyValue]
+      const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
+
+      modelRelationship.setPreloaded(true)
+      modelRelationship.setLoaded(targetModel)
+    }
+
+    return targetModels
+  }
+}

package/src/database/query/preloader/has-many.mjs

@@ -0,0 +1,55 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloaderHasMany {
+  constructor({models, relationship, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.models = models
+    this.relationship = relationship
+  }
+
+  async run() {
+    const modelIds = []
+    const modelsById = {}
+    const foreignKey = this.relationship.getForeignKey()
+    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const preloadCollections = {}
+
+    for (const model of this.models) {
+      preloadCollections[model.id()] = []
+      modelIds.push(model.id())
+
+      if (!(model.id in modelsById)) modelsById[model.id()] = []
+
+      modelsById[model.id()].push(model)
+    }
+
+    const whereArgs = {}
+
+    whereArgs[foreignKey] = modelIds
+
+    // Load target models to be preloaded on the given models
+    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+
+    for (const targetModel of targetModels) {
+      const foreignKeyValue = targetModel[foreignKeyCamelized]()
+
+      preloadCollections[foreignKeyValue].push(targetModel)
+    }
+
+    // Set the target preloaded models on the given models
+    for (const modelId in preloadCollections) {
+      const preloadedCollection = preloadCollections[modelId]
+
+      for (const model of modelsById[modelId]) {
+        const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
+
+        modelRelationship.setPreloaded(true)
+        modelRelationship.addToLoaded(preloadedCollection)
+      }
+    }
+
+    return targetModels
+  }
+}

package/src/database/query/preloader.mjs

@@ -0,0 +1,41 @@
+import BelongsToPreloader from "./preloader/belongs-to.mjs"
+import HasManyPreloader from "./preloader/has-many.mjs"
+import restArgsError from "../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloader {
+  constructor({modelClass, models, preload, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.modelClass = modelClass
+    this.models = models
+    this.preload = preload
+  }
+
+  async run() {
+    for (const preloadRelationshipName in this.preload) {
+      const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName)
+      let targetModels
+
+      if (relationship.getType() == "belongsTo") {
+        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: relationship})
+
+        targetModels = await hasManyPreloader.run()
+      } else if (relationship.getType() == "hasMany") {
+        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: relationship})
+
+        targetModels = await hasManyPreloader.run()
+      } else {
+        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+      }
+
+      // Handle any further preloads in the tree
+      const newPreload = this.preload[preloadRelationshipName]
+
+      if (typeof newPreload == "object" && targetModels.length > 0) {
+        const preloader = new VelociousDatabaseQueryPreloader({modelClass: relationship.getTargetModelClass(), models: targetModels, preload: newPreload})
+
+        await preloader.run()
+      }
+    }
+  }
+}

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

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

package/src/database/query/where-hash.mjs

@@ -0,0 +1,35 @@
+import WhereBase from "./where-base.mjs"
+
+export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  constructor(query, hash) {
+    super()
+    this.hash = hash
+    this.query = query
+  }
+
+  toSql() {
+    const options = this.getOptions()
+    let sql = "("
+    let index = 0
+
+    for (const whereKey in this.hash) {
+      const whereValue = this.hash[whereKey]
+
+      if (index > 0) sql += " AND "
+
+      sql += `${options.quoteColumnName(whereKey)}`
+
+      if (Array.isArray(whereValue)) {
+        sql += ` IN (${whereValue.map((value) => options.quote(value)).join(", ")})`
+      } else {
+        sql += ` = ${options.quote(whereValue)}`
+      }
+
+      index++
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

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

@@ -0,0 +1,13 @@
+import WhereBase from "./where-base.mjs"
+
+export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  constructor(query, plain) {
+    super()
+    this.plain = plain
+    this.query = query
+  }
+
+  toSql() {
+    return this.plain
+  }
+}