velocious 1.0.35 → 1.0.37

package/README.md

@@ -32,6 +32,7 @@ class Task extends Record {
 
 Task.belongsTo("account")
 Task.translates("description", "subTitle", "title")
+Task.validates("name", {presence: true, uniqueness: true})
 
 export default Task
 ```

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",
@@ -22,10 +22,12 @@
   "homepage": "https://github.com/kaspernj/velocious#readme",
   "description": "",
   "devDependencies": {
+    "awaitery": "^1.0.1",
     "jasmine": "^5.0.2",
     "mssql": "^11.0.1",
     "mysql": "^2.18.1",
     "node-fetch": "^3.3.1",
+    "pg": "^8.16.3",
     "require-context": "^1.1.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
@@ -42,9 +44,9 @@
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",
+    "pure-uuid": "^1.8.1",
     "sql-escape-string": "^1.1.0",
     "sql.js": "^1.12.0",
-    "strftime": "^0.10.2",
-    "uuid": "^12.0.0"
+    "strftime": "^0.10.2"
   }
 }

package/peak_flow.yml

@@ -30,24 +30,44 @@ services:
       - 1433
     mem_limit: 4096m
     restart_policy: on-failure
+  postgres:
+    environment:
+      POSTGRES_USER: peakflow
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: velocious_test
+    image: postgres:17.6
+    expose:
+      - 5432
+    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
+      - wait-for-it mssql:1433
+      - cd spec/dummy && npx velocious db:create
       - 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
+      - wait-for-it mssql:1433
       - cd spec/dummy && npx velocious db:create
       - npm test
   build_3:
+    name: PG-SQL
+    script:
+      - cp spec/dummy/src/config/configuration.peakflow.pgsql.js spec/dummy/src/config/configuration.js
+      - wait-for-it mssql:1433
+      - wait-for-it postgres:5432
+      - cd spec/dummy && npx velocious db:create
+      - npm test
+  build_4:
     name: SQLite
     script:
       - cp spec/dummy/src/config/configuration.peakflow.sqlite.js spec/dummy/src/config/configuration.js
+      - wait-for-it mssql:1433
       - cd spec/dummy && npx velocious db:create
       - npm test

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

@@ -30,6 +30,12 @@ describe("Cli - Commands - db:create", () => {
           }
         ]
       )
+    } else if (cli.getConfiguration().getDatabaseType() == "pgsql") {
+      expect(result[2]).toEqual(
+        {
+          createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS "schema_migrations" ("version" VARCHAR(255) PRIMARY KEY NOT NULL)'
+        }
+      )
     } else {
       expect(result).toEqual(
         [

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

@@ -6,7 +6,7 @@ const mysqlConfig = digg(configuration, "database", "test", "default")
 
 describe("Database - Drivers - Mysql - Connection", () => {
   it("connects", async () => {
-    if (configuration.getDatabaseType() != "sqlite" && configuration.getDatabaseType() != "mssql") {
+    if (configuration.getDatabaseType() != "sqlite" && configuration.getDatabaseType() != "mssql" && configuration.getDatabaseType() != "pgsql") {
       const mysql = new DatabaseDriversMysql(mysqlConfig)
 
       await mysql.connect()

package/spec/database/record/create-spec.js

@@ -19,6 +19,8 @@ describe("Record - create", () => {
       expect(project.name()).toEqual("Test project")
       expect(project.nameDe()).toEqual("Test projekt")
       expect(project.nameEn()).toEqual("Test project")
+      expect(project.createdAt()).toBeInstanceOf(Date)
+      expect(project.updatedAt()).toBeInstanceOf(Date)
     })
   })
 
@@ -35,4 +37,26 @@ describe("Record - create", () => {
       expect(task.project()).toEqual(project)
     })
   })
+
+  it("uses transactions and rolls back in case of an error", async () => {
+    await Dummy.run(async () => {
+      const project = new Project({name: "Test project"})
+
+      project.tasks().build({name: " ", project})
+
+      try {
+        await project.save()
+
+        throw new Error("Didnt expect to succeed")
+      } catch (error) {
+        expect(error.message).toEqual("Validation failed: Name can't be blank")
+      }
+
+      const projectsCount = await Project.count()
+      const tasksCount = await Task.count()
+
+      expect(projectsCount).toEqual(0)
+      expect(tasksCount).toEqual(0)
+    })
+  })
 })

package/spec/database/record/update-spec.js

@@ -1,5 +1,7 @@
 import Dummy from "../../dummy/index.js"
+import Project from "../../dummy/src/models/project.js"
 import Task from "../../dummy/src/models/task.js"
+import wait from "awaitery/src/wait.js"
 
 describe("Record - update", () => {
   it("updates a record", async () => {
@@ -12,4 +14,17 @@ describe("Record - update", () => {
       expect(task.readAttribute("name")).toEqual("Updated name")
     })
   })
+
+  it("updates a record with timestamps", async () => {
+    await Dummy.run(async () => {
+      const project = new Project({name: "Test project"})
+
+      await project.save()
+      await wait(1000)
+      await project.update({name: "Updated name"})
+
+      expect(project.name()).toEqual("Updated name")
+      expect(project.updatedAt()).not.toEqual(project.createdAt())
+    })
+  })
 })

package/spec/database/record/validations-spec.js

@@ -0,0 +1,28 @@
+import Dummy from "../../dummy/index.js"
+import Task from "../../dummy/src/models/task.js"
+
+describe("Record - validations", () => {
+  it("raises validations if trying to create an invalid record because of a presence validation", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: " "})
+
+      await expectAsync(task.save()).toBeRejectedWith(new Error("Validation failed: Name can't be blank"))
+    })
+  })
+
+  it("raises validations if trying to create an invalid record because of a uniqueness validation", async () => {
+    await Dummy.run(async () => {
+      await Task.create({name: "Task 1"})
+
+      const task2 = await Task.create({name: "Task 2"})
+
+      try {
+        await task2.update({name: "Task 1"})
+
+        throw new Error("Task 2 save didn't fail")
+      } catch (error) {
+        expect(error.message).toEqual("Validation failed: Name has already been taken")
+      }
+    })
+  })
+})

package/spec/database/transactions-spec.js

@@ -0,0 +1,36 @@
+import Dummy from "../dummy/index.js"
+import dummyConfiguration from "../dummy/src/config/configuration.js"
+import Task from "../dummy/src/models/task.js"
+
+describe("database - transactions", () => {
+  it("supports transactions and savepoints", async () => {
+    await Dummy.run(async () => {
+      await dummyConfiguration.withConnections(async (dbs) => {
+        const db = dbs.default
+
+        await db.transaction(async () => {
+          await Task.create({name: "Task 1"})
+
+          await db.transaction(async () => {
+            await Task.create({name: "Task 2"})
+
+            try {
+              await db.transaction(async () => {
+                await Task.create({name: "Task 3"})
+                await Task.create({name: "    "})
+
+                throw new Error("Didn't expect to succeed")
+              })
+            } catch (error) {
+              expect(error.message).toEqual("Validation failed: Name can't be blank")
+            }
+          })
+        })
+      })
+
+      const tasksCount = await Task.count()
+
+      expect(tasksCount).toEqual(2)
+    })
+  })
+})

package/spec/dummy/src/config/{configuration.sqlite.js → configuration.peakflow.pgsql.js}

@@ -5,60 +5,33 @@ 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 PgsqlDriver from "../../../../src/database/drivers/pgsql/index.js"
 import requireContext from "require-context"
-import SqliteDriver from "../../../../src/database/drivers/sqlite/index.js"
-import SingleMultiUsePool from "../../../../src/database/pool/single-multi-use.js"
 
 export default new Configuration({
   database: {
-    development: {
-      default: {
-        driver: SqliteDriver,
-        poolType: SingleMultiUsePool,
-        type: "sqlite",
-        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"
+        driver: PgsqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "pgsql",
+        host: "postgres",
+        username: "peakflow",
+        password: "password",
+        database: "velocious_test",
+        useDatabase: "velocious_test"
       },
       mssql: {
         driver: MssqlDriver,
         poolType: AsyncTrackedMultiConnection,
         type: "mssql",
         database: "velocious_test",
-        useDatabase: "velocious_test",
+        useDatabase: "default",
         sqlConfig: {
           user: "sa",
           password: "Super-Secret-Password",
           database: "velocious_test",
-          server: "6.0.0.8",
+          server: "mssql",
           pool: {
             max: 10,
             min: 0,

package/spec/dummy/src/models/task.js

@@ -4,5 +4,6 @@ class Task extends DatabaseRecord {
 }
 
 Task.belongsTo("project")
+Task.validates("name", {presence: true, uniqueness: true})
 
 export default Task

package/src/cli/commands/db/create.js

@@ -24,12 +24,15 @@ export default class DbCreate extends BaseCommand{
       this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
       await this.databaseConnection.connect()
 
-      if (databaseType != "sqlite") {
-        await this.createDatabase(databaseIdentifier)
-      }
+      try {
+        if (databaseType != "sqlite") {
+          await this.createDatabase(databaseIdentifier)
+        }
 
-      await this.createSchemaMigrationsTable()
-      await this.databaseConnection.close()
+        await this.createSchemaMigrationsTable()
+      } finally {
+        await this.databaseConnection.close()
+      }
 
       if (this.args.testing) return this.result
     }
@@ -37,12 +40,14 @@ export default class DbCreate extends BaseCommand{
 
   async createDatabase(databaseIdentifier) {
     const databaseName = digg(this.configuration.getDatabaseConfiguration(), databaseIdentifier, "database")
-    const sql = this.databaseConnection.createDatabaseSql(databaseName, {ifNotExists: true})
+    const sqls = this.databaseConnection.createDatabaseSql(databaseName, {ifNotExists: true})
 
-    if (this.args.testing) {
-      this.result.push({databaseName, sql})
-    } else {
-      await this.databaseConnection.query(sql)
+    for (const sql of sqls) {
+      if (this.args.testing) {
+        this.result.push({databaseName, sql})
+      } else {
+        await this.databaseConnection.query(sql)
+      }
     }
   }
 

package/src/cli/commands/test.js

@@ -9,5 +9,13 @@ export default class VelociousCliCommandsInit extends BaseCommand {
     const testRunner = new TestRunner({configuration: this.configuration, testFiles})
 
     await testRunner.run()
+
+    if (testRunner.isFailed()) {
+      console.error(`Test run failed with ${testRunner.failedTests} failed tests and ${testRunner.successfulTests} successfull`)
+      process.exit(-1)
+    } else {
+      console.log(`Test run succeeded with ${testRunner.successfulTests} successful tests`)
+      process.exit(1)
+    }
   }
 }

package/src/configuration.js

@@ -137,6 +137,20 @@ export default class VelociousConfiguration {
     this.routes = newRoutes
   }
 
+  setTranslator(callback) {
+    this._translator = callback
+  }
+
+  _defaultTranslator(msgID, args) {
+    if (args?.defaultValue) return args.defaultValue
+
+    return msgID
+  }
+
+  getTranslator() {
+    return this._translator || this._defaultTranslator
+  }
+
   async withConnections(callback) {
     const dbs = {}
     const actualCallback = async () => {

package/src/database/drivers/base.js

@@ -1,7 +1,8 @@
 import {Logger} from "../../logger.js"
 import Query from "../query/index.js"
 import Handler from "../handler.js"
-import {v4 as uuidv4} from "uuid"
+import strftime from "strftime"
+import UUID from "pure-uuid"
 
 export default class VelociousDatabaseDriversBase {
   constructor(config, configuration) {
@@ -66,6 +67,14 @@ export default class VelociousDatabaseDriversBase {
     throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
   }
 
+  _convertValue(value) {
+    if (value instanceof Date) {
+      return strftime("%F %T.%L", value)
+    }
+
+    return value
+  }
+
   quote(value) {
     if (typeof value == "number") return value
 
@@ -126,9 +135,17 @@ export default class VelociousDatabaseDriversBase {
 
     if (this._transactionsCount == 0) {
       this.logger.debug("Start transaction")
-      await this.startTransaction()
-      transactionStarted = true
       this._transactionsCount++
+
+      try {
+        await this.startTransaction()
+      } catch (error) {
+        this._transactionsCount--
+
+        throw error
+      }
+
+      transactionStarted = true
     } else {
       this.logger.debug("Start savepoint", savePointName)
       await this.startSavePoint(savePointName)
@@ -183,7 +200,7 @@ export default class VelociousDatabaseDriversBase {
   }
 
   generateSavePointName() {
-    return `sp${uuidv4().replaceAll("-", "")}`
+    return `sp${new UUID(4).format().replaceAll("-", "")}`
   }
 
   async startSavePoint(savePointName) {

package/src/database/drivers/mssql/index.js

@@ -12,7 +12,7 @@ import mssql from "mssql"
 import QueryParser from "./query-parser.js"
 import Table from "./table.js"
 import Update from "./sql/update.js"
-import {v4 as uuidv4} from "uuid"
+import UUID from "pure-uuid"
 
 export default class VelociousDatabaseDriversMssql extends Base{
   async connect() {
@@ -99,7 +99,11 @@ export default class VelociousDatabaseDriversMssql extends Base{
 
   shouldSetAutoIncrementWhenPrimaryKey = () => true
 
+
+
   escape(value) {
+    value = this._convertValue(value)
+
     const type = typeof value
 
     if (type != "string") value = `${value}`
@@ -111,6 +115,8 @@ export default class VelociousDatabaseDriversMssql extends Base{
   }
 
   quote(value) {
+    value = this._convertValue(value)
+
     const type = typeof value
 
     if (type == "number") return value
@@ -172,9 +178,11 @@ export default class VelociousDatabaseDriversMssql extends Base{
   }
 
   async startTransaction() {
+    if (!this.connection) throw new Error("No connection")
     if (this._currentTransaction) throw new Error("A transaction is already running")
 
-    this._currentTransaction = new mssql.Transaction()
+    this._currentTransaction = new mssql.Transaction(this.connection)
+
     await this._currentTransaction.begin()
   }
 
@@ -189,6 +197,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
     if (!this._currentTransaction) throw new Error("A transaction isn't running")
 
     await this._currentTransaction.rollback()
+
     this._currentTransaction = null
   }
 
@@ -205,7 +214,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
   }
 
   generateSavePointName() {
-    return `sp${uuidv4().replaceAll("-", "")}`.substring(0, 32)
+    return `sp${new UUID(4).format().replaceAll("-", "")}`.substring(0, 32)
   }
 
   updateSql({conditions, data, tableName}) {

package/src/database/drivers/mssql/sql/create-database.js

@@ -23,6 +23,6 @@ export default class VelociousDatabaseConnectionDriversMssqlSqlCreateDatabase ex
       sql += " END"
     }
 
-    return sql
+    return [sql]
   }
 }

package/src/database/drivers/mysql/index.js

@@ -102,7 +102,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
   escape(value) {
     if (!this.connection) throw new Error("Can't escape before connected")
 
-    const escapedValueWithQuotes = this.connection.escape(value)
+    const escapedValueWithQuotes = this.connection.escape(this._convertValue(value))
 
     return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)
   }
@@ -110,7 +110,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
   quote(value) {
     if (!this.connection) throw new Error("Can't escape before connected")
 
-    return this.connection.escape(value)
+    return this.connection.escape(this._convertValue(value))
   }
 
   deleteSql({tableName, conditions}) {

package/src/database/drivers/pgsql/column.js

@@ -0,0 +1,10 @@
+export default class VelociousDatabaseDriversPgsqlColumn {
+  constructor(table, data) {
+    this.data = data
+    this.table = table
+  }
+
+  getName() {
+    return this.data.column_name
+  }
+}

package/src/database/drivers/pgsql/foreign-key.js

@@ -0,0 +1,13 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversPgsqlForeignKey {
+  constructor(data) {
+    this.data = data
+  }
+
+  getColumnName = () => digg(this, "data", "column_name")
+  getName = () => digg(this, "data", "constraint_name")
+  getTableName = () => digg(this, "data", "table_name")
+  getReferencedColumnName = () => digg(this, "data", "foreign_column_name")
+  getReferencedTableName = () => digg(this, "data", "foreign_table_name")
+}