velocious 1.0.29 → 1.0.31

package/src/database/migration/index.js

@@ -3,26 +3,43 @@ import restArgsError from "../../utils/rest-args-error.js"
 import TableData, {TableColumn} from "../table-data/index.js"
 
 export default class VelociousDatabaseMigration {
-  constructor({configuration}) {
+  static onDatabases(databaseIdentifiers) {
+    this._databaseIdentifiers = databaseIdentifiers
+  }
+
+  static getDatabaseIdentifiers() {
+    return this._databaseIdentifiers
+  }
+
+  constructor({configuration, databaseIdentifier = "default", db}) {
+    if (!databaseIdentifier) throw new Error("No database identifier given")
+    if (!db) throw new Error("No 'db' given")
+
     this.configuration = configuration
+    this._databaseIdentifier = databaseIdentifier
+    this._db = db
+  }
+
+  _getDatabaseIdentifier() {
+    if (!this._databaseIdentifier) throw new Error("No database identifier set")
+
+    return this._databaseIdentifier
   }
 
   async addColumn(tableName, columnName, columnType, args) {
-    const databasePool = this.configuration.getDatabasePool()
     const tableColumnArgs = Object.assign({type: columnType}, args)
 
-    const sqls = databasePool.alterTableSql({
+    const sqls = this._db.alterTableSql({
       columns: [new TableColumn(columnName, tableColumnArgs)],
       tableName
     })
 
     for (const sql of sqls) {
-      await databasePool.query(sql)
+      await this._db.query(sql)
     }
   }
 
   async addIndex(tableName, columns, args) {
-    const databasePool = this.configuration.getDatabasePool()
     const createIndexArgs = Object.assign(
       {
         columns,
@@ -30,25 +47,24 @@ export default class VelociousDatabaseMigration {
       },
       args
     )
-    const sql = databasePool.createIndexSql(createIndexArgs)
+    const sql = this._db.createIndexSql(createIndexArgs)
 
-    await databasePool.query(sql)
+    await this._db.query(sql)
   }
 
   async addForeignKey(tableName, referenceName) {
     const referenceNameUnderscore = inflection.underscore(referenceName)
     const tableNameUnderscore = inflection.underscore(tableName)
     const columnName = `${referenceNameUnderscore}_id`
-    const databasePool = this.configuration.getDatabasePool()
     const foreignKeyName = `fk_${tableName}_${referenceName}`
     let sql = ""
 
-    sql += `ALTER TABLE ${databasePool.quoteTable(tableName)}`
+    sql += `ALTER TABLE ${this._db.quoteTable(tableName)}`
     sql += ` ADD CONSTRAINT ${foreignKeyName} `
-    sql += ` FOREIGN KEY (${databasePool.quoteColumn(columnName)})`
+    sql += ` FOREIGN KEY (${this._db.quoteColumn(columnName)})`
     sql += ` REFERENCES ${tableNameUnderscore}(id)`
 
-    await databasePool.query(sql)
+    await this._db.query(sql)
   }
 
   async addReference(tableName, referenceName, args) {
@@ -74,8 +90,9 @@ export default class VelociousDatabaseMigration {
       callback = arg2
     }
 
-    const databasePool = this.configuration.getDatabasePool()
     const {id = {}, ...restArgs} = args
+    const databaseIdentifier = this._getDatabaseIdentifier()
+    const databasePool = this.configuration.getDatabasePool(databaseIdentifier)
     const {default: idDefault, type: idType = databasePool.primaryKeyType(), ...restArgsId} = id
     const tableData = new TableData(tableName)
 
@@ -90,23 +107,15 @@ export default class VelociousDatabaseMigration {
       callback(tableData)
     }
 
-    const sqls = databasePool.createTableSql(tableData)
+    const sqls = this._db.createTableSql(tableData)
 
     for (const sql of sqls) {
-      await databasePool.query(sql)
+      await this._db.query(sql)
     }
   }
 
-  getConnection() {
-    const connection = this.configuration.getDatabasePool().getCurrentConnection()
-
-    if (!connection) throw new Error("Couldn't get current connection")
-
-    return connection
-  }
-
   async tableExists(tableName) {
-    const exists = await this.getConnection().tableExists(tableName)
+    const exists = await this._db.tableExists(tableName)
 
     return exists
   }

package/src/database/migrator.js

@@ -1,75 +1,224 @@
 import {digg} from "diggerize"
+import * as inflection from "inflection"
+import {Logger} from "../logger.js"
 import TableData from "./table-data/index.js"
 
 export default class VelociousDatabaseMigrator {
   constructor({configuration}) {
     this.configuration = configuration
+    this.logger = new Logger(this)
   }
 
   async prepare() {
-    const exists = await this.migrationsTableExist()
-
-    if (!exists) await this.createMigrationsTable()
-
+    await this.createMigrationsTable()
     await this.loadMigrationsVersions()
   }
 
   async createMigrationsTable() {
-    const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
+    const dbs = await this.configuration.getCurrentConnections()
+
+    for (const db of Object.values(dbs)) {
+      if (await this.migrationsTableExist(db)) continue
+
+      const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
 
-    schemaMigrationsTable.string("version", {null: false, primaryKey: 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")
-    }
+  hasRunMigrationVersion(dbIdentifier, version) {
+    if (!this.migrationsVersions) throw new Error("Migrations versions hasn't been loaded yet")
+    if (!this.migrationsVersions[dbIdentifier]) throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`)
 
-    if (version in this.migrationsVersions) {
+    if (version in this.migrationsVersions[dbIdentifier]) {
       return true
     }
 
     return false
   }
 
-  async loadMigrationsVersions() {
-    const db = this.configuration.getDatabasePool()
+  async migrateFiles(files, importCallback) {
+    await this.configuration.withConnections(async () => {
+      for (const migration of files) {
+        await this.runMigrationFile({
+          migration,
+          requireMigration: async () => {
+            const migrationImport = await importCallback(migration.fullPath)
+
+            return migrationImport.default
+          }
+        })
+      }
+    })
+  }
+
+  async migrateFilesFromRequireContext(requireContext) {
+    const files = requireContext
+      .keys()
+      .map((file) => {
+        // "13,14" because somes "require-context"-npm-module deletes first character!?
+        const match = file.match(/(\d{13,14})-(.+)\.js$/)
+
+        if (!match) return null
 
+        // Fix require-context-npm-module deletes first character
+        let fileName = file
+        let dateNumber = match[1]
+
+        if (dateNumber.length == 13) {
+          dateNumber = `2${dateNumber}`
+          fileName = `2${fileName}`
+        }
+
+        // Parse regex
+        const date = parseInt(dateNumber)
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
+
+        return {
+          file: fileName,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    await this.configuration.withConnections(async () => {
+      for (const migration of files) {
+        await this.runMigrationFile({
+          migration,
+          requireMigration: () => requireContext(migration.file).default
+        })
+      }
+    })
+  }
+
+  async loadMigrationsVersions() {
     this.migrationsVersions = {}
 
-    await db.withConnection(async () => {
+    const dbs = await this.configuration.getCurrentConnections()
+
+    for (const dbIdentifier in dbs) {
+      const db = dbs[dbIdentifier]
       const rows = await db.select("schema_migrations")
 
+      this.migrationsVersions[dbIdentifier] = {}
+
       for (const row of rows) {
         const version = digg(row, "version")
 
-        this.migrationsVersions[version] = true
+        this.migrationsVersions[dbIdentifier][version] = true
       }
-    })
+    }
+  }
+
+  async migrationsTableExist(db) {
+    const tables = await db.getTables()
+    const schemaTable = tables.find((table) => table.getName() == "schema_migrations")
+
+    if (!schemaTable) return false
+
+    return true
+  }
+
+  async executeRequireContext(requireContext) {
+    const migrationFiles = requireContext.keys()
+
+    files = migrationFiles
+      .map((file) => {
+        const match = file.match(/^(\d{14})-(.+)\.js$/)
+
+        if (!match) return null
+
+        const date = parseInt(match[1])
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName)
+
+        return {
+          file,
+          fullPath: `${migrationsPath}/${file}`,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    for (const migration of files) {
+      await this.runMigrationFile({
+        migration,
+        require: requireContext(migration.file).default
+      })
+    }
   }
 
-  async migrationsTableExist() {
-    let exists = false
+  async reset() {
+    const dbs = await this.configuration.getCurrentConnections()
 
-    await this.configuration.getDatabasePool().withConnection(async (db) => {
-      const tables = await db.getTables()
+    for (const dbIdentifier in dbs) {
+      const db = dbs[dbIdentifier]
 
-      for (const table of tables) {
-        if (table.getName() == "schema_migrations") {
-          exists = true
-          break
+      await db.withDisabledForeignKeys(async () => {
+        for (const table of await db.getTables()) {
+          this.logger.log(`Dropping table ${table.getName()}`)
+          await db.dropTable(table.getName())
         }
+      })
+    }
+  }
+
+  async runMigrationFile({migration, requireMigration}) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
+
+    const dbs = await this.configuration.getCurrentConnections()
+    const migrationClass = await requireMigration()
+    const migrationDatabaseIdentifiers = migrationClass.getDatabaseIdentifiers() || ["default"]
+
+    for (const dbIdentifier in dbs) {
+      if (!migrationDatabaseIdentifiers.includes(dbIdentifier)) {
+        this.logger.debug(`${dbIdentifier} shouldn't run migration ${migration.file}`, {migrationDatabaseIdentifiers})
+        continue
       }
-    })
 
-    return exists
+      if (this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
+        this.logger.debug(`${dbIdentifier} has already run migration ${migration.file}`)
+        continue
+      }
+
+      this.logger.debug(`Running migration on ${dbIdentifier}: ${migration.file}`, {migrationDatabaseIdentifiers})
+
+      const db = dbs[dbIdentifier]
+      const MigrationClass = migrationClass
+      const migrationInstance = new MigrationClass({
+        configuration: this.configuration,
+        db
+      })
+
+      if (migrationInstance.change) {
+        await migrationInstance.change()
+      } else if (migrationInstance.up) {
+        await migrationInstance.up()
+      } else {
+        throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
+      }
+
+      const dateString = digg(migration, "date")
+      const existingSchemaMigrations = await db.newQuery()
+        .from("schema_migrations")
+        .where({version: dateString})
+        .results()
+
+      if (existingSchemaMigrations.length == 0) {
+        await db.insert({tableName: "schema_migrations", data: {version: dateString}})
+      }
+    }
   }
 }

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

@@ -1,14 +1,13 @@
 import {AsyncLocalStorage} from "async_hooks"
 import BasePool from "./base.js"
 
-let idSeq = 0
-
 export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
   constructor(args = {}) {
     super(args)
     this.connections = []
     this.connectionsInUse = {}
     this.asyncLocalStorage = new AsyncLocalStorage()
+    this.idSeq = 0
   }
 
   checkin = (connection) => {
@@ -32,7 +31,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
 
     if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
 
-    const id = idSeq++
+    const id = this.idSeq++
 
     connection.setIdSeq(id)
     this.connectionsInUse[id] = connection

package/src/database/pool/base.js

@@ -1,5 +1,6 @@
 import Configuration from "../../configuration.js"
 import {digg} from "diggerize"
+import {Logger} from "../../logger.js"
 
 if (!globalThis.velociousDatabasePoolBase) {
   globalThis.velociousDatabasePoolBase = {
@@ -18,11 +19,19 @@ class VelociousDatabasePoolBase {
 
   constructor(args = {}) {
     this.configuration = args.configuration || Configuration.current()
+
+    if (!this.configuration) throw new Error("No configuration given")
+    if (!args.identifier) throw new Error("No identifier was given")
+
     this.connections = []
     this.connectionsInUse = {}
+    this.identifier = args.identifier
+    this.logger = new Logger(this)
   }
 
-  getConfiguration = () => digg(this, "configuration", "database", "default", "master")
+  getConfiguration() {
+    return digg(this.configuration.getDatabaseConfiguration(), this.identifier)
+  }
 
   setCurrent() {
     globalThis.velociousDatabasePoolBase.current = this
@@ -33,8 +42,11 @@ class VelociousDatabasePoolBase {
   }
 
   async spawnConnection() {
-    const defaultConfig = this.getConfiguration()
-    const connection = await this.spawnConnectionWithConfiguration(defaultConfig)
+    const databaseConfig = this.getConfiguration()
+
+    this.logger.debug("spawnConnection", {identifier: this.identifier, databaseConfig})
+
+    const connection = await this.spawnConnectionWithConfiguration(databaseConfig)
 
     return connection
   }

package/src/database/query/base.js

@@ -1,10 +1,30 @@
+import restArgsError from "../../utils/rest-args-error.js"
+
 export default class VelociousDatabaseQueryBase {
-  constructor({driver}) {
-    this.driver = driver
+  constructor({driver, options, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this._driver = driver
+    this._options = options || driver.options()
+
+    if (!this._options) throw new Error("No database options was given or could be gotten from driver")
+  }
+
+  getConfiguration() {
+    return this.getDriver().getConfiguration()
   }
 
-  getDriver = () => this.driver
-  getOptions = () => this.getDriver()?.options()
+  getDriver() {
+    return this._driver
+  }
+
+  getOptions() {
+    return this._options
+  }
+
+  getDatabaseType() {
+    return this.getDriver().getType()
+  }
 
   toSql() {
     throw new Error("'toSql' wasn't implemented")

package/src/database/query/create-database-base.js

@@ -1,4 +1,3 @@
-import {digs} from "diggerize"
 import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
@@ -10,12 +9,11 @@ export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase
 
   toSql() {
     const {databaseName} = this
-    const {tableQuote} = digs(this.getOptions(), "tableQuote")
     let sql = "CREATE DATABASE"
 
     if (this.ifNotExists) sql += " IF NOT EXISTS"
 
-    sql += ` ${tableQuote}${databaseName}${tableQuote}`
+    sql += ` ${this.getOptions().quoteDatabaseName(databaseName)}`
 
     return sql
   }

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

@@ -24,8 +24,8 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   toSql() {
+    const options = this.getOptions()
     const {tableName} = this
-    const {columnQuote, indexQuote, tableQuote} = digs(this.getOptions(), "columnQuote", "indexQuote", "tableQuote")
     let sql = "CREATE"
 
     if (this.unique) sql += " UNIQUE"
@@ -34,13 +34,22 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
 
     if (this.ifNotExists) sql += " IF NOT EXISTS"
 
-    sql += ` ${indexQuote}${this.name || this.generateIndexName()}${indexQuote}`
-    sql += ` ON ${tableQuote}${tableName}${tableQuote} (`
+    sql += ` ${options.quoteIndexName(this.name || this.generateIndexName())}`
+    sql += ` ON ${options.quoteTableName(tableName)} (`
 
     for (const columnIndex in this.columns) {
       if (columnIndex > 0) sql += ", "
 
-      sql += `${columnQuote}${this.columns[columnIndex]}${columnQuote}`
+      const column = this.columns[columnIndex]
+      let columnName
+
+      if (typeof column == "string") {
+        columnName = column
+      } else {
+        columnName = column.getName()
+      }
+
+      sql += `${options.quoteColumnName(columnName)}`
     }
 
     sql += ")"

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

@@ -10,18 +10,24 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     this.tableData = tableData
   }
 
-  getConfiguration = () => this.driver.getConfiguration()
-
   toSql() {
-    const databaseType = this.getConfiguration().getDatabaseType()
+    const databaseType = this.getDatabaseType()
+    const driver = this.getDriver()
+    const options = this.getOptions()
     const {tableData} = this
     const sqls = []
+    const ifNotExists = this.ifNotExists || tableData.getIfNotExists()
+    let sql = ""
+
+    if (databaseType == "mssql" && ifNotExists) {
+      sql += `IF NOT EXISTS(SELECT * FROM [sysobjects] WHERE [name] = ${options.quote(tableData.getName())} AND [xtype] = 'U') BEGIN `
+    }
 
-    let sql = "CREATE TABLE"
+    sql += "CREATE TABLE"
 
-    if (this.ifNotExists || tableData.getIfNotExists()) sql += " IF NOT EXISTS"
+    if (databaseType != "mssql" && ifNotExists) sql += " IF NOT EXISTS"
 
-    sql += ` ${tableData.getName()} (`
+    sql += ` ${options.quoteTableName(tableData.getName())} (`
 
     let columnCount = 0
 
@@ -42,16 +48,22 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
 
       if (columnCount > 1) sql += ", "
 
-      sql += `${this.driver.quoteColumn(column.getName())} ${type}`
+      sql += `${options.quoteColumnName(column.getName())} ${type}`
 
       if (maxlength !== undefined) sql += `(${maxlength})`
 
-      if (column.getAutoIncrement() && this.driver.shouldSetAutoIncrementWhenPrimaryKey()) sql += " AUTO_INCREMENT"
+      if (column.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
+        if (databaseType == "mssql") {
+          sql += " IDENTITY"
+        } else {
+          sql += " AUTO_INCREMENT"
+        }
+      }
 
       if (typeof column.getDefault() == "function") {
         sql += ` DEFAULT (${column.getDefault()()})`
       } else if (column.getDefault()) {
-        sql += ` DEFAULT ${this.driver.quote(column.getDefault())}`
+        sql += ` DEFAULT ${options.quote(column.getDefault())}`
       }
 
       if (column.getPrimaryKey()) sql += " PRIMARY KEY"
@@ -67,7 +79,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           throw new Error(`Unknown foreign key type given: ${column.getForeignKey()} (${typeof column.getForeignKey()})`)
         }
 
-        sql += ` REFERENCES ${this.driver.quoteTable(foreignKeyTable)}(${this.driver.quoteColumn(foreignKeyColumn)})`
+        sql += ` REFERENCES ${driver.quoteTable(foreignKeyTable)}(${driver.quoteColumn(foreignKeyColumn)})`
       }
     }
 
@@ -90,7 +102,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         index.getColumns().forEach((column, columnIndex) => {
           if (columnIndex > 0) sql += ", "
 
-          sql += this.driver.quoteColumn(column.name)
+          sql += driver.quoteColumn(column.name)
         })
 
         sql += ")"
@@ -99,6 +111,10 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
 
     sql += ")"
 
+    if (databaseType == "mssql" && ifNotExists) {
+      sql += " END"
+    }
+
     sqls.push(sql)
 
     if (!this.indexInCreateTable) {

package/src/database/query/drop-table-base.js

@@ -0,0 +1,39 @@
+import QueryBase from "./base.js"
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
+  constructor({driver, ifExists, options, tableName, ...restArgs}) {
+    super({driver, options})
+
+    restArgsError(restArgs)
+
+    this.ifExists = ifExists
+    this.tableName = tableName
+  }
+
+  toSql() {
+    const databaseType = this.getDatabaseType()
+    const options = this.getOptions()
+    const {ifExists, tableName} = this
+    const sqls = []
+    let sql = ""
+
+    if (databaseType == "mssql" && ifExists) {
+      sql += `IF EXISTS(SELECT * FROM [sysobjects] WHERE [name] = ${options.quote(tableName)} AND [xtype] = 'U') BEGIN `
+    }
+
+    sql += "DROP TABLE"
+
+    if (databaseType != "mssql" && ifExists) sql += " IF EXISTS"
+
+    sql += ` ${options.quoteTableName(tableName)}`
+
+    if (databaseType == "mssql" && ifExists) {
+      sql += " END"
+    }
+
+    sqls.push(sql)
+
+    return [sql]
+  }
+}

package/src/database/query/index.js

@@ -218,9 +218,13 @@ export default class VelociousDatabaseQuery {
     return results
   }
 
+  async results() {
+    return await this._executeQuery()
+  }
+
   async toArray() {
     const models = []
-    const results = await this._executeQuery()
+    const results = await this.results()
 
     for (const result of results) {
       const model = new this.modelClass()