velocious 1.0.65 → 1.0.67

package/README.md

@@ -37,6 +37,31 @@ Task.validates("name", {presence: true, uniqueness: true})
 export default Task
 ```
 
+## Preloading relationships
+
+```js
+const tasks = await Task.preload({project: {translations: true}}).toArray()
+const projectNames = tasks.map((task) => task.project().name())
+```
+
+## Load a relationship after init
+
+```js
+const task = await Task.find(5)
+
+await task.loadProject()
+
+const projects = task.project()
+```
+
+```js
+const project = await Project.find(4)
+
+await project.loadTasks()
+
+const tasks = project.tasks().loaded()
+```
+
 # Migrations
 
 Make a new migration from a template like this:

package/package.json

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

package/run-tests.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
-VELOCIOUS_TEST_DIR=/home/dev/Development/velocious/spec cd spec/dummy && npx velocious test
+cd spec/dummy && VELOCIOUS_TEST_DIR=/home/dev/Development/velocious/spec 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/instance-relationships/belongs-to-relationship-spec.js

@@ -0,0 +1,21 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import Task from "../../../dummy/src/models/task.js"
+
+describe("Record - instance relationships - belongs to relationship", () => {
+  it("loads a relationship", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create()
+      const task = await Task.create({name: "Test task", project})
+      const foundTask = await Task.find(task.id())
+      const projectInstanceRelationship = foundTask.getRelationshipByName("project")
+
+      expect(projectInstanceRelationship.isLoaded()).toBeFalse()
+
+      await foundTask.loadProject()
+
+      expect(projectInstanceRelationship.isLoaded()).toBeTrue()
+      expect(foundTask.project().id()).toEqual(project.id())
+    })
+  })
+})

package/spec/database/record/instance-relationships/has-many-relationship-spec.js

@@ -0,0 +1,24 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import Task from "../../../dummy/src/models/task.js"
+
+describe("Record - instance relationships - has many relationship", () => {
+  it("loads a relationship", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create()
+      const task = await Task.create({name: "Test task", project})
+      const foundProject = await Project.find(project.id())
+      const tasksInstanceRelationship = foundProject.getRelationshipByName("tasks")
+
+      expect(tasksInstanceRelationship.isLoaded()).toBeFalse()
+
+      await foundProject.loadTasks()
+
+      expect(tasksInstanceRelationship.isLoaded()).toBeTrue()
+
+      const taskIDs = foundProject.tasks().loaded().map((task) => task.id())
+
+      expect(taskIDs).toEqual([task.id()])
+    })
+  })
+})

package/spec/database/record/instance-relationships/has-one-relationship-spec.js

@@ -0,0 +1,24 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import ProjectDetail from "../../../dummy/src/models/project-detail.js"
+
+describe("Record - instance relationships - has one relationship", () => {
+  it("loads a relationship", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create()
+      const projectDetail = await ProjectDetail.create({note: "Test project", project})
+      const foundProject = await Project.find(project.id())
+      const projectDetailInstanceRelationship = foundProject.getRelationshipByName("projectDetail")
+
+      expect(projectDetailInstanceRelationship.isLoaded()).toBeFalse()
+
+      await foundProject.loadProjectDetail()
+
+      expect(projectDetailInstanceRelationship.isLoaded()).toBeTrue()
+
+      const projectsLoadedProjectDetail = foundProject.projectDetail()
+
+      expect(projectsLoadedProjectDetail.id()).toEqual(projectDetail.id())
+    })
+  })
+})

package/spec/database/record/preloader/belongs-to-spec.js

@@ -0,0 +1,15 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import User from "../../../dummy/src/models/user.js"
+
+describe("Record - preloader - belongs to", () => {
+  it("loads with custom primary key and foreign key", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create({creating_user_reference: "User-65"})
+      const user = await User.create({email: "user@example.com", encrypted_password: "password", reference: "User-65"})
+      const foundProject = await Project.preload({creatingUser: true}).find(project.id())
+
+      expect(foundProject.creatingUser().id()).toEqual(user.id())
+    })
+  })
+})

package/spec/database/record/preloader/has-many-spec.js

@@ -0,0 +1,29 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import User from "../../../dummy/src/models/user.js"
+
+describe("Record - preloader - has many", () => {
+  it("loads with custom primary key and foreign key", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create({creating_user_reference: "User-65"})
+      const user = await User.create({email: "user@example.com", encrypted_password: "password", reference: "User-65"})
+      const foundUser = await User.preload({createdProjects: true}).find(user.id())
+      const createdProjectsIDs = foundUser.createdProjects().loaded().map((createdProject) => createdProject.id())
+
+      expect(createdProjectsIDs).toEqual([project.id()])
+    })
+  })
+
+  it("preloads an empty array if nothing is found", async () => {
+    await Dummy.run(async () => {
+      // Differenre reference because nothing should be found as a kind of smoke test
+      await Project.create({creating_user_reference: "User-69"})
+
+      const user = await User.create({email: "user@example.com", encrypted_password: "password", reference: "User-65"})
+      const foundUser = await User.preload({createdProjects: true}).find(user.id())
+      const createdProjectsIDs = foundUser.createdProjects().loaded().map((createdProject) => createdProject.id())
+
+      expect(createdProjectsIDs).toEqual([])
+    })
+  })
+})

package/spec/database/record/preloader/has-one-spec.js

@@ -0,0 +1,15 @@
+import Dummy from "../../../dummy/index.js"
+import Project from "../../../dummy/src/models/project.js"
+import User from "../../../dummy/src/models/user.js"
+
+describe("Record - preloader - has one", () => {
+  it("loads with custom primary key and foreign key", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create({creating_user_reference: "User-65"})
+      const user = await User.create({email: "user@example.com", encrypted_password: "password", reference: "User-65"})
+      const foundUser = await User.preload({createdProject: true}).find(user.id())
+
+      expect(foundUser.createdProject().id()).toEqual([project.id()])
+    })
+  })
+})

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

@@ -75,6 +75,30 @@ describe("Record - query", () => {
     })
   })
 
+  it("finds the record with joins and where hashes", async () => {
+    await Dummy.run(async () => {
+      const project1 = await Project.create({name: "Test project 1"})
+      const project2 = await Project.create({name: "Test project 2"})
+
+      for (let i = 0; i < 5; i++) {
+        await Task.create({name: `Task 1-${i}`, project: project1})
+        await Task.create({name: `Task 2-${i}`, project: project2})
+      }
+
+      const tasks = await Task
+        .joins({project: {translations: true}})
+        .where({tasks: {name: "Task 2-2"}, project_translations: {name: "Test project 2"}})
+        .preload({project: {translations: true}})
+        .toArray()
+
+      const task = tasks[0]
+
+      expect(tasks.length).toEqual(1)
+      expect(task.name()).toEqual("Task 2-2")
+      expect(task.project().name()).toEqual("Test project 2")
+    })
+  })
+
   it("counts the records", async () => {
     await Dummy.run(async () => {
       const taskIDs = []

package/spec/dummy/src/database/migrations/20230728075328-create-projects.js

@@ -2,8 +2,9 @@ import Migration from "../../../../../src/database/migration/index.js"
 
 export default class CreateProjects extends Migration {
   async change() {
-    await this.createTable("projects", (table) => {
-      table.timestamps()
+    await this.createTable("projects", (t) => {
+      t.string("creating_user_reference")
+      t.timestamps()
     })
   }
 }

package/spec/dummy/src/database/migrations/20250912183605-create-users.js

@@ -5,6 +5,7 @@ export default class CreateUsers extends Migration {
     await this.createTable("users", (t) => {
       t.string("email", {index: {unique: true}, null: false})
       t.string("encrypted_password", {null: false})
+      t.string("reference")
       t.timestamps()
     })
   }

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

@@ -0,0 +1,8 @@
+import DatabaseRecord from "../../../../src/database/record/index.js"
+
+class Account extends DatabaseRecord {
+}
+
+Account.setDatabaseIdentifier("mssql")
+
+export default Account

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

@@ -3,6 +3,7 @@ import DatabaseRecord from "../../../../src/database/record/index.js"
 class Project extends DatabaseRecord {
 }
 
+Project.belongsTo("creatingUser", {className: "User", foreignKey: "creating_user_reference", primaryKey: "reference"})
 Project.hasMany("tasks")
 Project.hasOne("projectDetail")
 Project.translates("name")

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

@@ -4,7 +4,10 @@ import UserModule from "../../../../src/database/record/user-module.js"
 class User extends Record {
 }
 
+User.hasOne("createdProject", {className: "Project", foreignKey: "creating_user_reference", primaryKey: "reference"})
+
 User.hasMany("authenticationTokens" , {dependent: "destroy"})
+User.hasMany("createdProjects", {className: "Project", foreignKey: "creating_user_reference", primaryKey: "reference"})
 
 const userModule = new UserModule({
   secretKey: "02e383b7-aad1-437c-b1e1-17c0240ad851"

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

@@ -15,6 +15,8 @@ export default class VelociousDatabaseInitializerFromRequireContext {
 
       const modelClass = modelClassImport.default
 
+      if (!modelClass) throw new Error(`Model wasn't exported from: ${fileName}`)
+
       await modelClass.initializeRecord({configuration})
 
       if (await modelClass.hasTranslationsTable()) {

package/src/database/query/preloader/belongs-to.js

@@ -1,4 +1,3 @@
-import * as inflection from "inflection"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderBelongsTo {
@@ -11,17 +10,12 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
 
   async run() {
     const foreignKeyValues = []
-    const modelsById = {}
     const foreignKey = this.relationship.getForeignKey()
-    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
-    const preloadCollections = {}
 
     for (const model of this.models) {
-      const foreignKeyValue = model[foreignKeyCamelized]()
+      const foreignKeyValue = model.readColumn(foreignKey)
 
-      preloadCollections[model.id()] = []
-      foreignKeyValues.push(foreignKeyValue)
-      modelsById[model.id()] = model
+      if (!foreignKeyValues.includes(foreignKeyValue)) foreignKeyValues.push(foreignKeyValue)
     }
 
     const whereArgs = {}
@@ -34,12 +28,14 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
     const targetModelsById = {}
 
     for (const targetModel of targetModels) {
-      targetModelsById[targetModel.id()] = targetModel
+      const primaryKeyValue = targetModel.readColumn(this.relationship.getPrimaryKey())
+
+      targetModelsById[primaryKeyValue] = targetModel
     }
 
     // Set the target preloaded models on the given models
     for (const model of this.models) {
-      const foreignKeyValue = model[foreignKeyCamelized]()
+      const foreignKeyValue = model.readColumn(foreignKey)
       const targetModel = targetModelsById[foreignKeyValue]
       const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
 

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

@@ -1,4 +1,3 @@
-import * as inflection from "inflection"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderHasMany {
@@ -10,43 +9,50 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
   }
 
   async run() {
-    const modelIds = []
-    const modelsById = {}
+    const modelsPrimaryKeyValues = []
+    const modelsByPrimaryKeyValue = {}
     const foreignKey = this.relationship.getForeignKey()
-    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const primaryKey = this.relationship.getPrimaryKey()
     const preloadCollections = {}
 
     for (const model of this.models) {
-      preloadCollections[model.id()] = []
-      modelIds.push(model.id())
+      const primaryKeyValue = model.readColumn(primaryKey)
 
-      if (!(model.id in modelsById)) modelsById[model.id()] = []
+      preloadCollections[primaryKeyValue] = []
 
-      modelsById[model.id()].push(model)
+      if (!modelsPrimaryKeyValues.includes(primaryKeyValue)) modelsPrimaryKeyValues.push(primaryKeyValue)
+      if (!(primaryKeyValue in modelsByPrimaryKeyValue)) modelsByPrimaryKeyValue[primaryKeyValue] = []
+
+      modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
     const whereArgs = {}
 
-    whereArgs[foreignKey] = modelIds
+    whereArgs[foreignKey] = modelsPrimaryKeyValues
 
     // Load target models to be preloaded on the given models
     const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
 
     for (const targetModel of targetModels) {
-      const foreignKeyValue = targetModel[foreignKeyCamelized]()
+      const foreignKeyValue = targetModel.readColumn(foreignKey)
 
       preloadCollections[foreignKeyValue].push(targetModel)
     }
 
     // Set the target preloaded models on the given models
-    for (const modelId in preloadCollections) {
-      const preloadedCollection = preloadCollections[modelId]
+    for (const modelValue in preloadCollections) {
+      const preloadedCollection = preloadCollections[modelValue]
 
-      for (const model of modelsById[modelId]) {
+      for (const model of modelsByPrimaryKeyValue[modelValue]) {
         const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
 
+        if (preloadedCollection.length == 0) {
+          modelRelationship.setLoaded([])
+        } else {
+          modelRelationship.addToLoaded(preloadedCollection)
+        }
+
         modelRelationship.setPreloaded(true)
-        modelRelationship.addToLoaded(preloadedCollection)
       }
     }
 

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

@@ -1,4 +1,3 @@
-import * as inflection from "inflection"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderHasOne {
@@ -10,39 +9,41 @@ export default class VelociousDatabaseQueryPreloaderHasOne {
   }
 
   async run() {
-    const modelIds = []
-    const modelsById = {}
+    const modelsPrimaryKeyValues = []
+    const modelsByPrimaryKeyValue = {}
     const foreignKey = this.relationship.getForeignKey()
-    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const primaryKey = this.relationship.getPrimaryKey()
     const preloadCollections = {}
 
     for (const model of this.models) {
-      preloadCollections[model.id()] = null
-      modelIds.push(model.id())
+      const primaryKeyValue = model.readColumn(primaryKey)
 
-      if (!(model.id in modelsById)) modelsById[model.id()] = []
+      preloadCollections[primaryKeyValue] = null
 
-      modelsById[model.id()].push(model)
+      if (!modelsPrimaryKeyValues.includes(primaryKeyValue)) modelsPrimaryKeyValues.push(primaryKeyValue)
+      if (!(primaryKeyValue in modelsByPrimaryKeyValue)) modelsByPrimaryKeyValue[primaryKeyValue] = []
+
+      modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
     const whereArgs = {}
 
-    whereArgs[foreignKey] = modelIds
+    whereArgs[foreignKey] = modelsPrimaryKeyValues
 
     // Load target models to be preloaded on the given models
     const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
 
     for (const targetModel of targetModels) {
-      const foreignKeyValue = targetModel[foreignKeyCamelized]()
+      const foreignKeyValue = targetModel.readColumn(foreignKey)
 
       preloadCollections[foreignKeyValue] = targetModel
     }
 
     // Set the target preloaded models on the given models
-    for (const modelId in preloadCollections) {
-      const preloadedModel = preloadCollections[modelId]
+    for (const modelValue in preloadCollections) {
+      const preloadedModel = preloadCollections[modelValue]
 
-      for (const model of modelsById[modelId]) {
+      for (const model of modelsByPrimaryKeyValue[modelValue]) {
         const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
 
         modelRelationship.setPreloaded(true)

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

@@ -8,28 +8,43 @@ export default class VelociousDatabaseQueryWhereHash extends WhereBase {
   }
 
   toSql() {
-    const options = this.getOptions()
     let sql = "("
+
+    sql += this._whereSQLFromHash(this.hash)
+    sql += ")"
+
+    return sql
+  }
+
+  _whereSQLFromHash(hash, tableName) {
+    const options = this.getOptions()
+    let sql = ""
     let index = 0
 
-    for (const whereKey in this.hash) {
-      const whereValue = this.hash[whereKey]
+    for (const whereKey in hash) {
+      const whereValue = hash[whereKey]
 
       if (index > 0) sql += " AND "
 
-      sql += `${options.quoteColumnName(whereKey)}`
-
-      if (Array.isArray(whereValue)) {
-        sql += ` IN (${whereValue.map((value) => options.quote(value)).join(", ")})`
+      if (!Array.isArray(whereValue) && typeof whereValue == "object") {
+        sql += this._whereSQLFromHash(whereValue, whereKey)
       } else {
-        sql += ` = ${options.quote(whereValue)}`
+        if (tableName) {
+          sql += `${options.quoteTableName(tableName)}.`
+        }
+
+        sql += `${options.quoteColumnName(whereKey)}`
+
+        if (Array.isArray(whereValue)) {
+          sql += ` IN (${whereValue.map((value) => options.quote(value)).join(", ")})`
+        } else {
+          sql += ` = ${options.quote(whereValue)}`
+        }
       }
 
       index++
     }
 
-    sql += ")"
-
     return sql
   }
 }

package/src/database/record/index.js

@@ -78,23 +78,40 @@ class VelociousDatabaseRecord {
     if (actualData.type == "belongsTo") {
       relationship = new BelongsToRelationship(actualData)
 
-      const buildMethodName = `build${inflection.camelize(relationshipName)}`
-      const setMethodName = `set${inflection.camelize(relationshipName)}`
-
-      this.prototype[relationshipName] = function () {
+      this.prototype[relationshipName] = function() {
         const relationship = this.getRelationshipByName(relationshipName)
 
         return relationship.loaded()
       }
 
-      this.prototype[buildMethodName] = function (attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(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
       }
 
-      this.prototype[setMethodName] = function (model) {
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
+        await this.getRelationshipByName(relationshipName).load()
+      }
+
+      this.prototype[`set${inflection.camelize(relationshipName)}`] = function(model) {
         const relationship = this.getRelationshipByName(relationshipName)
 
         relationship.setLoaded(model)
@@ -103,24 +120,39 @@ class VelociousDatabaseRecord {
     } else if (actualData.type == "hasMany") {
       relationship = new HasManyRelationship(actualData)
 
-      this.prototype[relationshipName] = function () {
+      this.prototype[relationshipName] = function() {
         return this.getRelationshipByName(relationshipName)
       }
-    } else if (actualData.type == "hasOne") {
-      const buildMethodName = `build${inflection.camelize(relationshipName)}`
 
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
+        await this.getRelationshipByName(relationshipName).load()
+      }
+    } else if (actualData.type == "hasOne") {
       relationship = new HasOneRelationship(actualData)
 
-      this.prototype[relationshipName] = function () {
+      this.prototype[relationshipName] = function() {
         return this.getRelationshipByName(relationshipName).loaded()
       }
 
-      this.prototype[buildMethodName] = function (attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(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
       }
+
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
+        await this.getRelationshipByName(relationshipName).load()
+      }
     } else {
       throw new Error(`Unknown relationship type: ${actualData.type}`)
     }
@@ -144,6 +176,10 @@ class VelociousDatabaseRecord {
     return []
   }
 
+  static getRelationshipNames() {
+    return this.getRelationships().map((relationship) => relationship.getRelationshipName())
+  }
+
   getRelationshipByName(relationshipName) {
     if (!this._instanceRelationships) this._instanceRelationships = {}
 
@@ -168,8 +204,8 @@ class VelociousDatabaseRecord {
     return this._instanceRelationships[relationshipName]
   }
 
-  static belongsTo(relationshipName) {
-    this._defineRelationship(relationshipName, {type: "belongsTo"})
+  static belongsTo(relationshipName, options) {
+    this._defineRelationship(relationshipName, Object.assign({type: "belongsTo"}, options))
   }
 
   static connection() {
@@ -219,11 +255,14 @@ class VelociousDatabaseRecord {
     return this._getConfiguration().getTranslator()(`velocious.database.record.attributes.${modelNameKey}.${attributeName}`, {defaultValue: inflection.camelize(attributeName)})
   }
 
+  static getDatabaseType() { return this._databaseType }
+
   static async initializeRecord({configuration}) {
     if (!configuration) throw new Error(`No configuration given for ${this.name}`)
 
     this._configuration = configuration
     this._configuration.registerModelClass(this)
+    this._databaseType = this.connection().getType()
 
     this._table = await this.connection().getTableByName(this.tableName())
     this._columns = await this._getTable().getColumns()
@@ -285,13 +324,13 @@ class VelociousDatabaseRecord {
         const nameCamelized = inflection.camelize(name)
         const setterMethodName = `set${nameCamelized}`
 
-        this.prototype[name] = function () {
+        this.prototype[name] = function() {
           const locale = this._getConfiguration().getLocale()
 
           return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
-        this.prototype[setterMethodName] = function (newValue) {
+        this.prototype[setterMethodName] = function(newValue) {
           const locale = this._getConfiguration().getLocale()
 
           return this._setTranslatedAttribute(name, locale, newValue)
@@ -302,11 +341,11 @@ class VelociousDatabaseRecord {
           const getterMethodNameLocalized = `${name}${localeCamelized}`
           const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
 
-          this.prototype[getterMethodNameLocalized] = function () {
+          this.prototype[getterMethodNameLocalized] = function() {
             return this._getTranslatedAttribute(name, locale)
           }
 
-          this.prototype[setterMethodNameLocalized] = function (newValue) {
+          this.prototype[setterMethodNameLocalized] = function(newValue) {
             return this._setTranslatedAttribute(name, locale, newValue)
           }
         }
@@ -425,6 +464,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       const model = instanceRelationship.loaded()
 
       if (model?.isChanged()) {
@@ -433,6 +476,7 @@ class VelociousDatabaseRecord {
         const foreignKey = instanceRelationship.getForeignKey()
 
         this.setAttribute(foreignKey, model.id())
+
         instanceRelationship.setPreloaded(true)
         instanceRelationship.setDirty(false)
 
@@ -453,6 +497,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       let loaded
 
       if (instanceRelationship.getType() == "hasOne") {
@@ -469,14 +517,16 @@ class VelociousDatabaseRecord {
 
       let useRelationship = false
 
-      for (const model of loaded) {
-        const foreignKey = instanceRelationship.getForeignKey()
+      if (loaded) {
+        for (const model of loaded) {
+          const foreignKey = instanceRelationship.getForeignKey()
 
-        model.setAttribute(foreignKey, this.id())
+          model.setAttribute(foreignKey, this.id())
 
-        if (model.isChanged()) {
-          useRelationship = true
-          continue
+          if (model.isChanged()) {
+            useRelationship = true
+            continue
+          }
         }
       }
 
@@ -488,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]
 
@@ -792,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]
 
@@ -827,7 +881,7 @@ class VelociousDatabaseRecord {
   readAttribute(attributeName) {
     const columnName = this.constructor._attributeNameToColumnName[attributeName]
 
-    if (!columnName) throw new Error(`Couldn't figure out column name for attribute: ${attributeName}`)
+    if (!columnName) throw new Error(`Couldn't figure out column name for attribute: ${attributeName} from these mappings: ${Object.keys(this.constructor._attributeNameToColumnName)}`)
 
     return this.readColumn(columnName)
   }
@@ -844,7 +898,7 @@ class VelociousDatabaseRecord {
       throw new Error(`No such attribute or not selected ${this.constructor.name}#${attributeName}`)
     }
 
-    if (column && this.constructor.connection().getType() == "sqlite") {
+    if (column && this.constructor.getDatabaseType() == "sqlite") {
       if (column.getType() == "date" || column.getType() == "datetime") {
         result = new Date(Date.parse(result))
       }
@@ -903,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)
     }
   }
@@ -929,9 +987,9 @@ class VelociousDatabaseRecord {
     }
   }
 
-  id = () => this.readAttribute(this.constructor.primaryKey())
-  isPersisted = () => !this._isNewRecord
-  isNewRecord = () => this._isNewRecord
+  id() { return this.readAttribute(this.constructor._columnNameToAttributeName[this.constructor.primaryKey()]) }
+  isPersisted() { return !this._isNewRecord }
+  isNewRecord() { return this._isNewRecord }
 
   setIsNewRecord(newIsNewRecord) {
     this._isNewRecord = newIsNewRecord

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

@@ -1,15 +1,16 @@
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
   constructor({model, relationship}) {
+    this._autoSave = null
     this._dirty = false
     this.model = model
     this.relationship = relationship
   }
 
-  setDirty(newValue) {
-    this._dirty = newValue
-  }
-
+  getAutoSave() { return this._autoSave }
+  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }
+  setDirty(newValue) { this._dirty = newValue }
   getDirty() { return this._dirty }
+  isLoaded() { return Boolean(this._loaded) }
 
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
@@ -19,15 +20,11 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     return this._loaded
   }
 
-  setLoaded(model) {
-    this._loaded = model
-  }
-
-  setPreloaded(preloadedValue) {
-    this._preloaded = preloadedValue
-  }
-
+  setLoaded(model) { this._loaded = model }
+  getPreloaded() { return this._preloaded }
+  setPreloaded(preloadedValue) { this._preloaded = preloadedValue }
   getForeignKey() { return this.getRelationship().getForeignKey() }
+  getModel() { return this.model }
   getPrimaryKey() { return this.getRelationship().getPrimaryKey() }
   getRelationship() { return this.relationship }
   getTargetModelClass() { return this.getRelationship().getTargetModelClass() }

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

@@ -1,10 +1,6 @@
 import BaseInstanceRelationship from "./base.js"
 
 export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
-  constructor(args) {
-    super(args)
-  }
-
   build(data) {
     const targetModelClass = this.getTargetModelClass()
     const newInstance = new targetModelClass(data)
@@ -14,7 +10,16 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
     return newInstance
   }
 
-  getLoadedOrNull() {
-    return this._loaded
+  getLoadedOrNull() { return this._loaded }
+
+  async load() {
+    const foreignKey = this.getForeignKey()
+    const foreignModelID = this.getModel().readColumn(foreignKey)
+    const TargetModelClass = this.getTargetModelClass()
+    const foreignModel = await TargetModelClass.find(foreignModelID)
+
+    this.setLoaded(foreignModel)
+    this.setDirty(false)
+    this.setPreloaded(true)
   }
 }

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

@@ -3,36 +3,76 @@ import BaseInstanceRelationship from "./base.js"
 export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
   constructor(args) {
     super(args)
-    this._loaded = []
+    this._loaded = null
   }
 
   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
   }
 
+  async load() {
+    const foreignKey = this.getForeignKey()
+    const primaryKey = this.getPrimaryKey()
+    const primaryModelID = this.getModel().readColumn(primaryKey)
+    const TargetModelClass = this.getTargetModelClass()
+    const whereArgs = {}
+
+    whereArgs[foreignKey] = primaryModelID
+
+    const foreignModels = await TargetModelClass.where(whereArgs).toArray()
+
+    this.setLoaded(foreignModels)
+    this.setDirty(false)
+    this.setPreloaded(true)
+  }
+
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       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) {
+        if (this._loaded === null) this._loaded = []
+
         this._loaded.push(model)
       }
     } else {
+      if (this._loaded === null) this._loaded = []
+
       this._loaded.push(models)
     }
   }
@@ -43,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

@@ -15,6 +15,22 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     return newInstance
   }
 
+  async load() {
+    const foreignKey = this.getForeignKey()
+    const primaryKey = this.getPrimaryKey()
+    const primaryModelID = this.getModel().readColumn(primaryKey)
+    const TargetModelClass = this.getTargetModelClass()
+    const whereArgs = {}
+
+    whereArgs[foreignKey] = primaryModelID
+
+    const foreignModel = await TargetModelClass.where(whereArgs).first()
+
+    this.setLoaded(foreignModel)
+    this.setDirty(false)
+    this.setPreloaded(true)
+  }
+
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
@@ -23,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}`)
@@ -33,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/http-server/worker-handler/index.js

@@ -74,11 +74,11 @@ export default class VelociousHttpServerWorker {
 
       const {clientCount, output} = digs(data, "clientCount", "output")
 
-      this.clients[clientCount].send(output)
+      this.clients[clientCount]?.send(output)
     } else if (command == "clientClose") {
       const {clientCount} = digs(data, "clientCount")
 
-      this.clients[clientCount].close()
+      this.clients[clientCount]?.close()
     } else {
       throw new Error(`Unknown command: ${command}`)
     }

package/src/testing/test-runner.js

@@ -138,8 +138,11 @@ export default class TestRunner {
 
       if (this._onlyFocussed && !testArgs.focus) continue
 
-      if (testArgs.type == "request") {
+      if (testArgs.type == "model" || testArgs.type == "request") {
         testArgs.application = await this.application()
+      }
+
+      if (testArgs.type == "request") {
         testArgs.client = await this.requestClient()
       }
 
@@ -147,7 +150,7 @@ export default class TestRunner {
 
       try {
         for (const beforeEachData of newBeforeEaches) {
-          await beforeEachData.callback({testArgs, testData})
+          await beforeEachData.callback({configuration: this.configuration, testArgs, testData})
         }
 
         await testData.function(testArgs)
@@ -167,7 +170,7 @@ export default class TestRunner {
         }
       } finally {
         for (const afterEachData of newAfterEaches) {
-          await afterEachData.callback({testArgs, testData})
+          await afterEachData.callback({configuration: this.configuration, testArgs, testData})
         }
       }
     }