velocious 1.0.66 → 1.0.68

package/README.md

@@ -62,14 +62,51 @@ await project.loadTasks()
 const tasks = project.tasks().loaded()
 ```
 
+### Create records
+
+```js
+const task = new Task({identifier: "task-4"})
+
+task.assign({name: "New task})
+
+await task.save()
+```
+
+```js
+const task = await Task.create({name: "Task 4"})
+```
+
+### Find or create records
+
+```js
+const task = await Task.findOrInitializeBy({identifier: "task-5"})
+
+if (task.isNewRecord()) {
+  console.log("Task didn't already exist")
+
+  await task.save()
+}
+
+if (task.isPersisted()) {
+  console.log("Task already exist")
+}
+```
+
+```js
+const task = await Task.findOrCreateBy({identifier: "task-5"}, (newTask) => {
+  newTask.assign({description: "This callback only happens if not already existing"})
+})
+```
+
 # Migrations
 
-Make a new migration from a template like this:
+## Make a new migration from a template
 
 ```bash
 npx velocious g:migration create-tasks
 ```
 
+## Write a migration
 ```js
 import Migration from "velocious/src/database/migration/index.js"
 
@@ -96,12 +133,13 @@ export default class CreateEvents extends Migration {
 }
 ```
 
-Run migrations from the command line like this:
+## Run migrations from the command line
+
 ```bash
 npx velocious db:migrate
 ```
 
-Run migrations from anywhere if you want to:
+## Run migrations from anywhere if you want to:
 
 ```js
 const migrationsPath = `/some/dir/migrations`
@@ -122,7 +160,10 @@ import {Task} from "@/src/models/task"
 
 const tasks = await Task
   .preload({project: {account: true}})
+  .joins({project: true})
   .where({projects: {public: true}})
+  .joins("JOIN task_details ON task_details.task_id = tasks.id")
+  .where("task_details.id IS NOT NULL")
   .order("name")
   .limit(5)
   .toArray()
@@ -138,7 +179,7 @@ npx velocious test
 If you are developing on Velocious, you can run the tests with:
 
 ```bash
-npm run test
+./run-tests.sh
 ```
 
 # Writing a request test
@@ -169,8 +210,63 @@ await describe("accounts - create", {type: "request"}, async () => {
 })
 ```
 
+# Routes
+
+Create or edit the file `src/config/routes.js` and do something like this:
+
+```js
+import Routes from "velocious/src/routes/index.js"
+
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("projects")
+
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+
+  route.namespace("testing", (route) => {
+    route.post("truncate")
+  })
+
+  route.get("ping")
+})
+
+export default {routes}
+```
+
+# Controllers
+
+Create the file `src/routes/testing/controller.js` and do something like this:
+
+```js
+import Controller from "velocious/src/controller.js"
+
+export default class TestingController extends Controller {
+  async truncate() {
+    await doSomething()
+    this.renderJson({status: "database-truncated"})
+  }
+
+  async anotherAction() {
+    render("test-view")
+  }
+}
+```
+
+# Views
+
+Create the file `src/routes/testing/another-action.ejs` and so something like this:
+
+```ejs
+<p>
+  View for path: <%= controller.getRequest().path() %>
+</p>
+```
+
 # Running a server
 
 ```bash
