velocious 1.0.65 → 1.0.66

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.66",
   "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/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())
 
         modelRelationship.setPreloaded(true)
-        modelRelationship.addToLoaded(preloadedCollection)
+
+        if (preloadedCollection.length == 0) {
+          modelRelationship.setLoaded([])
+        } else {
+          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,24 @@ 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) {
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
         const relationship = this.getRelationshipByName(relationshipName)
         const record = relationship.build(attributes)
 
         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 +104,30 @@ 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) {
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
         const relationship = this.getRelationshipByName(relationshipName)
         const record = relationship.build(attributes)
 
         return record
       }
+
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
+        await this.getRelationshipByName(relationshipName).load()
+      }
     } else {
       throw new Error(`Unknown relationship type: ${actualData.type}`)
     }
@@ -168,8 +175,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 +226,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 +295,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 +312,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)
           }
         }
@@ -469,14 +479,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
+          }
         }
       }
 
@@ -827,7 +839,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 +856,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))
       }
@@ -929,9 +941,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

@@ -5,11 +5,9 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     this.relationship = relationship
   }
 
-  setDirty(newValue) {
-    this._dirty = newValue
-  }
-
+  setDirty(newValue) { this._dirty = newValue }
   getDirty() { return this._dirty }
+  isLoaded() { return Boolean(this._loaded) }
 
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
@@ -19,15 +17,10 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     return this._loaded
   }
 
-  setLoaded(model) {
-    this._loaded = model
-  }
-
-  setPreloaded(preloadedValue) {
-    this._preloaded = preloadedValue
-  }
-
+  setLoaded(model) { this._loaded = model }
+  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)
@@ -17,4 +13,15 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
   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,18 +3,36 @@ import BaseInstanceRelationship from "./base.js"
 export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
   constructor(args) {
     super(args)
-    this._loaded = []
+    this._loaded = null
   }
 
   build(data) {
     const targetModelClass = this.getTargetModelClass()
     const newInstance = new targetModelClass(data)
 
+    if (this._loaded === null) this._loaded = []
+
     this._loaded.push(newInstance)
 
     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`)
@@ -30,6 +48,8 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
   addToLoaded(models) {
     if (Array.isArray(models)) {
       for (const model of models) {
+        if (this._loaded === null) this._loaded = []
+
         this._loaded.push(model)
       }
     } else {

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`)

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})
         }
       }
     }