velocious 1.0.98 → 1.0.100

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.98",
+  "version": "1.0.100",
   "main": "index.js",
   "scripts": {
     "lint": "eslint",

package/spec/database/migration/column-exists-spec.js

@@ -0,0 +1,28 @@
+// @ts-check
+
+import Dummy from "../../dummy/index.js"
+import dummyConfiguration from "../../dummy/src/config/configuration.js"
+import {describe, it} from "../../../src/testing/test.js"
+import Migration from "../../../src/database/migration/index.js"
+
+describe("database - migration", () => {
+  it("checks if a column exists", async () => {
+    await Dummy.run(async () => {
+      await dummyConfiguration.ensureConnections(async (dbs) => {
+        const migration = new Migration({
+          configuration: dummyConfiguration,
+          databaseIdentifier: "default",
+          db: dbs.default
+        })
+
+        const projectsIDExists = await migration.columnExists("projects", "id")
+
+        expect(projectsIDExists).toBe(true)
+
+        const projectsSomeNonExistingColumnExists = await migration.columnExists("projects", "some_non_existing_column")
+
+        expect(projectsSomeNonExistingColumnExists).toBe(false)
+      })
+    })
+  })
+})

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

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Dummy from "../../dummy/index.js"
 import Project from "../../dummy/src/models/project.js"
 import Task from "../../dummy/src/models/task.js"
@@ -51,7 +53,7 @@ describe("Record - create", () => {
 
       expect(tasksRelationship.getPreloaded()).toBeTrue()
 
-      const projectTasksIDs = project.tasks().loaded().map((task) => task.id())
+      const projectTasksIDs = project.tasksLoaded().map((task) => task.id())
 
       expect(projectTasksIDs).toEqual([task.id()])
     })
@@ -65,17 +67,17 @@ describe("Record - create", () => {
 
     await project.save()
 
-    const tasks = project.tasks().loaded()
+    const tasks = project.tasksLoaded()
     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(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())
+    expect(task2?.projectId()).toEqual(project.id())
+    expect(task2?.project().id()).toEqual(project.id())
   })
 
   it("creates a new task with an existing project", async () => {
@@ -111,7 +113,12 @@ describe("Record - create", () => {
         throw new Error("Didnt expect to succeed")
       } catch (error) {
         expect(error).toBeInstanceOf(ValidationError)
-        expect(error.message).toEqual("Name can't be blank")
+
+        if (error instanceof Error) {
+          expect(error.message).toEqual("Name can't be blank")
+        } else {
+          throw new Error(`Expected error to be an instance of Error: ${typeof error}`)
+        }
       }
 
       const projectsCount = await Project.count()

package/spec/database/transactions-spec.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Dummy from "../dummy/index.js"
 import dummyConfiguration from "../dummy/src/config/configuration.js"
 import Project from "../dummy/src/models/project.js"
@@ -26,7 +28,12 @@ describe("database - transactions", () => {
               })
             } catch (error) {
               expect(error).toBeInstanceOf(ValidationError)
-              expect(error.message).toEqual("Name can't be blank")
+
+              if (error instanceof Error) {
+                expect(error.message).toEqual("Name can't be blank")
+              } else {
+                throw new Error(`'error' wasn't an 'Error': ${typeof error}`)
+              }
             }
           })
         })

package/spec/dummy/src/model-bases/account.js

