velocious 1.0.29 → 1.0.31

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

@@ -1,7 +1,7 @@
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryInsertBase {
-  constructor({columns, data, driver, multiple, tableName, rows, ...restArgs}) {
+  constructor({columns, data, driver, multiple, tableName, returnLastInsertedColumnName, rows, ...restArgs}) {
     if (!driver) throw new Error("No driver given to insert base")
     if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
 
@@ -11,6 +11,7 @@ export default class VelociousDatabaseQueryInsertBase {
     this.data = data
     this.driver = driver
     this.multiple = multiple
+    this.returnLastInsertedColumnName = returnLastInsertedColumnName
     this.rows = rows
     this.tableName = tableName
   }
@@ -20,9 +21,23 @@ export default class VelociousDatabaseQueryInsertBase {
   }
 
   toSql() {
-    let sql = `INSERT INTO ${this.getOptions().quoteTableName(this.tableName)}`
+    const {driver} = this
+
+    let sql = `INSERT INTO ${driver.quoteTable(this.tableName)}`
     let count = 0
-    let columns
+    let columns, lastInsertedSQL
+
+    if (this.returnLastInsertedColumnName) {
+      if (driver.getType() == "mssql") {
+        lastInsertedSQL = ` OUTPUT INSERTED.${driver.quoteColumn(this.returnLastInsertedColumnName)} AS lastInsertID`
+
+        if (Object.keys(this.data).length <= 0) {
+          sql += lastInsertedSQL
+        }
+      } else if (driver.getType() == "mysql") {
+        lastInsertedSQL = ` RETURNING ${driver.quoteColumn(this.returnLastInsertedColumnName)} AS lastInsertID`
+      }
+    }
 
     if (this.columns && this.rows) {
       columns = this.columns
@@ -38,13 +53,17 @@ export default class VelociousDatabaseQueryInsertBase {
       for (const columnName of columns) {
         if (count > 0) sql += ", "
 
-        sql += this.getOptions().quoteColumnName(columnName)
+        sql += driver.quoteColumn(columnName)
         count++
       }
 
       sql += ")"
     }
 
+    if (this.returnLastInsertedColumnName && driver.getType() == "mssql" && Object.keys(this.data).length > 0) {
+      sql += lastInsertedSQL
+    }
+
     if (this.columns && this.rows) {
       if (this.rows.length > 0) {
         sql += " VALUES "
@@ -62,13 +81,19 @@ export default class VelociousDatabaseQueryInsertBase {
       if (Object.keys(this.data).length > 0) {
         sql += " VALUES "
         sql += this._valuesSql(Object.values(this.data))
-      } else if (this.driver.getType() == "sqlite") {
+      } else if (driver.getType() == "sqlite" || driver.getType() == "mssql") {
         sql += " DEFAULT VALUES"
-      } else if (this.driver.getType() == "mysql") {
+      } else if (driver.getType() == "mysql") {
         sql += " () VALUES ()"
       }
     }
 
+    if (this.returnLastInsertedColumnName) {
+      if (driver.getType() == "mysql") {
+        sql += lastInsertedSQL
+      }
+    }
+
     return sql
   }
 

package/src/database/query-parser/limit-parser.js

@@ -8,6 +8,7 @@ export default class VelocuiousDatabaseQueryParserLimitParser {
 
   toSql() {
     const {pretty, query} = digs(this, "pretty", "query")
+    const driver = query.driver
     let sql = ""
 
     if (query._limits.length == 0) return sql
@@ -19,7 +20,11 @@ export default class VelocuiousDatabaseQueryParserLimitParser {
       sql += " "
     }
 
-    sql += "LIMIT"
+    if (driver.getType() == "mssql") {
+      // sql += "BETWEEN"
+    } else {
+      sql += "LIMIT"
+    }
 
     for (const limitKey in query._limits) {
       const limit = query._limits[limitKey]
@@ -32,7 +37,11 @@ export default class VelocuiousDatabaseQueryParserLimitParser {
         sql += " "
       }
 
-      sql += this.query.getOptions().quote(limit)
+      if (driver.getType() == "mssql") {
+        sql += `OFFSET 0 ROWS FETCH FIRST ${this.query.getOptions().quote(limit)} ROWS ONLY`
+      } else {
+        sql += this.query.getOptions().quote(limit)
+      }
     }
 
     return sql

package/src/database/query-parser/options.js

@@ -11,22 +11,34 @@ export default class VelociousDatabaseQueryParserOptions {
     if (!this.driver) throw new Error("No driver given to parser options")
   }
 
+  quote(value) {
+    if (typeof value == "number") return value
+
+    return this.quoteString(value)
+  }
+
+  quoteDatabaseName(databaseName) {
+    if (databaseName.includes(this.tableQuote)) throw new Error(`Possible SQL injection in database name: ${databaseName}`)
+
+    return `${this.tableQuote}${databaseName}${this.tableQuote}`
+  }
+
   quoteColumnName(columnName) {
-    if (!columnName || columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
+    if (!columnName) throw new Error("No column name was given")
+    if (columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
 
     return `${this.columnQuote}${columnName}${this.columnQuote}`
   }
 
-  quoteTableName(tableName) {
-    if (!tableName || tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
+  quoteIndexName(indexName) {
+    if (!indexName || indexName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${indexName}`)
 
-    return `${this.tableQuote}${tableName}${this.tableQuote}`
+    return `${this.columnQuote}${indexName}${this.columnQuote}`
   }
 
-  quote(value) {
-    if (typeof value == "number")
-      return value
+  quoteTableName(tableName) {
+    if (!tableName || tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
 
-    return this.quoteString(value)
+    return `${this.tableQuote}${tableName}${this.tableQuote}`
   }
 }

package/src/database/record/index.js

@@ -117,7 +117,8 @@ export default class VelociousDatabaseRecord {
   }
 
   static connection() {
-    const connection = this._getConfiguration().getDatabasePoolType().current().getCurrentConnection()
+    const databasePool = this._getConfiguration().getDatabasePool(this.getDatabaseIdentifier())
+    const connection = databasePool.getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 
@@ -229,6 +230,14 @@ export default class VelociousDatabaseRecord {
     }
   }
 
+  static getDatabaseIdentifier() {
+    return this._databaseIdentifier || "default"
+  }
+
+  static setDatabaseIdentifier(databaseIdentifier) {
+    this._databaseIdentifier = databaseIdentifier
+  }
+
   getAttribute(name) {
     const columnName = inflection.underscore(name)
 
@@ -681,11 +690,18 @@ export default class VelociousDatabaseRecord {
 
     const data = Object.assign({}, this._belongsToChanges(), this.attributes())
     const sql = this._connection().insertSql({
+      returnLastInsertedColumnName: this.constructor.primaryKey(),
       tableName: this._tableName(),
       data
     })
-    await this._connection().query(sql)
-    const id = await this._connection().lastInsertID()
+    const insertResult = await this._connection().query(sql)
+    let id
+
+    if (insertResult && insertResult[0]?.lastInsertID) {
+      id = insertResult[0]?.lastInsertID
+    } else {
+      id = await this._connection().lastInsertID()
+    }
 
     await this._reloadWithId(id)
     this.setIsNewRecord(false)

package/src/database/use-database.js

@@ -1,8 +1,8 @@
-import DatabaseMigrateFromRequireContext from "./migrate-from-require-context.js"
 import React from "react"
 import useEnvSense from "env-sense/src/use-env-sense.js"
 
 import Configuration from "../configuration.js"
+import Migrator from "./migrator.js"
 import restArgsError from "../utils/rest-args-error.js"
 
 const loadMigrations = function loadMigrations({migrationsRequireContext, ...restArgs}) {
@@ -14,10 +14,11 @@ const loadMigrations = function loadMigrations({migrationsRequireContext, ...res
     instance.running = true
 
     try {
-      await Configuration.current().getDatabasePool().withConnection(async () => {
-        const databaseMigrateFromRequireContext = new DatabaseMigrateFromRequireContext()
+      await Configuration.current().withConnections(async () => {
+        const migrator = new Migrator({configuration: Configuration.current()})
 
-        await databaseMigrateFromRequireContext.execute(migrationsRequireContext)
+        await migrator.prepare()
+        await migrator.migrateFilesFromRequireContext(migrationsRequireContext)
       })
 
       await Configuration.current().initialize()

package/src/routes/base-route.js

@@ -1,4 +1,5 @@
 import GetRoute from "./get-route.js"
+import PostRoute from "./post-route.js"
 import ResourceRoute from "./resource-route.js"
 
 var VelociousBaseRoute
@@ -19,6 +20,12 @@ export function initBaseRoute() {
       throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
     }
 
+    post(name, args) {
+      const route = new PostRoute({name, args})
+
+      this.routes.push(route)
+    }
+
     resources(name, callback) {
       const route = new ResourceRoute({name})
 

package/src/routes/post-route.js

@@ -0,0 +1,24 @@
+import BaseRoute, {initBaseRoute} from "./base-route.js"
+import escapeStringRegexp from "escape-string-regexp"
+
+initBaseRoute()
+
+export default class VelociousRoutePostRoute extends BaseRoute {
+  constructor({name}) {
+    super()
+    this.name = name
+    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
+  }
+
+  matchWithPath({params, path}) {
+    const match = path.match(this.regExp)
+
+    if (match) {
+      const [_beginnigSlash, _matchedName, restPath] = match
+
+      params.action = this.name
+
+      return {restPath}
+    }
+  }
+}

package/src/routes/resolver.js

@@ -58,7 +58,7 @@ export default class VelociousRoutesResolver {
       throw new Error(`Missing action on controller: ${controller}#${action}`)
     }
 
-    await this.configuration.getDatabasePool().withConnection(async () => {
+    await this.configuration.withConnections(async () => {
       await controllerInstance._runBeforeCallbacks()
       await controllerInstance[action]()
     })

package/src/templates/configuration.js

@@ -4,18 +4,51 @@ import MysqlDriver from "velocious/src/database/drivers/mysql/index.js"
 
 export default new Configuration({
   database: {
-    default: {
-      master: {
+    development: {
+      default: {
         driver: MysqlDriver,
         poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "username",
         password: "password",
-        database: "database"
+        database: "database_development"
+      }
+    },
+    production: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "database_production"
+      }
+    },
+    test: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "database_test"
       }
     }
   },
+  initializeModels: async ({configuration}) => {
+    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
+    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
+    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
+
+    await configuration.withConnections(async () => {
+      await initializerFromRequireContext.initialize({configuration})
+    })
+  },
+  locale: () => "en",
+  locales: ["de", "en"],
   localeFallbacks: {
     de: ["de", "en"],
     en: ["en", "de"]

package/src/testing/test-runner.js

@@ -71,7 +71,7 @@ export default class TestRunner {
       }
     }
 
-    await this.configuration.getDatabasePool().withConnection(async () => {
+    await this.configuration.withConnections(async () => {
       for (const subDescription in tests.subs) {
         const subTest = tests.subs[subDescription]
         const newDecriptions = descriptions.concat([subDescription])

package/src/utils/nest-callbacks.js

@@ -0,0 +1,15 @@
+export default async function nestCallbacks(callbacksToNestInside, callback) {
+  let runCallback = callback
+
+  for (const callbackToNestInside of callbacksToNestInside) {
+    let actualRunCallback = runCallback
+
+    const nextRunRequest = async () => {
+      await callbackToNestInside(actualRunCallback)
+    }
+
+    runCallback = nextRunRequest
+  }
+
+  await runCallback()
+}

package/src/big-brother.js

@@ -1,37 +0,0 @@
-export default class VelociousBigBrother {
-  constructor() {
-    this.enabledLoggers = {
-      databaseQuery: false
-    }
-  }
-
-  checkExists(name) {
-    if (!(name in this.enabledLoggers)) throw new Error(`Invalid logger name: ${name}`)
-  }
-
-  isEnabled(name) {
-    this.checkExists(name)
-
-    return this.enabledLoggers[name]
-  }
-
-  async run({after, before, name}, callback) {
-    this.checkExists(name)
-
-    if (!this.enabledLoggers[name]) {
-      return await callback()
-    }
-
-    if (before) {
-      before()
-    }
-
-    const startTime = new Date()
-    const result = await callback()
-    const endTime = new Date()
-
-    if (after) {
-      after({result})
-    }
-  }
-}

package/src/database/migrate-from-require-context.js

@@ -1,72 +0,0 @@
-import Configuration from "../configuration.js"
-import * as inflection from "inflection"
-import Migrator from "./migrator.js"
-
-export default class VelociousDatabaseMigrateFromRequireContext {
-  constructor(configuration) {
-    this.configuration = configuration || Configuration.current()
-    this.migrator = new Migrator({configuration: this.configuration})
-  }
-
-  async execute(requireContext) {
-    await this.migrator.prepare()
-
-    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)
-
-    for (const migration of files) {
-      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
-        await this.runMigrationFile(migration, requireContext)
-      }
-    }
-  }
-
-  async runMigrationFile(migration, requireContext) {
-    if (!this.configuration) throw new Error("No configuration set")
-    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
-
-    await this.configuration.getDatabasePool().withConnection(async (db) => {
-      const MigrationClass = requireContext(migration.file).default
-      const migrationInstance = new MigrationClass({
-        configuration: this.configuration
-      })
-
-      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}`)
-      }
-
-      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
-    })
-  }
-}

package/src/spec/index.js

@@ -1,5 +0,0 @@
-export default class VelocuiousSpec {
-  static describe(description) {
-    throw new Error("stub", description)
-  }
-}