-npx velocious server
+npx velocious server --host 0.0.0.0 --port 8082
 ```

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",

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

@@ -29,14 +29,55 @@ describe("Record - create", () => {
       // 'name' is not a column but rather a column on the translation data model.
       expect(() => project.readColumn("name")).toThrowError("No such attribute or not selected Project#name")
 
-      // It saves a project note
+
+      // It saves a project note through a has one relationship
       const projectDetail = project.projectDetail()
 
+      expect(projectDetail.isNewRecord()).toBeFalse()
+      expect(projectDetail.isPersisted()).toBeTrue()
       expect(projectDetail.note()).toEqual("Test note")
       expect(projectDetail.projectId()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-one-relationship
+      const projectInstanceRelationship = projectDetail.getRelationshipByName("project")
+
+      expect(projectInstanceRelationship.getPreloaded()).toBeTrue()
+      expect(projectDetail.project().id()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-many-relationship
+      const tasksRelationship = project.getRelationshipByName("tasks")
+
+      expect(tasksRelationship.getPreloaded()).toBeTrue()
+
+      const projectTasksIDs = project.tasks().loaded().map((task) => task.id())
+
+      expect(projectTasksIDs).toEqual([task.id()])
     })
   })
 
+  it("sets the inversed relationship on has-many-relationships", async () => {
+    const project = new Project({name: "Test project"})
+
+    project.tasks().build({name: "Test task 1"})
+    project.tasks().build({name: "Test task 2"})
+
+    await project.save()
+
+    const tasks = project.tasks().loaded()
+    const task1 = tasks.find((task) => task.name() == "Test task 1")
+    const task2 = tasks.find((task) => task.name() == "Test task 2")
+
+    expect(tasks.length).toEqual(2)
+
+    expect(task1.projectId()).toEqual(project.id())
+    expect(task1.project().id()).toEqual(project.id())
+
+    expect(task2.projectId()).toEqual(project.id())
+    expect(task2.project().id()).toEqual(project.id())
+  })
+
   it("creates a new task with an existing project", async () => {
     await Dummy.run(async () => {
       const project = await Project.create({name: "Test project"})

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

@@ -0,0 +1,59 @@
+import Dummy from "../../dummy/index.js"
+import Task from "../../dummy/src/models/task.js"
+
+describe("Record - find or create", () => {
+  it("doesnt find but then creates a record", async () => {
+    await Dummy.run(async () => {
+      const task = await Task.findOrCreateBy({name: "Test task"}, (newTask) => {
+        const project = newTask.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
+
+        project.buildProjectDetail({note: "Test note"})
+      })
+
+      const project = task.project()
+
+      expect(task.isPersisted()).toBeTrue()
+      expect(task.isNewRecord()).toBeFalse()
+      expect(task.id()).not.toBeUndefined()
+      expect(task.name()).toEqual("Test task")
+      expect(task.project().id()).toEqual(project.id())
+      expect(task.project()).toEqual(project)
+
+      expect(project.id()).not.toBeUndefined()
+      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)
+
+      // 'name' is not a column but rather a column on the translation data model.
+      expect(() => project.readColumn("name")).toThrowError("No such attribute or not selected Project#name")
+
+
+      // It saves a project note through a has one relationship
+      const projectDetail = project.projectDetail()
+
+      expect(projectDetail.isNewRecord()).toBeFalse()
+      expect(projectDetail.isPersisted()).toBeTrue()
+      expect(projectDetail.note()).toEqual("Test note")
+      expect(projectDetail.projectId()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-one-relationship
+      const projectInstanceRelationship = projectDetail.getRelationshipByName("project")
+
+      expect(projectInstanceRelationship.getPreloaded()).toBeTrue()
+      expect(projectDetail.project().id()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-many-relationship
+      const tasksRelationship = project.getRelationshipByName("tasks")
+
+      expect(tasksRelationship.getPreloaded()).toBeTrue()
+
+      const projectTasksIDs = project.tasks().loaded().map((task) => task.id())
+
+      expect(projectTasksIDs).toEqual([task.id()])
+    })
+  })
+})

package/src/database/drivers/base.js

@@ -125,7 +125,7 @@ export default class VelociousDatabaseDriversBase {
   }
 
   quoteTable(tableName) {
-    return this.options().quoteColumnName(tableName)
+    return this.options().quoteTableName(tableName)
   }
 
   newQuery() {

package/src/database/query/index.js

@@ -108,8 +108,8 @@ export default class VelociousDatabaseQuery {
     return await this.clone().where(newConditions).first()
   }
 
-  async findOrCreateBy(conditions) {
-    const record = await this.findOrInitializeBy(conditions)
+  async findOrCreateBy(...args) {
+    const record = await this.findOrInitializeBy(...args)
 
     if (record.isNewRecord()) {
       await record.save()
@@ -118,13 +118,17 @@ export default class VelociousDatabaseQuery {
     return record
   }
 
-  async findOrInitializeBy(conditions) {
+  async findOrInitializeBy(conditions, callback) {
     const record = await this.findBy(conditions)
 
     if (record) return record
 
     const newRecord = new this.modelClass(conditions)
 
+    if (callback) {
+      callback(newRecord)
+    }
+
     return newRecord
   }
 

package/src/database/query/preloader/has-many.js

@@ -46,13 +46,13 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
       for (const model of modelsByPrimaryKeyValue[modelValue]) {
         const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
 
-        modelRelationship.setPreloaded(true)
-
         if (preloadedCollection.length == 0) {
           modelRelationship.setLoaded([])
         } else {
           modelRelationship.addToLoaded(preloadedCollection)
         }
+
+        modelRelationship.setPreloaded(true)
       }
     }
 

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

@@ -23,7 +23,7 @@ export default class VelocuiousDatabaseQueryParserWhereParser {
     for (const whereKey in query._wheres) {
       const where = query._wheres[whereKey]
 
-      if (whereKey > 0) sql += " &&"
+      if (whereKey > 0) sql += " AND"
 
       if (pretty) {
         sql += "\n  "

package/src/database/record/index.js

@@ -85,8 +85,24 @@ class VelociousDatabaseRecord {
       }
 
       this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+        const instanceRelationship = this.getRelationshipByName(relationshipName)
+        const record = instanceRelationship.build(attributes)
+
+        const inverseOf = instanceRelationship.getRelationship().getInverseOf()
+
+        if (inverseOf) {
+          const inverseInstanceRelationship = record.getRelationshipByName(inverseOf)
+
+          inverseInstanceRelationship.setAutoSave(false)
+
+          if (inverseInstanceRelationship.getType() == "hasOne") {
+            inverseInstanceRelationship.setLoaded(this)
+          } else if (inverseInstanceRelationship.getType() == "hasMany") {
+            inverseInstanceRelationship.addToLoaded(this)
+          } else {
+            throw new Error(`Unknown relationship type: ${inverseInstanceRelationship.getType()}`)
+          }
+        }
 
         return record
       }
@@ -119,8 +135,17 @@ class VelociousDatabaseRecord {
       }
 
       this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+        const instanceRelationship = this.getRelationshipByName(relationshipName)
+        const record = instanceRelationship.build(attributes)
+
+        const inverseOf = instanceRelationship.getRelationship().getInverseOf()
+
+        if (inverseOf) {
+          const inverseInstanceRelationship = record.getRelationshipByName(inverseOf)
+
+          inverseInstanceRelationship.setAutoSave(false)
+          inverseInstanceRelationship.setLoaded(this)
+        }
 
         return record
       }
@@ -151,6 +176,10 @@ class VelociousDatabaseRecord {
     return []
   }
 
+  static getRelationshipNames() {
+    return this.getRelationships().map((relationship) => relationship.getRelationshipName())
+  }
+
   getRelationshipByName(relationshipName) {
     if (!this._instanceRelationships) this._instanceRelationships = {}
 
@@ -435,6 +464,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       const model = instanceRelationship.loaded()
 
       if (model?.isChanged()) {
@@ -443,6 +476,7 @@ class VelociousDatabaseRecord {
         const foreignKey = instanceRelationship.getForeignKey()
 
         this.setAttribute(foreignKey, model.id())
+
         instanceRelationship.setPreloaded(true)
         instanceRelationship.setDirty(false)
 
@@ -463,6 +497,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       let loaded
 
       if (instanceRelationship.getType() == "hasOne") {
@@ -500,7 +538,7 @@ class VelociousDatabaseRecord {
 
   async _autoSaveHasManyAndHasOneRelationships({isNewRecord}) {
     for (const instanceRelationship of this._autoSaveHasManyAndHasOneRelationshipsToSave()) {
-      let loaded = instanceRelationship._loaded
+      let loaded = instanceRelationship.getLoadedOrNull()
 
       if (!Array.isArray(loaded)) loaded = [loaded]
 
@@ -804,6 +842,10 @@ class VelociousDatabaseRecord {
         const instanceRelationship = this._instanceRelationships[instanceRelationshipName]
         let loaded = instanceRelationship._loaded
 
+        if (instanceRelationship.getAutoSave() === false) {
+          continue
+        }
+
         if (!loaded) continue
         if (!Array.isArray(loaded)) loaded = [loaded]
 
@@ -915,6 +957,10 @@ class VelociousDatabaseRecord {
     for (const relationship of this.constructor.getRelationships()) {
       const instanceRelationship = this.getRelationshipByName(relationship.getRelationshipName())
 
+      if (instanceRelationship.getType() == "hasMany" && instanceRelationship.getLoadedOrNull() === null) {
+        instanceRelationship.setLoaded([])
+      }
+
       instanceRelationship.setPreloaded(true)
     }
   }

package/src/database/record/instance-relationships/base.js

@@ -1,10 +1,13 @@
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
   constructor({model, relationship}) {
+    this._autoSave = null
     this._dirty = false
     this.model = model
     this.relationship = relationship
   }
 
+  getAutoSave() { return this._autoSave }
+  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }
   setDirty(newValue) { this._dirty = newValue }
   getDirty() { return this._dirty }
   isLoaded() { return Boolean(this._loaded) }
@@ -18,6 +21,7 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
   }
 
   setLoaded(model) { this._loaded = model }
+  getPreloaded() { return this._preloaded }
   setPreloaded(preloadedValue) { this._preloaded = preloadedValue }
   getForeignKey() { return this.getRelationship().getForeignKey() }
   getModel() { return this.model }

package/src/database/record/instance-relationships/belongs-to.js

@@ -10,9 +10,7 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
     return newInstance
   }
 
-  getLoadedOrNull() {
-    return this._loaded
-  }
+  getLoadedOrNull() { return this._loaded }
 
   async load() {
     const foreignKey = this.getForeignKey()

package/src/database/record/instance-relationships/has-many.js

@@ -7,13 +7,29 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
   }
 
   build(data) {
+    // Spawn new model of the targeted class
     const targetModelClass = this.getTargetModelClass()
     const newInstance = new targetModelClass(data)
 
+
+    // Add it to the loaded models of this relationship
     if (this._loaded === null) this._loaded = []
 
     this._loaded.push(newInstance)
 
+
+    // Set loaded on the models inversed relationship
+    const inverseOf = this.getRelationship().getInverseOf()
+
+    if (inverseOf) {
+      const inverseInstanceRelationship = newInstance.getRelationshipByName(inverseOf)
+
+      inverseInstanceRelationship.setAutoSave(false)
+      inverseInstanceRelationship.setLoaded(this.getModel())
+    }
+
+
+    // Return the new contructed model
     return newInstance
   }
 
@@ -38,13 +54,15 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
     }
 
-    return this._loaded
-  }
+    if (this._loaded === null && this.model.isNewRecord()) {
+      return []
+    }
 
-  getLoadedOrNull() {
     return this._loaded
   }
 
+  getLoadedOrNull() { return this._loaded }
+
   addToLoaded(models) {
     if (Array.isArray(models)) {
       for (const model of models) {
@@ -53,6 +71,8 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
         this._loaded.push(model)
       }
     } else {
+      if (this._loaded === null) this._loaded = []
+
       this._loaded.push(models)
     }
   }
@@ -63,5 +83,13 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     this._loaded = models
   }
 
-  getTargetModelClass = () => this.relationship.getTargetModelClass()
+  setPreloaded(preloaded) {
+    if (preloaded && !Array.isArray(this._loaded)) {
+      throw new Error("Trying to set preloaded without a loaded value")
+    }
+
+    this._preloaded = preloaded
+  }
+
+  getTargetModelClass() { return this.relationship.getTargetModelClass() }
 }

package/src/database/record/instance-relationships/has-one.js

@@ -39,9 +39,7 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     return this._loaded
   }
 
-  getLoadedOrNull() {
-    return this._loaded
-  }
+  getLoadedOrNull() { return this._loaded }
 
   setLoaded(model) {
     if (Array.isArray(model)) throw new Error(`Argument given to setLoaded was an array: ${typeof model}`)
@@ -49,5 +47,5 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     this._loaded = model
   }
 
-  getTargetModelClass = () => this.relationship.getTargetModelClass()
+  getTargetModelClass() { return this.relationship.getTargetModelClass() }
 }

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

@@ -1,7 +1,7 @@
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseRecordBaseRelationship {
-  constructor({className, configuration, dependent, foreignKey, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) {
+  constructor({className, configuration, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
@@ -11,6 +11,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this.configuration = configuration
     this._dependent = dependent
     this.foreignKey = foreignKey
+    this._inverseOf
     this.klass = klass
     this.modelClass = modelClass
     this._primaryKey = primaryKey

package/src/database/record/relationships/belongs-to.js

@@ -9,4 +9,28 @@ export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRe
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedHasOneInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+        const autoGeneratedHasManyInverseOfName = inflection.pluralize(autoGeneratedHasOneInverseOfName)
+
+        if (targetClassRelationshipNames.includes(autoGeneratedHasOneInverseOfName)) {
+          this._inverseOf = autoGeneratedHasOneInverseOfName
+        } else if (targetClassRelationshipNames.includes(autoGeneratedHasManyInverseOfName)) {
+          this._inverseOf = autoGeneratedHasManyInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }

package/src/database/record/relationships/has-many.js

@@ -9,4 +9,25 @@ export default class VelociousDatabaseRecordHasManyRelationship extends BaseRela
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = inflection.singularize(`${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`)
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+
+        if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {
+          this._inverseOf = autoGeneratedBelongsToInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }

package/src/database/record/relationships/has-one.js

@@ -9,4 +9,25 @@ export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelat
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+
+        if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {
+          this._inverseOf = autoGeneratedBelongsToInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }

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

@@ -3,16 +3,24 @@ import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
   async validate({model, attributeName}) {
+    const modelClass = model.constructor
+    const connection = modelClass.connection()
+    const tableName = modelClass._getTable().getName()
     const attributeValue = model.readAttribute(attributeName)
     const attributeNameUnderscore = inflection.underscore(attributeName)
     const whereArgs = {}
 
     whereArgs[attributeNameUnderscore] = attributeValue
 
-    const existingRecord = await model.constructor
-      .select(model.constructor.primaryKey())
+    let existingRecordQuery = model.constructor
+      .select(modelClass.primaryKey())
       .where(whereArgs)
-      .first()
+
+    if (model.isPersisted()) {
+      existingRecordQuery.where(`${connection.quoteTable(tableName)}.${connection.quoteColumn(modelClass.primaryKey())} != ${connection.quote(model.id())}`)
+    }
+
+    const existingRecord = await existingRecordQuery.first()
 
     if (existingRecord) {
       if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []

package/src/http-server/client/index.js

@@ -92,7 +92,9 @@ export default class VeoliciousHttpServerClient {
       response.addHeader("Connection", "Close")
     }
 
-    response.addHeader("Content-Length", response.body.length)
+    const textEncoded = new TextEncoder().encode(body)
+
+    response.addHeader("Content-Length", textEncoded.length)
     response.addHeader("Date", date.toUTCString())
     response.addHeader("Server", "Velocious")