@@ -0,0 +1,67 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class AccountBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {string | null}
+   */
+  name() { return this.readAttribute("name") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setName(newValue) { return this._setColumnAttribute("name", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasName() { return this._hasAttribute(this.name()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+}

package/spec/dummy/src/model-bases/authentication-token.js

@@ -0,0 +1,109 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class AuthenticationTokenBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {string | null}
+   */
+  userToken() { return this.readAttribute("userToken") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setUserToken(newValue) { return this._setColumnAttribute("userToken", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUserToken() { return this._hasAttribute(this.userToken()) }
+
+  /**
+   * @returns {number | null}
+   */
+  userId() { return this.readAttribute("userId") }
+
+  /**
+   * @param {number | null} newValue
+   * @returns {void}
+   */
+  setUserId(newValue) { return this._setColumnAttribute("userId", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUserId() { return this._hasAttribute(this.userId()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @interface
+   * @returns {import("../models/user.js").default}
+   */
+  user() { return this.getRelationshipByName("user").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/user.js").default}
+   */
+  buildUser(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadUser() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/user.js").default} newModel
+   * @returns {void}
+   */
+  setUser(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

package/spec/dummy/src/model-bases/project-detail.js

@@ -0,0 +1,102 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class ProjectDetailBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {number}
+   */
+  projectId() { return this.readAttribute("projectId") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setProjectId(newValue) { return this._setColumnAttribute("projectId", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasProjectId() { return this._hasAttribute(this.projectId()) }
+
+  note() { return this.readAttribute("note") }
+
+  setNote(newValue) { return this._setColumnAttribute("note", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasNote() { return this._hasAttribute(this.note()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @interface
+   * @returns {import("../models/project.js").default}
+   */
+  project() { return this.getRelationshipByName("project").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/project.js").default}
+   */
+  buildProject(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadProject() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/project.js").default} newModel
+   * @returns {void}
+   */
+  setProject(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

package/spec/dummy/src/model-bases/project-translation.js

@@ -0,0 +1,125 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class ProjectTranslationBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {number}
+   */
+  projectId() { return this.readAttribute("projectId") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setProjectId(newValue) { return this._setColumnAttribute("projectId", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasProjectId() { return this._hasAttribute(this.projectId()) }
+
+  /**
+   * @returns {string}
+   */
+  locale() { return this.readAttribute("locale") }
+
+  /**
+   * @param {string} newValue
+   * @returns {void}
+   */
+  setLocale(newValue) { return this._setColumnAttribute("locale", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasLocale() { return this._hasAttribute(this.locale()) }
+
+  /**
+   * @returns {string | null}
+   */
+  name() { return this.readAttribute("name") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setName(newValue) { return this._setColumnAttribute("name", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasName() { return this._hasAttribute(this.name()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @interface
+   * @returns {import("../models/project.js").default}
+   */
+  project() { return this.getRelationshipByName("project").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/project.js").default}
+   */
+  buildProject(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadProject() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/project.js").default} newModel
+   * @returns {void}
+   */
+  setProject(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

package/spec/dummy/src/model-bases/project.js

@@ -0,0 +1,184 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class ProjectBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {string | null}
+   */
+  creatingUserReference() { return this.readAttribute("creatingUserReference") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setCreatingUserReference(newValue) { return this._setColumnAttribute("creatingUserReference", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatingUserReference() { return this._hasAttribute(this.creatingUserReference()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @returns {string | null}
+   */
+  name() { return this._getTranslatedAttributeWithFallback("name", this._getConfiguration().getLocale()) }
+
+  /**
+   * @returns {string | null}
+   */
+  nameDe() { return this._getTranslatedAttributeWithFallback("name", "de") }
+
+  /**
+   * @returns {string | null}
+   */
+  nameEn() { return this._getTranslatedAttributeWithFallback("name", "en") }
+
+  /**
+   * @interface
+   * @returns {import("../models/user.js").default}
+   */
+  creatingUser() { return this.getRelationshipByName("creatingUser").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/user.js").default}
+   */
+  buildCreatingUser(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadCreatingUser() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/user.js").default} newModel
+   * @returns {void}
+   */
+  setCreatingUser(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {import("velocious/src/database/query/index.js").default<import("../models/task.js").default>}
+   */
+  tasks() { return this.getRelationshipByName("tasks") }
+
+  /**
+   * @interface
+   * @returns {Array<import("../models/task.js").default>}
+   */
+  tasksLoaded() { return this.getRelationshipByName("tasks").loaded() }
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadTasks() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {Array<import("../models/task.js").default>} newModels
+   * @returns {void}
+   */
+  setTasks(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {import("../models/project-detail.js").default}
+   */
+  projectDetail() { return this.getRelationshipByName("projectDetail").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/project-detail.js").default}
+   */
+  buildProjectDetail(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadProjectDetail() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/project-detail.js").default} newModel
+   * @returns {void}
+   */
+  setProjectDetail(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {import("velocious/src/database/query/index.js").default<import("velocious/src/database/record/index.js").default>}
+   */
+  translations() { return this.getRelationshipByName("translations") }
+
+  /**
+   * @interface
+   * @returns {Array<import("velocious/src/database/record/index.js").default>}
+   */
+  translationsLoaded() { return this.getRelationshipByName("translations").loaded() }
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadTranslations() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {Array<import("velocious/src/database/record/index.js").default>} newModels
+   * @returns {void}
+   */
+  setTranslations(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

package/spec/dummy/src/model-bases/task.js

@@ -0,0 +1,118 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class TaskBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {number}
+   */
+  projectId() { return this.readAttribute("projectId") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setProjectId(newValue) { return this._setColumnAttribute("projectId", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasProjectId() { return this._hasAttribute(this.projectId()) }
+
+  /**
+   * @returns {string | null}
+   */
+  name() { return this.readAttribute("name") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setName(newValue) { return this._setColumnAttribute("name", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasName() { return this._hasAttribute(this.name()) }
+
+  description() { return this.readAttribute("description") }
+
+  setDescription(newValue) { return this._setColumnAttribute("description", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasDescription() { return this._hasAttribute(this.description()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @interface
+   * @returns {import("../models/project.js").default}
+   */
+  project() { return this.getRelationshipByName("project").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/project.js").default}
+   */
+  buildProject(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadProject() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/project.js").default} newModel
+   * @returns {void}
+   */
+  setProject(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

package/spec/dummy/src/model-bases/user.js

@@ -0,0 +1,175 @@
+import Record from "../../../../src/database/record/index.js"
+
+export default class UserBase extends Record {
+  /**
+   * @returns {number}
+   */
+  id() { return this.readAttribute("id") }
+
+  /**
+   * @param {number} newValue
+   * @returns {void}
+   */
+  setId(newValue) { return this._setColumnAttribute("id", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasId() { return this._hasAttribute(this.id()) }
+
+  /**
+   * @returns {string}
+   */
+  email() { return this.readAttribute("email") }
+
+  /**
+   * @param {string} newValue
+   * @returns {void}
+   */
+  setEmail(newValue) { return this._setColumnAttribute("email", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasEmail() { return this._hasAttribute(this.email()) }
+
+  /**
+   * @returns {string}
+   */
+  encryptedPassword() { return this.readAttribute("encryptedPassword") }
+
+  /**
+   * @param {string} newValue
+   * @returns {void}
+   */
+  setEncryptedPassword(newValue) { return this._setColumnAttribute("encryptedPassword", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasEncryptedPassword() { return this._hasAttribute(this.encryptedPassword()) }
+
+  /**
+   * @returns {string | null}
+   */
+  reference() { return this.readAttribute("reference") }
+
+  /**
+   * @param {string | null} newValue
+   * @returns {void}
+   */
+  setReference(newValue) { return this._setColumnAttribute("reference", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasReference() { return this._hasAttribute(this.reference()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  createdAt() { return this.readAttribute("createdAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setCreatedAt(newValue) { return this._setColumnAttribute("createdAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasCreatedAt() { return this._hasAttribute(this.createdAt()) }
+
+  /**
+   * @returns {Date | null}
+   */
+  updatedAt() { return this.readAttribute("updatedAt") }
+
+  /**
+   * @param {Date | null} newValue
+   * @returns {void}
+   */
+  setUpdatedAt(newValue) { return this._setColumnAttribute("updatedAt", newValue) }
+
+  /**
+   * @returns {boolean}
+   */
+  hasUpdatedAt() { return this._hasAttribute(this.updatedAt()) }
+
+  /**
+   * @interface
+   * @returns {import("../models/project.js").default}
+   */
+  createdProject() { return this.getRelationshipByName("createdProject").loaded() }
+
+  /**
+   * @interface
+   * @param {Record<string, any>} attributes
+   * @returns {import("../models/project.js").default}
+   */
+  buildCreatedProject(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadCreatedProject() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {import("../models/project.js").default} newModel
+   * @returns {void}
+   */
+  setCreatedProject(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {import("velocious/src/database/query/index.js").default<import("../models/authentication-token.js").default>}
+   */
+  authenticationTokens() { return this.getRelationshipByName("authenticationTokens") }
+
+  /**
+   * @interface
+   * @returns {Array<import("../models/authentication-token.js").default>}
+   */
+  authenticationTokensLoaded() { return this.getRelationshipByName("authenticationTokens").loaded() }
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadAuthenticationTokens() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {Array<import("../models/authentication-token.js").default>} newModels
+   * @returns {void}
+   */
+  setAuthenticationTokens(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {import("velocious/src/database/query/index.js").default<import("../models/project.js").default>}
+   */
+  createdProjects() { return this.getRelationshipByName("createdProjects") }
+
+  /**
+   * @interface
+   * @returns {Array<import("../models/project.js").default>}
+   */
+  createdProjectsLoaded() { return this.getRelationshipByName("createdProjects").loaded() }
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  loadCreatedProjects() { throw new Error("Not implemented") }
+
+  /**
+   * @interface
+   * @param {Array<import("../models/project.js").default>} newModels
+   * @returns {void}
+   */
+  setCreatedProjects(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars
+}

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

@@ -1,6 +1,6 @@
-import DatabaseRecord from "../../../../src/database/record/index.js"
+import AccountBase from "../model-bases/account.js"
 
-class Account extends DatabaseRecord {
+class Account extends AccountBase {
 }
 
 Account.setDatabaseIdentifier("mssql")

package/spec/dummy/src/models/authentication-token.js

@@ -1,6 +1,6 @@
-import Record from "../../../../src/database/record/index.js"
+import AuthenticationTokenBase from "../model-bases/authentication-token.js"
 
-class AuthenticationToken extends Record {
+class AuthenticationToken extends AuthenticationTokenBase {
 }
 
 AuthenticationToken.belongsTo("user")

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

@@ -1,6 +1,6 @@
-import DatabaseRecord from "../../../../src/database/record/index.js"
+import ProjectDetailsBase from "../model-bases/project-detail.js"
 
-class ProjectDetail extends DatabaseRecord {
+class ProjectDetail extends ProjectDetailsBase {
 }
 
 ProjectDetail.belongsTo("project")

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

@@ -1,6 +1,6 @@
-import DatabaseRecord from "../../../../src/database/record/index.js"
+import ProjectBase from "../model-bases/project.js"
 
-class Project extends DatabaseRecord {
+class Project extends ProjectBase {
 }
 
 Project.belongsTo("creatingUser", {className: "User", foreignKey: "creating_user_reference", primaryKey: "reference"})

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

@@ -1,6 +1,6 @@
-import Record from "../../../../src/database/record/index.js"
+import TaskBase from "../model-bases/task.js"
 
-class Task extends Record {
+class Task extends TaskBase {
 }
 
 Task.belongsTo("project")

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

@@ -1,7 +1,7 @@
-import Record from "../../../../src/database/record/index.js"
+import UserBase from "../model-bases/user.js"
 import UserModule from "../../../../src/database/record/user-module.js"
 
-class User extends Record {
+class User extends UserBase {
 }
 
 User.hasOne("createdProject", {className: "Project", foreignKey: "creating_user_reference", primaryKey: "reference"})

package/src/configuration.js

@@ -1,5 +1,9 @@
 // @ts-check
 
+/**
+ * @typedef {function(Record<string, import("./database/drivers/base.js").default>) : Promise<void>} WithConnectionsCallbackType
+ */
+
 import {digg} from "diggerize"
 import restArgsError from "./utils/rest-args-error.js"
 import {withTrackedStack} from "./utils/with-tracked-stack.js"
@@ -320,7 +324,7 @@ export default class VelociousConfiguration {
   }
 
   /**
-   * @param {Function} callback
+   * @param {WithConnectionsCallbackType} callback
    * @returns {Promise<void>}
    */
   async withConnections(callback) {
@@ -376,7 +380,7 @@ export default class VelociousConfiguration {
   }
 
   /**
-   * @param {Function} callback
+   * @param {WithConnectionsCallbackType} callback
    * @returns {Promise<void>}
    */
   async ensureConnections(callback) {

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

@@ -83,7 +83,15 @@ export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
 
   getType() {
     const type = digg(this, "data", "Type")
+
+    if (type.match(/^[a-z]+$/)) {
+      return type
+    }
+
     const match = type.match(/^(.+)\((\d+)\)$/)
+
+    if (!match) throw new Error(`Couldn't match column type from: ${type}`)
+
     const columnType = match[1]
 
     return columnType

package/src/database/migration/index.js

@@ -223,13 +223,15 @@ export default class VelociousDatabaseMigration {
   async columnExists(tableName, columnName) {
     const table = await this.getDriver().getTableByName(tableName)
 
-    if (!table) throw new Error(`Table ${tableName} does not exist`)
-
-    const column = await table.getColumnByName(columnName)
+    if (table) {
+      const column = await table.getColumnByName(columnName)
 
-    if (!column) throw new Error(`Column ${columnName} does not exist in table ${tableName}`)
+      if (column) {
+        return true
+      }
+    }
 
-    return Boolean(column)
+    return Boolean(false)
   }
 
   /**
@@ -271,6 +273,8 @@ export default class VelociousDatabaseMigration {
 
     if (id !== false) {
       ({default: idDefault, type: idType, ...restArgsId} = id)
+
+      restArgsError(restArgsId)
     }
 
     if (!idType) {
@@ -280,7 +284,6 @@ export default class VelociousDatabaseMigration {
     const tableData = new TableData(tableName)
 
     restArgsError(restArgs)
-    restArgsError(restArgsId)
 
     if (!(idType in tableData)) throw new Error(`Unsupported primary key type: ${idType}`)
 

package/src/database/record/index.js

@@ -269,7 +269,7 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * @param {Record<string, any>} attributes
+   * @param {Record<string, any>} [attributes]
    * @returns {Promise<InstanceType<typeof this>>}
    */
   static async create(attributes) {
@@ -511,6 +511,9 @@ class VelociousDatabaseRecord {
     }
   }
 
+  /**
+   * @returns {import("../drivers/base-column.js").default[]}
+   */
   static getColumns() {
     if (!this._columns) throw new Error(`${this.name} hasn't been initialized yet`)
 
@@ -763,7 +766,7 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * @returns {VelociousDatabaseRecord}
+   * @returns {typeof VelociousDatabaseRecord}
    */
   static getTranslationClass() {
     if (this._translationClass) return this._translationClass

package/src/environment-handlers/node/cli/commands/generate/base-models.js

@@ -9,6 +9,11 @@ export default class DbGenerateModel extends BaseCommand {
 
     const modelsDir = `${process.cwd()}/src/model-bases`
     const modelClasses = this.getConfiguration().getModelClasses()
+    let devMode = false
+
+    if (modelsDir.endsWith("velocious/spec/dummy/src/model-bases")) {
+      devMode = true
+    }
 
     if (!await fileExists(modelsDir)) {
       await fs.mkdir(modelsDir, {recursive: true})
@@ -23,7 +28,13 @@ export default class DbGenerateModel extends BaseCommand {
 
       console.log(`create src/model-bases/${modelBaseFileName}`)
 
-      let fileContent = `import Record from "velocious/src/database/record/index.js"\n\n`
+      let fileContent = ""
+
+      if (devMode) {
+        fileContent += `import Record from "../../../../src/database/record/index.js"\n\n`
+      } else {
+        fileContent += `import Record from "velocious/src/database/record/index.js"\n\n`
+      }
 
       fileContent += `export default class ${modelNameCamelized}Base extends Record {\n`
 
@@ -33,15 +44,7 @@ export default class DbGenerateModel extends BaseCommand {
       for (const column of columns) {
         const camelizedColumnName = inflection.camelize(column.getName(), true)
         const camelizedColumnNameBigFirst = inflection.camelize(column.getName())
-        let jsdocType
-
-        if (column.getType() == "varchar") {
-          jsdocType = "string"
-        } else if (["bigint", "int", "integer", "smallint"].includes(column.getType())) {
-          jsdocType = "number"
-        } else if (["date", "datetime"].includes(column.getType())) {
-          jsdocType = "Date"
-        }
+        const jsdocType = this.jsDocTypeFromColumn(column)
 
         if (methodsCount > 0) {
           fileContent += "\n"
@@ -49,7 +52,7 @@ export default class DbGenerateModel extends BaseCommand {
 
         if (jsdocType) {
           fileContent += "  /**\n"
-          fileContent += `   * @returns {${jsdocType}}\n`
+          fileContent += `   * @returns {${jsdocType}${column.getNull() ? " | null" : ""}}\n`
           fileContent += "   */\n"
         }
 
@@ -57,7 +60,7 @@ export default class DbGenerateModel extends BaseCommand {
 
         if (jsdocType) {
           fileContent += "  /**\n"
-          fileContent += `   * @param {${jsdocType}} newValue\n`
+          fileContent += `   * @param {${jsdocType}${column.getNull() ? " | null" : ""}} newValue\n`
           fileContent += "   * @returns {void}\n"
           fileContent += "   */\n"
         }
@@ -72,6 +75,46 @@ export default class DbGenerateModel extends BaseCommand {
         methodsCount++
       }
 
+      if (modelClass._translations) {
+        const TranslationClass = modelClass.getTranslationClass()
+        const translationColumns = TranslationClass.getColumns()
+
+        for (const name in modelClass._translations) {
+          const nameUnderscore = inflection.underscore(name)
+          const column = translationColumns.find((translationColumn) => translationColumn.getName() === nameUnderscore)
+          let translationJsdocType
+
+          if (column) {
+            translationJsdocType = this.jsDocTypeFromColumn(column)
+          }
+
+          if (translationJsdocType) {
+            fileContent += `\n`
+            fileContent += "  /**\n"
+            fileContent += `   * @returns {${translationJsdocType}${column.getNull() ? " | null" : ""}}\n`
+            fileContent += "   */\n"
+          }
+
+          fileContent += `  ${name}() { return this._getTranslatedAttributeWithFallback("${name}", this._getConfiguration().getLocale()) }\n`
+          methodsCount++
+
+          for (const locale of this.getConfiguration().getLocales()) {
+            const localeMethodName = `${name}${inflection.camelize(locale)}`
+
+            if (translationJsdocType) {
+              fileContent += `\n`
+              fileContent += "  /**\n"
+              fileContent += `   * @returns {${translationJsdocType}${column.getNull() ? " | null" : ""}}\n`
+              fileContent += "   */\n"
+            }
+
+            fileContent += `  ${localeMethodName}() { return this._getTranslatedAttributeWithFallback("${name}", "${locale}") }\n`
+
+            methodsCount++
+          }
+        }
+      }
+
       for (const relationship of modelClass.getRelationships()) {
         let fileName, fullFilePath
 
@@ -104,9 +147,10 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += "\n"
           fileContent += "  /**\n"
           fileContent += "   * @interface\n"
+          fileContent += "   * @param {Record<string, any>} attributes\n"
           fileContent += `   * @returns {import("${modelFilePath}").default}\n`
           fileContent += "   */\n"
-          fileContent += `  build${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+          fileContent += `  build${inflection.camelize(relationship.getRelationshipName())}(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"
@@ -121,7 +165,7 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += `   * @param {import("${modelFilePath}").default} newModel\n`
           fileContent += `   * @returns {void}\n`
           fileContent += "   */\n"
-          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`
         } else if (relationship.getType() == "hasMany") {
           let recordImport
 
@@ -155,9 +199,9 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += "  /**\n"
           fileContent += "   * @interface\n"
           fileContent += `   * @param {Array<import("${recordImport}").default>} newModels\n`
-          fileContent += "   * @returns {void>}\n"
+          fileContent += "   * @returns {void}\n"
           fileContent += "   */\n"
-          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`
         } else {
           throw new Error(`Unknown relationship type: ${relationship.getType()}`)
         }
@@ -170,4 +214,18 @@ export default class DbGenerateModel extends BaseCommand {
       await fs.writeFile(modelPath, fileContent)
     }
   }
+
+  /**
+   * @param {import("../../../../../database/drivers/base-column.js").default} column
+   * @returns {string | undefined}
+   */
+  jsDocTypeFromColumn(column) {
+    if (column.getType() == "varchar") {
+      return "string"
+    } else if (["bigint", "int", "integer", "smallint"].includes(column.getType())) {
+      return "number"
+    } else if (["date", "datetime"].includes(column.getType())) {
+      return "Date"
+    }
+  }
 }

package/src/testing/test.js

@@ -315,7 +315,7 @@ class Expect {
 /**
  * @param {string} description
  * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} arg2
+ * @param {undefined|() => Promise<void>} [arg2]
  * @returns {void}
  */
 async function describe(description, arg1, arg2) {
@@ -361,7 +361,7 @@ function expect(arg) {
 /**
  * @param {string} description
  * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} arg2
+ * @param {undefined|() => Promise<void>} [arg2]
  * @returns {void}
  */
 function it(description, arg1, arg2) {
@@ -386,7 +386,7 @@ function it(description, arg1, arg2) {
 /**
  * @param {string} description
  * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} arg2
+ * @param {undefined|() => Promise<void>} [arg2]
  * @returns {void}
  */
 function fit(description, arg1, arg2) {