velocious 1.0.28 → 1.0.30

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",
@@ -23,11 +23,14 @@
   "description": "",
   "devDependencies": {
     "jasmine": "^5.0.2",
+    "mssql": "^11.0.1",
     "mysql": "^2.18.1",
     "node-fetch": "^3.3.1",
     "require-context": "^1.1.0",
     "sqlite": "^5.1.1",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "tedious": "^18.6.1",
+    "uniqunize": "^1.0.1"
   },
   "dependencies": {
     "bcryptjs": "^3.0.2",

package/peak_flow.yml

@@ -6,6 +6,8 @@ before_install:
   - sudo apt-get install -y nodejs
 before_script:
   - npm install
+environment:
+  NODE_ENV: test
 services:
   mariadb:
     environment:
@@ -18,15 +20,34 @@ services:
       - 3306
     mem_limit: 4096m
     restart_policy: on-failure
+  mssql:
+    environment:
+      ACCEPT_EULA: Y
+      MSSQL_PID: Developer
+      MSSQL_SA_PASSWORD: Super-Secret-Password
+    image: mcr.microsoft.com/mssql/server:2022-latest
+    expose:
+      - 1433
+    mem_limit: 4096m
+    restart_policy: on-failure
 builds:
   build_1:
     name: MariaDB
     script:
       - cp spec/dummy/src/config/configuration.peakflow.mariadb.js spec/dummy/src/config/configuration.js
+      - cd spec/dummy && npx velocious db:create
       - wait-for-it mariadb:3306
       - npm test
   build_2:
+    name: MS-SQL
+    script:
+      - wait-for-it mssql:1433
+      - cp spec/dummy/src/config/configuration.peakflow.mssql.js spec/dummy/src/config/configuration.js
+      - cd spec/dummy && npx velocious db:create
+      - npm test
+  build_3:
     name: SQLite
     script:
       - cp spec/dummy/src/config/configuration.peakflow.sqlite.js spec/dummy/src/config/configuration.js
+      - cd spec/dummy && npx velocious db:create
       - npm test

package/spec/cli/commands/db/create-spec.js

@@ -14,7 +14,19 @@ describe("Cli - Commands - db:create", () => {
       expect(result).toEqual(
         [
           {
-            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
+            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS `schema_migrations` (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
+          }
+        ]
+      )
+    } else if (cli.getConfiguration().getDatabaseType() == "mssql") {
+      expect(result).toEqual(
+        [
+          {
+            databaseName: 'velocious_test',
+            sql: "IF NOT EXISTS(SELECT * FROM [sys].[databases] WHERE [name] = 'velocious_test') BEGIN CREATE DATABASE [velocious_test] END"
+          },
+          {
+            createSchemaMigrationsTableSql: "IF NOT EXISTS(SELECT * FROM [sysobjects] WHERE [name] = 'schema_migrations' AND [xtype] = 'U') BEGIN CREATE TABLE [schema_migrations] ([version] VARCHAR(255) PRIMARY KEY NOT NULL) END"
           }
         ]
       )
@@ -26,7 +38,7 @@ describe("Cli - Commands - db:create", () => {
             sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
           },
           {
-            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
+            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS `schema_migrations` (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
           }
         ]
       )

package/spec/cli/commands/db/migrate-spec.js

@@ -1,5 +1,6 @@
 import Cli from "../../../../src/cli/index.js"
 import dummyDirectory from "../../../dummy/dummy-directory.js"
+import uniqunize from "uniqunize"
 
 describe("Cli - Commands - db:migrate", () => {
   it("runs migrations", async () => {
@@ -12,46 +13,76 @@ describe("Cli - Commands - db:migrate", () => {
 
     await cli.loadConfiguration()
 
-    const dbPool = cli.configuration.getDatabasePool()
+    let defaultDatabaseType, defaultSchemaMigrations = [], projectForeignKey = [], tablesResult = []
 
-    await dbPool.withConnection(async (db) => {
-      await db.query("DROP TABLE IF EXISTS tasks")
-      await db.query("DROP TABLE IF EXISTS project_translations")
-      await db.query("DROP TABLE IF EXISTS projects")
-      await db.query("DROP TABLE IF EXISTS schema_migrations")
-    })
-
-    await cli.execute()
+    await cli.configuration.withConnections(async (dbs) => {
+      defaultDatabaseType = dbs.default.getType()
 
-    let projectForeignKey, schemaMigrations, tablesResult
+      const tableNames = ["accounts", "tasks", "project_translations", "projects", "schema_migrations"]
 
-    await dbPool.withConnection(async (db) => {
-      const tables = await db.getTables()
+      for (const tableName of tableNames) {
+        await dbs.default.dropTable(tableName, {ifExists: true})
+        await dbs.mssql.dropTable(tableName, {ifExists: true})
+      }
 
-      tablesResult = tables.map((table) => table.getName())
+      await cli.execute()
 
-      const table = await db.getTableByName("tasks")
+      const table = await dbs.default.getTableByName("tasks")
       const foreignKeys = await table.getForeignKeys()
 
-      projectForeignKey = foreignKeys.find((foreignKey) => foreignKey.getColumnName() == "project_id")
+      for (const foreignKey of foreignKeys) {
+        if (foreignKey.getColumnName() == "project_id") {
+          projectForeignKey = foreignKey
+        }
+      }
+
+      for (const db of Object.values(dbs)) {
+        const schemaMigrations = await db.query("SELECT * FROM schema_migrations ORDER BY version")
+
+        for (const schemaMigration of schemaMigrations) {
+          defaultSchemaMigrations.push(schemaMigration.version)
+        }
 
-      schemaMigrations = (await db.query("SELECT * FROM schema_migrations ORDER BY version")).map((schemaMigration) => schemaMigration.version)
+        const tables = await db.getTables()
+
+        for (const table of tables) {
+          tablesResult.push(table.getName())
+        }
+      }
     })
 
-    expect(tablesResult).toEqual(
-      [
-        "project_translations",
-        "projects",
-        "schema_migrations",
-        "tasks"
-      ]
-    )
+
 
     expect(projectForeignKey.getTableName()).toEqual("tasks")
     expect(projectForeignKey.getColumnName()).toEqual("project_id")
     expect(projectForeignKey.getReferencedTableName()).toEqual("projects")
     expect(projectForeignKey.getReferencedColumnName()).toEqual("id")
 
-    expect(schemaMigrations).toEqual(["20230728075328", "20230728075329", "20250605133926"])
+    if (defaultDatabaseType == "mssql") {
+      expect(uniqunize(tablesResult.sort())).toEqual(
+        [
+          "accounts",
+          "project_translations",
+          "projects",
+          "schema_migrations",
+          "tasks"
+        ]
+      )
+
+      expect(uniqunize(defaultSchemaMigrations.sort())).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845"])
+    } else {
+      expect(tablesResult.sort()).toEqual(
+        [
+          "accounts",
+          "project_translations",
+          "projects",
+          "schema_migrations",
+          "schema_migrations",
+          "tasks"
+        ]
+      )
+
+      expect(defaultSchemaMigrations.sort()).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845"])
+    }
   })
 })

package/spec/database/drivers/mysql/connection-spec.js

@@ -2,11 +2,11 @@ import DatabaseDriversMysql from "../../../../src/database/drivers/mysql/index.j
 import configuration from "../../../dummy/src/config/configuration.js"
 import {digg} from "diggerize"
 
-const mysqlConfig = digg(configuration, "database", "default", "master")
+const mysqlConfig = digg(configuration, "database", "test", "default")
 
 describe("Database - Drivers - Mysql - Connection", () => {
   it("connects", async () => {
-    if (configuration.getDatabaseType() != "sqlite") {
+    if (configuration.getDatabaseType() != "sqlite" && configuration.getDatabaseType() != "mssql") {
       const mysql = new DatabaseDriversMysql(mysqlConfig)
 
       await mysql.connect()

package/spec/dummy/index.js

@@ -1,4 +1,5 @@
 import Application from "../../src/application.js"
+import {digg} from "diggerize"
 import dummyConfiguration from "./src/config/configuration.js"
 import Migration from "../../src/database/migration/index.js"
 
@@ -14,14 +15,14 @@ export default class Dummy {
   static async prepare() {
     dummyConfiguration.setCurrent()
 
-    const db = dummyConfiguration.getDatabasePool()
+    await dummyConfiguration.withConnections(async (dbs) => {
+      const db = digg(dbs, "default")
 
-    await db.withConnection(async () => {
-      await db.query("DROP TABLE IF EXISTS tasks")
-      await db.query("DROP TABLE IF EXISTS project_translations")
-      await db.query("DROP TABLE IF EXISTS projects")
+      await db.dropTable("tasks", {ifExists: true})
+      await db.dropTable("project_translations", {ifExists: true})
+      await db.dropTable("projects", {ifExists: true})
 
-      const migration = new Migration({configuration: dummyConfiguration})
+      const migration = new Migration({configuration: dummyConfiguration, databaseIdentifier: "default", db})
 
       await migration.createTable("projects", (t) => {
         t.timestamps()
@@ -51,7 +52,7 @@ export default class Dummy {
   }
 
   async run(callback) {
-    await dummyConfiguration.getDatabasePool().withConnection(async () => {
+    await dummyConfiguration.withConnections(async () => {
       await Dummy.prepare()
       await this.start()
 

package/spec/dummy/src/config/configuration.example.js

@@ -9,8 +9,30 @@ import requireContext from "require-context"
 
 export default new Configuration({
   database: {
-    default: {
-      master: {
+    development: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "velocious_development"
+      }
+    },
+    production: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "velocious_production"
+      }
+    },
+    test: {
+      default: {
         driver: MysqlDriver,
         poolType: AsyncTrackedMultiConnection,
         type: "mysql",
@@ -27,7 +49,7 @@ export default new Configuration({
     const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
     const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
 
-    await configuration.getDatabasePool().withConnection(async () => {
+    await configuration.withConnections(async () => {
       await initializerFromRequireContext.initialize({configuration})
     })
   },

package/spec/dummy/src/config/configuration.mariadb.js

@@ -0,0 +1,97 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
+import Configuration from "../../../../src/configuration.js"
+import dummyDirectory from "../../dummy-directory.js"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
+import MysqlDriver from "../../../../src/database/drivers/mysql/index.js"
+import path from "path"
+import requireContext from "require-context"
+
+export default new Configuration({
+  database: {
+    development: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "dev",
+        password: "Eid7Eip6iof2weive7yaeshe8eu2Nei4",
+        database: "velocious_test"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_development",
+        useDatabase: "velocious_development",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_development",
+          server: "6.0.0.8",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
+      }
+    },
+    test: {
+      default: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "dev",
+        password: "Eid7Eip6iof2weive7yaeshe8eu2Nei4",
+        database: "velocious_test"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_development",
+        useDatabase: "velocious_development",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_development",
+          server: "6.0.0.8",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
+      }
+    }
+  },
+  debug: false,
+  directory: dummyDirectory(),
+  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",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
+  locales: ["de", "en"]
+})

package/spec/dummy/src/config/configuration.peakflow.mariadb.js

@@ -3,14 +3,15 @@ import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"
 import fs from "fs/promises"
 import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
 import MysqlDriver from "../../../../src/database/drivers/mysql/index.js"
 import path from "path"
 import requireContext from "require-context"
 
 export default new Configuration({
   database: {
-    default: {
-      master: {
+    test: {
+      default: {
         driver: MysqlDriver,
         poolType: AsyncTrackedMultiConnection,
         type: "mysql",
@@ -19,6 +20,28 @@ export default new Configuration({
         password: "password",
         database: "velocious_test",
         useDatabase: "velocious_test"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_test",
+        useDatabase: "default",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_test",
+          server: "mssql",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
       }
     }
   },
@@ -28,7 +51,7 @@ export default new Configuration({
     const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
     const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
 
-    await configuration.getDatabasePool().withConnection(async () => {
+    await configuration.withConnections(async () => {
       await initializerFromRequireContext.initialize({configuration})
     })
   },

package/spec/dummy/src/config/configuration.peakflow.mssql.js

@@ -0,0 +1,75 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
+import Configuration from "../../../../src/configuration.js"
+import dummyDirectory from "../../dummy-directory.js"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
+import path from "path"
+import requireContext from "require-context"
+
+export default new Configuration({
+  database: {
+    test: {
+      default: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_test",
+        useDatabase: "default",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_test",
+          server: "mssql",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_test",
+        useDatabase: "default",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_test",
+          server: "mssql",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
+      }
+    }
+  },
+  directory: dummyDirectory(),
+  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",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
+  locales: ["de", "en"]
+})

package/spec/dummy/src/config/configuration.peakflow.sqlite.js

@@ -1,7 +1,9 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"
 import fs from "fs/promises"
 import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
 import SqliteDriver from "../../../../src/database/drivers/sqlite/index.js"
 import path from "path"
 import requireContext from "require-context"
@@ -9,12 +11,34 @@ import SingleMultiUsePool from "../../../../src/database/pool/single-multi-use.j
 
 export default new Configuration({
   database: {
-    default: {
-      master: {
+    test: {
+      default: {
         driver: SqliteDriver,
         poolType: SingleMultiUsePool,
         type: "sqlite",
         name: "test-db"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_test",
+        useDatabase: "default",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_test",
+          server: "mssql",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
       }
     }
   },
@@ -24,7 +48,7 @@ export default new Configuration({
     const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
     const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
 
-    await configuration.getDatabasePool().withConnection(async () => {
+    await configuration.withConnections(async () => {
       await initializerFromRequireContext.initialize({configuration})
     })
   },

package/spec/dummy/src/config/configuration.sqlite.js

@@ -1,7 +1,9 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"
 import fs from "fs/promises"
 import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
 import path from "path"
 import requireContext from "require-context"
 import SqliteDriver from "../../../../src/database/drivers/sqlite/index.js"
@@ -9,12 +11,64 @@ import SingleMultiUsePool from "../../../../src/database/pool/single-multi-use.j
 
 export default new Configuration({
   database: {
-    default: {
-      master: {
+    development: {
+      default: {
         driver: SqliteDriver,
         poolType: SingleMultiUsePool,
         type: "sqlite",
-        name: "test-db"
+        name: "test-db-development"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_development",
+        useDatabase: "velocious_development",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_development",
+          server: "6.0.0.8",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
+      }
+    },
+    test: {
+      default: {
+        driver: SqliteDriver,
+        poolType: SingleMultiUsePool,
+        type: "sqlite",
+        name: "test-db-test"
+      },
+      mssql: {
+        driver: MssqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mssql",
+        database: "velocious_test",
+        useDatabase: "velocious_test",
+        sqlConfig: {
+          user: "sa",
+          password: "Super-Secret-Password",
+          database: "velocious_test",
+          server: "6.0.0.8",
+          pool: {
+            max: 10,
+            min: 0,
+            idleTimeoutMillis: 30000
+          },
+          options: {
+            encrypt: true, // for azure
+            trustServerCertificate: true // change to true for local dev / self-signed certs
+          }
+        }
       }
     }
   },
@@ -24,7 +78,7 @@ export default new Configuration({
     const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
     const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
 
-    await configuration.getDatabasePool().withConnection(async () => {
+    await configuration.withConnections(async () => {
       await initializerFromRequireContext.initialize({configuration})
     })
   },