velocious 1.0.59 → 1.0.61

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.59",
+  "version": "1.0.61",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",
@@ -29,7 +29,7 @@
     "diggerize": "^1.0.5",
     "ejs": "^3.1.6",
     "env-sense": "^1.0.0",
-    "epic-locks": "^1.0.3",
+    "epic-locks": "^1.0.4",
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",

package/run-tests.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+VELOCIOUS_TEST_DIR=/home/dev/Development/velocious cd spec/dummy && npx velocious test
+

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

@@ -18,7 +18,7 @@ describe("Cli - Commands - db:migrate", () => {
     await cli.configuration.ensureConnections(async (dbs) => {
       defaultDatabaseType = dbs.default.getType()
 
-      const tableNames = ["accounts", "authentication_tokens", "tasks", "project_translations", "projects", "schema_migrations", "users"]
+      const tableNames = ["accounts", "authentication_tokens", "tasks", "project_details", "project_translations", "projects", "schema_migrations", "users"]
 
       for (const tableName of tableNames) {
         await dbs.default.dropTable(tableName, {cascade: true, ifExists: true})
@@ -102,6 +102,7 @@ describe("Cli - Commands - db:migrate", () => {
         [
           "accounts",
           "authentication_tokens",
+          "project_details",
           "project_translations",
           "projects",
           "schema_migrations",
@@ -118,13 +119,15 @@ describe("Cli - Commands - db:migrate", () => {
         "20250912183605",
         "20250912183606",
         "20250915085450",
-        "20250916111330"
+        "20250916111330",
+        "20250921121002"
       ])
     } else {
       expect(tablesResult.sort()).toEqual(
         [
           "accounts",
           "authentication_tokens",
+          "project_details",
           "project_translations",
           "projects",
           "schema_migrations",
@@ -142,7 +145,8 @@ describe("Cli - Commands - db:migrate", () => {
         "20250912183605",
         "20250912183606",
         "20250915085450",
-        "20250916111330"
+        "20250916111330",
+        "20250921121002"
       ])
     }
   })

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

@@ -2,6 +2,7 @@ import Dummy from "../../dummy/index.js"
 import Project from "../../dummy/src/models/project.js"
 import Task from "../../dummy/src/models/task.js"
 import {ValidationError} from "../../../src/database/record/index.js"
+import ProjectDetail from "../../dummy/src/models/project-detail.js"
 
 describe("Record - create", () => {
   it("creates a new simple record with relationships and translations", async () => {
@@ -9,6 +10,8 @@ describe("Record - create", () => {
       const task = new Task({name: "Test task"})
       const project = task.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
 
+      project.buildProjectDetail({note: "Test note"})
+
       await task.save()
 
       expect(task.id()).not.toBeUndefined()
@@ -25,6 +28,12 @@ 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
+      const projectDetail = project.projectDetail()
+
+      expect(projectDetail.note()).toEqual("Test note")
+      expect(projectDetail.projectId()).toEqual(project.id())
     })
   })
 
@@ -53,6 +62,7 @@ describe("Record - create", () => {
       const project = new Project({name: "Test project"})
 
       project.tasks().build({name: " ", project})
+      project.buildProjectDetail({note: "Test note"})
 
       try {
         await project.save()
@@ -64,9 +74,11 @@ describe("Record - create", () => {
       }
 
       const projectsCount = await Project.count()
+      const projectDetailsCount = await ProjectDetail.count()
       const tasksCount = await Task.count()
 
       expect(projectsCount).toEqual(0)
+      expect(projectDetailsCount).toEqual(0)
       expect(tasksCount).toEqual(0)
     })
   })

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

@@ -14,6 +14,7 @@ describe("Record - find", () => {
 
       expect(foundTask.readAttribute("name")).toEqual("Test task")
       expect(foundTask.readColumn("name")).toEqual("Test task")
+      expect(foundTask.hasName()).toBeTrue()
     })
   })
 

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

@@ -8,6 +8,8 @@ describe("Record - query", () => {
       const task = new Task({name: "Test task"})
       const project = task.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
 
+      project.buildProjectDetail({note: "Test note"})
+
       await task.save()
 
       expect(task.id()).not.toBeUndefined()
@@ -20,9 +22,10 @@ describe("Record - query", () => {
       expect(project.nameDe()).toEqual("Test projekt")
       expect(project.nameEn()).toEqual("Test project")
 
-      const tasks = await Task.preload({project: {translations: true}}).toArray()
+      const tasks = await Task.preload({project: {projectDetail: true, translations: true}}).toArray()
       const newTask = tasks[0]
       const newProject = newTask.project()
+      const newProjectDetail = newProject.projectDetail()
 
       expect(newTask.id()).not.toBeUndefined()
       expect(newTask.name()).toEqual("Test task")
@@ -33,6 +36,8 @@ describe("Record - query", () => {
       expect(newProject.name()).toEqual("Test project")
       expect(newProject.nameDe()).toEqual("Test projekt")
       expect(newProject.nameEn()).toEqual("Test project")
+
+      expect(newProjectDetail.note()).toEqual("Test note")
     })
   })
 

package/spec/dummy/dummy-directory.js

@@ -1,7 +1,7 @@
 import {dirname} from "path"
 import {fileURLToPath} from "url"
 
-const dummyDirectory = () => {
+function dummyDirectory() {
   const __filename = fileURLToPath(import.meta.url)
   const __dirname = dirname(__filename)
 

package/spec/dummy/src/database/migrations/20250921121002-create-project-details.js

@@ -0,0 +1,15 @@
+import Migration from "../../../../../src/database/migration/index.js"
+
+export default class CreateProjectDetails extends Migration {
+  async up() {
+    await this.createTable("project_details", (t) => {
+      t.references("project", {foreignKey: true, null: false})
+      t.text("note")
+      t.timestamps()
+    })
+  }
+
+  async down() {
+    await this.dropTable("project_details")
+  }
+}

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

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

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

@@ -4,6 +4,7 @@ class Project extends DatabaseRecord {
 }
 
 Project.hasMany("tasks")
+Project.hasOne("projectDetail")
 Project.translates("name")
 
 export default Project

package/src/configuration.js

@@ -80,7 +80,7 @@ export default class VelociousConfiguration {
   getEnvironment() { return digg(this, "_environment") }
   setEnvironment(newEnvironment) { this._environment = newEnvironment }
 
-  getLocaleFallbacks = () => this.localeFallbacks
+  getLocaleFallbacks() { return this.localeFallbacks }
   setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks }
 
   getLocale() {
@@ -93,7 +93,7 @@ export default class VelociousConfiguration {
     }
   }
 
-  getLocales = () => digg(this, "locales")
+  getLocales() { return digg(this, "locales") }
 
   getModelClass(name) {
     const modelClass = this.modelClasses[name]
@@ -115,8 +115,8 @@ export default class VelociousConfiguration {
     this.databasePools[identifier].setCurrent()
   }
 
-  isDatabasePoolInitialized = (identifier = "default") => Boolean(this.databasePools[identifier])
-  isInitialized = () => this._isInitialized
+  isDatabasePoolInitialized(identifier = "default") { return Boolean(this.databasePools[identifier]) }
+  isInitialized() { return this._isInitialized }
 
   async initialize() {
     if (!this.isInitialized()) {

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

@@ -2,9 +2,9 @@ import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversMssqlForeignKey extends BaseForeignKey {
-  getColumnName = () => digg(this, "data", "ParentColumn")
-  getName = () => digg(this, "data", "CONSTRAINT_NAME")
-  getTableName = () => digg(this, "data", "TableName")
-  getReferencedColumnName = () => digg(this, "data", "ReferencedColumn")
-  getReferencedTableName = () => digg(this, "data", "ReferencedTable")
+  getColumnName() { return digg(this, "data", "ParentColumn") }
+  getName() { return digg(this, "data", "CONSTRAINT_NAME") }
+  getTableName() { return digg(this, "data", "TableName") }
+  getReferencedColumnName() { return digg(this, "data", "ReferencedColumn") }
+  getReferencedTableName() { return digg(this, "data", "ReferencedTable") }
 }

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

@@ -82,8 +82,8 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return dropTable.toSql()
   }
 
-  getType = () => "mssql"
-  primaryKeyType = () => "bigint"
+  getType() { return "mssql" }
+  primaryKeyType() { return "bigint" }
 
   async query(sql) {
     let result, request, tries = 0

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

@@ -16,7 +16,7 @@ export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOpt
     return this.driver.quote(string)
   }
 
-  quoteColumnName = (string) => {
+  quoteColumnName(string) {
     if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in column name: ${string}`)
 
     return `[${string}]`
@@ -29,13 +29,13 @@ export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOpt
     return `[${databaseName}]`
   }
 
-  quoteIndexName = (string) => {
+  quoteIndexName(string) {
     if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in index name: ${string}`)
 
     return `[${string}]`
   }
 
-  quoteTableName = (string) => {
+  quoteTableName(string) {
     if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in table name: ${string}`)
 
     return `[${string}]`

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

@@ -2,9 +2,9 @@ import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
-  getColumnName = () => digg(this, "data", "COLUMN_NAME")
-  getName = () => digg(this, "data", "CONSTRAINT_NAME")
-  getTableName = () => digg(this, "data", "TABLE_NAME")
-  getReferencedColumnName = () => digg(this, "data", "REFERENCED_COLUMN_NAME")
-  getReferencedTableName = () => digg(this, "data", "REFERENCED_TABLE_NAME")
+  getColumnName() { return digg(this, "data", "COLUMN_NAME") }
+  getName() { return digg(this, "data", "CONSTRAINT_NAME") }
+  getTableName() { return digg(this, "data", "TABLE_NAME") }
+  getReferencedColumnName() { return digg(this, "data", "REFERENCED_COLUMN_NAME") }
+  getReferencedTableName() { return digg(this, "data", "REFERENCED_TABLE_NAME") }
 }

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

@@ -91,8 +91,8 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return dropTable.toSql()
   }
 
-  getType = () => "mysql"
-  primaryKeyType = () => "bigint"
+  getType() { return "mysql" }
+  primaryKeyType() { return "bigint" }
 
   async query(sql) {
     try {
@@ -107,7 +107,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return new QueryParser({query}).toSql()
   }
 
-  shouldSetAutoIncrementWhenPrimaryKey = () => true
+  shouldSetAutoIncrementWhenPrimaryKey() { return true }
 
   escape(value) {
     if (!this.connection) throw new Error("Can't escape before connected")

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

@@ -2,9 +2,9 @@ import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversPgsqlForeignKey extends BaseForeignKey {
-  getColumnName = () => digg(this, "data", "column_name")
-  getName = () => digg(this, "data", "constraint_name")
-  getTableName = () => digg(this, "data", "table_name")
-  getReferencedColumnName = () => digg(this, "data", "foreign_column_name")
-  getReferencedTableName = () => digg(this, "data", "foreign_table_name")
+  getColumnName() { return digg(this, "data", "column_name") }
+  getName() { return digg(this, "data", "constraint_name") }
+  getTableName() { return digg(this, "data", "table_name") }
+  getReferencedColumnName() { return digg(this, "data", "foreign_column_name") }
+  getReferencedTableName() { return digg(this, "data", "foreign_table_name") }
 }

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

@@ -99,8 +99,8 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     return dropTable.toSql()
   }
 
-  getType = () => "pgsql"
-  primaryKeyType = () => "bigint"
+  getType() { return "pgsql" }
+  primaryKeyType() { return "bigint" }
 
   async query(sql) {
     let response
@@ -118,7 +118,7 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     return new QueryParser({query}).toSql()
   }
 
-  shouldSetAutoIncrementWhenPrimaryKey = () => true
+  shouldSetAutoIncrementWhenPrimaryKey() { return true }
 
   escape(value) {
     if (!this.connection) throw new Error("Can't escape before connected")

package/src/database/pool/async-tracked-multi-connection.js

@@ -10,7 +10,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     this.idSeq = 0
   }
 
-  checkin = (connection) => {
+  checkin(connection) {
     const id = connection.getIdSeq()
 
     if (id in this.connectionsInUse) {

package/src/database/pool/single-multi-use.js

@@ -1,7 +1,7 @@
 import BasePool from "./base.js"
 
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
-  checkin = (connection) => {
+  checkin(connection) {
     // Do nothing
   }
 

package/src/database/query/from-plain.js

@@ -6,5 +6,5 @@ export default class VelociousDatabaseQueryFromPlain extends FromBase {
     this.plain = plain
   }
 
-  toSql = () => this.plain
+  toSql() { return this.plain }
 }

package/src/database/query/index.js

@@ -71,7 +71,7 @@ export default class VelociousDatabaseQuery {
     throw new Error("count multiple stub")
   }
 
-  getOptions = () => this.driver.options()
+  getOptions() { return this.driver.options() }
 
   async destroyAll() {
     const records = await this.toArray()
@@ -255,7 +255,7 @@ export default class VelociousDatabaseQuery {
     return models
   }
 
-  toSql = () => this.driver.queryToSql(this)
+  toSql() { return this.driver.queryToSql(this) }
 
   where(where) {
     if (typeof where == "string") {

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

@@ -0,0 +1,55 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.js"
+
+export default class VelociousDatabaseQueryPreloaderHasOne {
+  constructor({models, relationship, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.models = models
+    this.relationship = relationship
+  }
+
+  async run() {
+    const modelIds = []
+    const modelsById = {}
+    const foreignKey = this.relationship.getForeignKey()
+    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const preloadCollections = {}
+
+    for (const model of this.models) {
+      preloadCollections[model.id()] = null
+      modelIds.push(model.id())
+
+      if (!(model.id in modelsById)) modelsById[model.id()] = []
+
+      modelsById[model.id()].push(model)
+    }
+
+    const whereArgs = {}
+
+    whereArgs[foreignKey] = modelIds
+
+    // 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]()
+
+      preloadCollections[foreignKeyValue] = targetModel
+    }
+
+    // Set the target preloaded models on the given models
+    for (const modelId in preloadCollections) {
+      const preloadedModel = preloadCollections[modelId]
+
+      for (const model of modelsById[modelId]) {
+        const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
+
+        modelRelationship.setPreloaded(true)
+        modelRelationship.setLoaded(preloadedModel)
+      }
+    }
+
+    return targetModels
+  }
+}

package/src/database/query/preloader.js

@@ -1,5 +1,6 @@
 import BelongsToPreloader from "./preloader/belongs-to.js"
 import HasManyPreloader from "./preloader/has-many.js"
+import HasOnePreloader from "./preloader/has-one.js"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloader {
@@ -24,6 +25,10 @@ export default class VelociousDatabaseQueryPreloader {
         const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: relationship})
 
         targetModels = await hasManyPreloader.run()
+      } else if (relationship.getType() == "hasOne") {
+        const hasOnePreloader = new HasOnePreloader({models: this.models, relationship: relationship})
+
+        targetModels = await hasOnePreloader.run()
       } else {
         throw new Error(`Unknown relationship type: ${relationship.getType()}`)
       }

package/src/database/record/index.js

@@ -5,6 +5,8 @@ import FromTable from "../query/from-table.js"
 import Handler from "../handler.js"
 import HasManyRelationship from "./relationships/has-many.js"
 import HasManyInstanceRelationship from "./instance-relationships/has-many.js"
+import HasOneRelationship from "./relationships/has-one.js"
+import HasOneInstanceRelationship from "./instance-relationships/has-one.js"
 import * as inflection from "inflection"
 import Query from "../query/index.js"
 import ValidatorsPresence from "./validators/presence.js"
@@ -104,6 +106,21 @@ class VelociousDatabaseRecord {
       this.prototype[relationshipName] = function () {
         return this.getRelationshipByName(relationshipName)
       }
+    } else if (actualData.type == "hasOne") {
+      const buildMethodName = `build${inflection.camelize(relationshipName)}`
+
+      relationship = new HasOneRelationship(actualData)
+
+      this.prototype[relationshipName] = function () {
+        return this.getRelationshipByName(relationshipName).loaded()
+      }
+
+      this.prototype[buildMethodName] = function (attributes) {
+        const relationship = this.getRelationshipByName(relationshipName)
+        const record = relationship.build(attributes)
+
+        return record
+      }
     } else {
       throw new Error(`Unknown relationship type: ${actualData.type}`)
     }
@@ -132,14 +149,17 @@ class VelociousDatabaseRecord {
 
     if (!(relationshipName in this._instanceRelationships)) {
       const modelClassRelationship = this.constructor.getRelationshipByName(relationshipName)
+      const relationshipType = modelClassRelationship.getType()
       let instanceRelationship
 
-      if (modelClassRelationship.getType() == "belongsTo") {
+      if (relationshipType == "belongsTo") {
         instanceRelationship = new BelongsToInstanceRelationship({model: this, relationship: modelClassRelationship})
-      } else if (modelClassRelationship.getType() == "hasMany") {
+      } else if (relationshipType == "hasMany") {
         instanceRelationship = new HasManyInstanceRelationship({model: this, relationship: modelClassRelationship})
+      } else if (relationshipType == "hasOne") {
+        instanceRelationship = new HasOneInstanceRelationship({model: this, relationship: modelClassRelationship})
       } else {
-        throw new Error(`Unknown relationship type: ${modelClassRelationship.getType()}`)
+        throw new Error(`Unknown relationship type: ${relationshipType}`)
       }
 
       this._instanceRelationships[relationshipName] = instanceRelationship
@@ -189,6 +209,10 @@ class VelociousDatabaseRecord {
     return this._defineRelationship(relationshipName, Object.assign({type: "hasMany"}, options))
   }
 
+  static hasOne(relationshipName, options = {}) {
+    return this._defineRelationship(relationshipName, Object.assign({type: "hasOne"}, options))
+  }
+
   static humanAttributeName(attributeName) {
     const modelNameKey = inflection.underscore(this.constructor.name)
 
@@ -212,18 +236,31 @@ class VelociousDatabaseRecord {
 
       const camelizedColumnName = inflection.camelize(column.getName(), true)
       const camelizedColumnNameBigFirst = inflection.camelize(column.getName())
-      const setterMethodName = `set${camelizedColumnNameBigFirst}`
 
       this._attributeNameToColumnName[camelizedColumnName] = column.getName()
       this._columnNameToAttributeName[column.getName()] = camelizedColumnName
 
-      this.prototype[camelizedColumnName] = function () {
+      this.prototype[camelizedColumnName] = function() {
         return this.readAttribute(camelizedColumnName)
       }
 
-      this.prototype[setterMethodName] = function (newValue) {
+      this.prototype[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
         return this._setColumnAttribute(camelizedColumnName, newValue)
       }
+
+      this.prototype[`has${camelizedColumnNameBigFirst}`] = function() {
+        let value = this[camelizedColumnName]()
+
+        if (typeof value == "string") {
+          value = value.trim()
+        }
+
+        if (value) {
+          return true
+        }
+
+        return false
+      }
     }
 
     await this._defineTranslationMethods()
@@ -361,7 +398,7 @@ class VelociousDatabaseRecord {
 
       if (this.isPersisted()) {
         // If any has-many-relationships will be saved, then updated-at should still be set on this record.
-        const autoSaveHasManyrelationships = this._autoSaveHasManyRelationshipsToSave()
+        const autoSaveHasManyrelationships = this._autoSaveHasManyAndHasOneRelationshipsToSave()
 
         if (this._hasChanges() || savedCount > 0 || autoSaveHasManyrelationships.length > 0) {
           result = await this._updateRecordWithChanges()
@@ -370,7 +407,7 @@ class VelociousDatabaseRecord {
         result = await this._createNewRecord()
       }
 
-      await this._autoSaveHasManyRelationships({isNewRecord})
+      await this._autoSaveHasManyAndHasOneRelationships({isNewRecord})
     })
 
     return result
@@ -404,19 +441,29 @@ class VelociousDatabaseRecord {
     return {savedCount}
   }
 
-  _autoSaveHasManyRelationshipsToSave() {
+  _autoSaveHasManyAndHasOneRelationshipsToSave() {
     const relationships = []
 
     for (const relationshipName in this._instanceRelationships) {
       const instanceRelationship = this._instanceRelationships[relationshipName]
 
-      if (instanceRelationship.getType() != "hasMany") {
+      if (instanceRelationship.getType() != "hasMany" && instanceRelationship.getType() != "hasOne") {
         continue
       }
 
-      let loaded = instanceRelationship._loaded
+      let loaded
 
-      if (!Array.isArray(loaded)) loaded = [loaded]
+      if (instanceRelationship.getType() == "hasOne") {
+        const hasOneLoaded = instanceRelationship.getLoadedOrNull()
+
+        if (hasOneLoaded) {
+          loaded = [hasOneLoaded]
+        } else {
+          continue
+        }
+      } else {
+        loaded = instanceRelationship.getLoadedOrNull()
+      }
 
       let useRelationship = false
 
@@ -437,8 +484,8 @@ class VelociousDatabaseRecord {
     return relationships
   }
 
-  async _autoSaveHasManyRelationships({isNewRecord}) {
-    for (const instanceRelationship of this._autoSaveHasManyRelationshipsToSave()) {
+  async _autoSaveHasManyAndHasOneRelationships({isNewRecord}) {
+    for (const instanceRelationship of this._autoSaveHasManyAndHasOneRelationshipsToSave()) {
       let loaded = instanceRelationship._loaded
 
       if (!Array.isArray(loaded)) loaded = [loaded]

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

@@ -9,7 +9,7 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     this._dirty = newValue
   }
 
-  getDirty = () => this._dirty
+  getDirty() { return this._dirty }
 
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
@@ -27,9 +27,9 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     this._preloaded = preloadedValue
   }
 
-  getForeignKey = () => this.getRelationship().getForeignKey()
-  getPrimaryKey = () => this.getRelationship().getPrimaryKey()
-  getRelationship = () => this.relationship
-  getTargetModelClass = () => this.getRelationship().getTargetModelClass()
-  getType = () => this.getRelationship().getType()
+  getForeignKey() { return this.getRelationship().getForeignKey() }
+  getPrimaryKey() { return this.getRelationship().getPrimaryKey() }
+  getRelationship() { return this.relationship }
+  getTargetModelClass() { return this.getRelationship().getTargetModelClass() }
+  getType() { return this.getRelationship().getType() }
 }

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

@@ -14,7 +14,7 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
     return newInstance
   }
 
-  setLoaded(models) {
-    this._loaded = models
+  getLoadedOrNull() {
+    return this._loaded
   }
 }

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

@@ -23,6 +23,10 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     return this._loaded
   }
 
+  getLoadedOrNull() {
+    return this._loaded
+  }
+
   addToLoaded(models) {
     if (Array.isArray(models)) {
       for (const model of models) {

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

@@ -0,0 +1,37 @@
+import BaseInstanceRelationship from "./base.js"
+
+export default class VelociousDatabaseRecordHasOneInstanceRelationship extends BaseInstanceRelationship {
+  constructor(args) {
+    super(args)
+    this._loaded = null
+  }
+
+  build(data) {
+    const targetModelClass = this.getTargetModelClass()
+    const newInstance = new targetModelClass(data)
+
+    this._loaded = newInstance
+
+    return newInstance
+  }
+
+  loaded() {
+    if (!this._preloaded && this.model.isPersisted()) {
+      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
+    }
+
+    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}`)
+
+    this._loaded = model
+  }
+
+  getTargetModelClass = () => this.relationship.getTargetModelClass()
+}

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

@@ -1,8 +1,9 @@
+import restArgsError from "../../../utils/rest-args-error.js"
+
 export default class VelociousDatabaseRecordBaseRelationship {
-  constructor({className, configuration, dependent, foreignKey, klass, modelClass, relationshipName, through, type, ...restArgs}) {
-    const restArgsKeys = Object.keys(restArgs)
+  constructor({className, configuration, dependent, foreignKey, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) {
+    restArgsError(restArgs)
 
-    if (restArgsKeys.length > 0) throw new Error(`Unknown args given: ${restArgsKeys.join(", ")}`)
     if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
     if (!className && !klass) throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`)
 
@@ -12,15 +13,16 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this.foreignKey = foreignKey
     this.klass = klass
     this.modelClass = modelClass
+    this._primaryKey = primaryKey
     this.relationshipName = relationshipName
     this.through = through
     this.type = type
   }
 
-  getDependent = () => this._dependent
-  getRelationshipName = () => this.relationshipName
-  getPrimaryKey = () => "id" // TODO: Support custom given primary key
-  getType = () => this.type
+  getDependent() { return this._dependent }
+  getRelationshipName() { return this.relationshipName }
+  getPrimaryKey() { return this._primaryKey }
+  getType() { return this.type }
 
   getTargetModelClass() {
     if (this.className) {

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

@@ -0,0 +1,12 @@
+import BaseRelationship from "./base.js"
+import * as inflection from "inflection"
+
+export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelationship {
+  getForeignKey() {
+    if (!this.foreignKey) {
+      this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`
+    }
+
+    return this.foreignKey
+  }
+}