velocious 1.0.35 → 1.0.37

package/src/database/record/index.js

@@ -7,8 +7,26 @@ import HasManyRelationship from "./relationships/has-many.js"
 import HasManyInstanceRelationship from "./instance-relationships/has-many.js"
 import * as inflection from "inflection"
 import Query from "../query/index.js"
+import ValidatorsPresence from "./validators/presence.js"
+import ValidatorsUniqueness from "./validators/uniqueness.js"
+
+class VelociousDatabaseRecord {
+  static validatorTypes() {
+    if (!this._validatorTypes) this._validatorTypes = {}
+
+    return this._validatorTypes
+  }
+
+  static registerValidatorType(name, validatorClass) {
+    this.validatorTypes()[name] = validatorClass
+  }
+
+  static getValidatorType(validatorName) {
+    if (!(validatorName in this.validatorTypes())) throw new Error(`Validator type ${validatorName} not found`)
+
+    return this.validatorTypes()[validatorName]
+  }
 
-export default class VelociousDatabaseRecord {
   static _relationshipExists(relationshipName) {
     if (this._relationships && relationshipName in this._relationships) {
       return true
@@ -153,6 +171,12 @@ export default class VelociousDatabaseRecord {
     return this._defineRelationship(relationshipName, Object.assign({type: "hasMany"}, options))
   }
 
+  static humanAttributeName(attributeName) {
+    const modelNameKey = inflection.underscore(this.constructor.name)
+
+    return this._getConfiguration().getTranslator()(`velocious.database.record.attributes.${modelNameKey}.${attributeName}`, {defaultValue: inflection.camelize(attributeName)})
+  }
+
   static async initializeRecord({configuration}) {
     if (!configuration) throw new Error(`No configuration given for ${this.name}`)
 
@@ -296,11 +320,19 @@ export default class VelociousDatabaseRecord {
     const isNewRecord = this.isNewRecord()
     let result
 
+    await this._runValidations()
+
     await this.constructor.transaction(async () => {
-      await this._autoSaveBelongsToRelationships()
+      // If any belongs-to-relationships was saved, then updated-at should still be set on this record.
+      const {savedCount} = await this._autoSaveBelongsToRelationships()
 
       if (this.isPersisted()) {
-        result = await this._updateRecordWithChanges()
+        // If any has-many-relationships will be saved, then updated-at should still be set on this record.
+        const autoSaveHasManyrelationships = this._autoSaveHasManyRelationshipsToSave()
+
+        if (this._hasChanges() || savedCount > 0 || autoSaveHasManyrelationships.length > 0) {
+          result = await this._updateRecordWithChanges()
+        }
       } else {
         result = await this._createNewRecord()
       }
@@ -312,6 +344,8 @@ export default class VelociousDatabaseRecord {
   }
 
   async _autoSaveBelongsToRelationships() {
+    let savedCount = 0
+
     for (const relationshipName in this._instanceRelationships) {
       const instanceRelationship = this._instanceRelationships[relationshipName]
 
@@ -329,11 +363,17 @@ export default class VelociousDatabaseRecord {
         this.setAttribute(foreignKey, model.id())
         instanceRelationship.setPreloaded(true)
         instanceRelationship.setDirty(false)
+
+        savedCount++
       }
     }
+
+    return {savedCount}
   }
 
-  async _autoSaveHasManyRelationships({isNewRecord}) {
+  _autoSaveHasManyRelationshipsToSave() {
+    const relationships = []
+
     for (const relationshipName in this._instanceRelationships) {
       const instanceRelationship = this._instanceRelationships[relationshipName]
 
@@ -345,6 +385,31 @@ export default class VelociousDatabaseRecord {
 
       if (!Array.isArray(loaded)) loaded = [loaded]
 
+      let useRelationship = false
+
+      for (const model of loaded) {
+        const foreignKey = instanceRelationship.getForeignKey()
+
+        model.setAttribute(foreignKey, this.id())
+
+        if (model.isChanged()) {
+          useRelationship = true
+          continue
+        }
+      }
+
+      if (useRelationship) relationships.push(instanceRelationship)
+    }
+
+    return relationships
+  }
+
+  async _autoSaveHasManyRelationships({isNewRecord}) {
+    for (const instanceRelationship of this._autoSaveHasManyRelationshipsToSave()) {
+      let loaded = instanceRelationship._loaded
+
+      if (!Array.isArray(loaded)) loaded = [loaded]
+
       for (const model of loaded) {
         const foreignKey = instanceRelationship.getForeignKey()
 
@@ -423,6 +488,19 @@ export default class VelociousDatabaseRecord {
     }
   }
 
+  static async validates(attributeName, validators) {
+    for (const validatorName in validators) {
+      const validatorArgs = validators[validatorName]
+      const ValidatorClass = this.getValidatorType(validatorName)
+      const validator = new ValidatorClass({attributeName, args: validatorArgs})
+
+      if (!this._validators) this._validators = {}
+      if (!(attributeName in this._validators)) this._validators[attributeName] = []
+
+      this._validators[attributeName].push(validator)
+    }
+  }
+
   _getTranslatedAttribute(name, locale) {
     const translation = this.translations().loaded().find((translation) => translation.locale() == locale)
 
@@ -529,6 +607,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery().preload(...args)
   }
 
+  static select(...args) {
+    return this._newQuery().select(...args)
+  }
+
   static toArray(...args) {
     return this._newQuery().toArray(...args)
   }
@@ -662,14 +744,24 @@ export default class VelociousDatabaseRecord {
 
   readAttribute(attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
+    const column = this.constructor.getColumns().find((column) => column.getName() == attributeNameUnderscore)
+    let result
 
-    if (attributeNameUnderscore in this._changes) return this._changes[attributeNameUnderscore]
-
-    if (!(attributeNameUnderscore in this._attributes) && this.isPersisted()) {
+    if (attributeNameUnderscore in this._changes) {
+      result = this._changes[attributeNameUnderscore]
+    } else if (attributeNameUnderscore in this._attributes) {
+      result = this._attributes[attributeNameUnderscore]
+    } else if (this.isPersisted()) {
       throw new Error(`No such attribute or not selected ${this.constructor.name}#${attributeName}`)
     }
 
-    return this._attributes[attributeNameUnderscore]
+    if (column && this.constructor.connection().getType() == "sqlite") {
+      if (column.getType() == "date" || column.getType() == "datetime") {
+        result = new Date(Date.parse(result))
+      }
+    }
+
+    return result
   }
 
   _belongsToChanges() {
@@ -693,7 +785,14 @@ export default class VelociousDatabaseRecord {
       throw new Error(`No insertSql on ${this.constructor.connection().constructor.name}`)
     }
 
+    const createdAtColumn = this.constructor.getColumns().find((column) => column.getName() == "created_at")
+    const updatedAtColumn = this.constructor.getColumns().find((column) => column.getName() == "updated_at")
     const data = Object.assign({}, this._belongsToChanges(), this.attributes())
+    const currentDate = new Date()
+
+    if (createdAtColumn) data.created_at = currentDate
+    if (updatedAtColumn) data.updated_at = currentDate
+
     const sql = this._connection().insertSql({
       returnLastInsertedColumnName: this.constructor.primaryKey(),
       tableName: this._tableName(),
@@ -720,21 +819,25 @@ export default class VelociousDatabaseRecord {
   }
 
   async _updateRecordWithChanges() {
-    if (!this._hasChanges()) return
-
     const conditions = {}
 
     conditions[this.constructor.primaryKey()] = this.id()
 
     const changes = Object.assign({}, this._belongsToChanges(), this._changes)
-
-    const sql = this._connection().updateSql({
-      tableName: this._tableName(),
-      data: changes,
-      conditions
-    })
-    await this._connection().query(sql)
-    await this._reloadWithId(this.id())
+    const updatedAtColumn = this.constructor.getColumns().find((column) => column.getName() == "updated_at")
+    const currentDate = new Date()
+
+    if (updatedAtColumn) changes.updated_at = currentDate
+
+    if (Object.keys(changes).length > 0) {
+      const sql = this._connection().updateSql({
+        tableName: this._tableName(),
+        data: changes,
+        conditions
+      })
+      await this._connection().query(sql)
+      await this._reloadWithId(this.id())
+    }
   }
 
   id = () => this.readAttribute(this.constructor.primaryKey())
@@ -764,9 +867,50 @@ export default class VelociousDatabaseRecord {
     this._reloadWithId(this.readAttribute("id"))
   }
 
+  async _runValidations() {
+    this._validationErrors = {}
+
+    const validators = this.constructor._validators
+
+    if (validators) {
+      for (const attributeName in validators) {
+        const attributeValidators = validators[attributeName]
+
+        for (const validator of attributeValidators) {
+          await validator.validate({model: this, attributeName})
+        }
+      }
+    }
+
+    if (Object.keys(this._validationErrors).length > 0) {
+      throw new Error(`Validation failed: ${this.fullErrorMessages().join(". ")}`)
+    }
+  }
+
+  fullErrorMessages() {
+    const validationErrorMessages = []
+
+    if (this._validationErrors) {
+      for (const attributeName in this._validationErrors) {
+        for (const validationError of this._validationErrors[attributeName]) {
+          const message = `${this.constructor.humanAttributeName(attributeName)} ${validationError.message}`
+
+          validationErrorMessages.push(message)
+        }
+      }
+    }
+
+    return validationErrorMessages
+  }
+
   async update(attributesToAssign) {
     if (attributesToAssign) this.assign(attributesToAssign)
 
     await this.save()
   }
 }
+
+VelociousDatabaseRecord.registerValidatorType("presence", ValidatorsPresence)
+VelociousDatabaseRecord.registerValidatorType("uniqueness", ValidatorsUniqueness)
+
+export default VelociousDatabaseRecord

package/src/database/record/validators/base.js

@@ -0,0 +1,2 @@
+export default class VelociousDatabaseRecordValidatorsBase {
+}

package/src/database/record/validators/presence.js

@@ -0,0 +1,13 @@
+import Base from "./base.js"
+
+export default class VelociousDatabaseRecordValidatorsPresence extends Base {
+  validate({model, attributeName}) {
+    const attributeValue = model.readAttribute(attributeName).trim()
+
+    if (!attributeValue) {
+      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []
+
+      model._validationErrors[attributeName].push({type: "presence", message: "can't be blank"})
+    }
+  }
+}

package/src/database/record/validators/uniqueness.js

@@ -0,0 +1,23 @@
+import Base from "./base.js"
+import * as inflection from "inflection"
+
+export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
+  async validate({model, attributeName}) {
+    const attributeValue = model.readAttribute(attributeName)
+    const attributeNameUnderscore = inflection.underscore(attributeName)
+    const whereArgs = {}
+
+    whereArgs[attributeNameUnderscore] = attributeValue
+
+    const existingRecord = await model.constructor
+      .select(model.constructor.primaryKey())
+      .where(whereArgs)
+      .first()
+
+    if (existingRecord) {
+      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []
+
+      model._validationErrors[attributeName].push({type: "uniqueness", message: "has already been taken"})
+    }
+  }
+}

package/src/testing/test-runner.js

@@ -43,7 +43,14 @@ export default class TestRunner {
     }
   }
 
+  isFailed() {
+    return this.failedTests > 0
+  }
+
   async run() {
+    this.failedTests = 0
+    this.successfulTests = 0
+
     await this.importTestFiles()
     await this.runTests(tests, [], 0)
   }
@@ -65,7 +72,10 @@ export default class TestRunner {
 
       try {
         await testData.function(testArgs)
+        this.successfulTests++
       } catch (error) {
+        this.failedTests++
+
         // console.error(`${leftPadding}  Test failed: ${error.message}`)
         console.error(error.stack)
       }

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

@@ -1,97 +0,0 @@
-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"]
-})