velocious 1.0.108 → 1.0.109

package/spec/database/connection/drivers/mysql/query-parser-spec.js

@@ -1,41 +0,0 @@
-import configuration from "../../../../dummy/src/config/configuration.js"
-import DatabaseHandler from "../../../../../src/database/handler.js"
-import DatabaseQuery from "../../../../../src/database/query/index.js"
-import MysqlQueryParser from "../../../../../src/database/drivers/mysql/query-parser.js"
-
-import FromTable from "../../../../../src/database/query/from-table.js"
-import SelectTableAndColumn from "../../../../../src/database/query/select-table-and-column.js"
-
-import MysqlDriverClass from "../../../../../src/database/drivers/mysql/index.js"
-
-const mysqlConfig = configuration.database.test.default
-const mysqlDriver = new MysqlDriverClass(mysqlConfig, configuration)
-
-describe("database - connection - drivers - mysql - query parser", () => {
-  it("generates sql with selects, joins and orders", () => {
-    const handler = new DatabaseHandler()
-    const query = new DatabaseQuery({driver: mysqlDriver, handler})
-      .select(["tasks.id", "tasks.name"])
-      .from("tasks")
-      .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
-
-    const sql = new MysqlQueryParser({query}).toSql()
-
-    expect(sql).toEqual("SELECT tasks.id, tasks.name FROM tasks LEFT JOIN projects ON projects.id = tasks.project_id")
-  })
-
-  it("generates sql with selects, joins and orders with SelectTableAndColumn", () => {
-    const handler = new DatabaseHandler()
-    const query = new DatabaseQuery({driver: mysqlDriver, handler})
-      .select([
-        new SelectTableAndColumn("tasks", "id"),
-        new SelectTableAndColumn("tasks", "name")
-      ])
-      .from(new FromTable("tasks"))
-      .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
-
-    const sql = new MysqlQueryParser({query}).toSql()
-
-    expect(sql).toEqual("SELECT `tasks`.`id`, `tasks`.`name` FROM `tasks` LEFT JOIN projects ON projects.id = tasks.project_id")
-  })
-})

package/spec/database/drivers/columns-spec.js

@@ -1,27 +0,0 @@
-import dummyConfiguration from "../../dummy/src/config/configuration.js"
-
-describe("database - drivers - columns", () => {
-  it("runs migrations", {databaseCleaning: {transaction: false}}, async () => {
-    await dummyConfiguration.ensureConnections(async (dbs) => {
-      // Authentication tokens table is important because it will be totally re-created in SQLite because the renaming of the token column to user-column
-      const authenticationTokensTable = await dbs.default.getTableByName("authentication_tokens")
-      const authenticationTokensIDColumn = await authenticationTokensTable.getColumnByName("id")
-
-      expect(authenticationTokensIDColumn.getAutoIncrement()).toBeTrue()
-      expect(authenticationTokensIDColumn.getPrimaryKey()).toBeTrue()
-      expect(authenticationTokensIDColumn.getNull()).toBeFalse()
-
-      const projectsTable = await dbs.default.getTableByName("projects")
-      const projectsCreatedAtColumn = await projectsTable.getColumnByName("created_at")
-      const projectsIDColumn = await projectsTable.getColumnByName("id")
-
-      expect(projectsIDColumn.getAutoIncrement()).toBeTrue()
-      expect(projectsIDColumn.getPrimaryKey()).toBeTrue()
-      expect(projectsIDColumn.getNull()).toBeFalse()
-
-      expect(projectsCreatedAtColumn.getAutoIncrement()).toBeFalse()
-      expect(projectsCreatedAtColumn.getPrimaryKey()).toBeFalse()
-      expect(projectsCreatedAtColumn.getNull()).toBeTrue()
-    })
-  })
-})

package/spec/database/drivers/create-sql/create-index-sql-spec.js

@@ -1,24 +0,0 @@
-// @ts-check
-
-import dummyConfiguration from "../../../dummy/src/config/configuration.js"
-
-describe("database - create sql - create index sql", () => {
-  it("runs migrations", {databaseCleaning: {transaction: false}}, async () => {
-    await dummyConfiguration.ensureConnections(async (dbs) => {
-      const createIndexSQLs = await dbs.default.createIndexSQLs({
-        columns: ["id", "created_at"],
-        tableName: "projects"
-      })
-
-      if (dbs.default.getType() == "sqlite") {
-        expect(createIndexSQLs).toEqual("CREATE INDEX `index_on_projects_id_and_created_at` ON `projects` (`id`, `created_at`)")
-      } else if (dbs.default.getType() == "mssql") {
-        expect(createIndexSQLs).toEqual("CREATE INDEX [index_on_id_and_created_at] ON [projects] ([id], [created_at])")
-      } else if (dbs.default.getType() == "pgsql") {
-        expect(createIndexSQLs).toEqual(`CREATE INDEX "index_on_id_and_created_at" ON "projects" ("id", "created_at")`)
-      } else {
-        expect(createIndexSQLs).toEqual("CREATE INDEX `index_on_id_and_created_at` ON `projects` (`id`, `created_at`)")
-      }
-    })
-  })
-})

package/spec/database/drivers/mysql/connection-spec.js

@@ -1,22 +0,0 @@
-import DatabaseDriversMysql from "../../../../src/database/drivers/mysql/index.js"
-import configuration from "../../../dummy/src/config/configuration.js"
-import {digg} from "diggerize"
-
-const mysqlConfig = digg(configuration, "database", "test", "default")
-
-describe("Database - Drivers - Mysql - Connection", () => {
-  it("connects", async () => {
-    if (configuration.getDatabaseType() != "sqlite" && configuration.getDatabaseType() != "mssql" && configuration.getDatabaseType() != "pgsql") {
-      const mysql = new DatabaseDriversMysql(mysqlConfig, configuration)
-
-      await mysql.connect()
-
-      const result = await mysql.query("SELECT \"1\" AS test1, \"2\" AS test2")
-
-      expect(result).toEqual([{
-        test1: "1",
-        test2: "2"
-      }])
-    }
-  })
-})

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

@@ -1,28 +0,0 @@
-// @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,140 +0,0 @@
-// @ts-check
-
-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 () => {
-    await Dummy.run(async () => {
-      const task = new Task({name: "Test task"})
-      const project = task.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
-
-      project.buildProjectDetail({note: "Test note"})
-
-      expect(task.hasName()).toBeTrue()
-      expect(task.hasCreatedAt()).toBeFalse()
-      expect(project.hasName()).toBeTrue()
-      expect(project.hasNameEn()).toBeTrue()
-      expect(project.hasNameDe()).toBeTrue()
-      expect(project.hasUpdatedAt()).toBeFalse()
-
-      await task.save()
-
-      expect(task.id()).not.toBeUndefined()
-      expect(task.name()).toEqual("Test task")
-      expect(task.project().id()).toEqual(project.id())
-      expect(task.project()).toEqual(project)
-
-      expect(project.id()).not.toBeUndefined()
-      expect(project.name()).toEqual("Test project")
-      expect(project.nameDe()).toEqual("Test projekt")
-      expect(project.nameEn()).toEqual("Test project")
-      expect(project.createdAt()).toBeInstanceOf(Date)
-      expect(project.updatedAt()).toBeInstanceOf(Date)
-
-      // 'name' is not a column but rather a column on the translation data model.
-      expect(() => project.readColumn("name")).toThrowError("No such attribute or not selected Project#name")
-
-
-      // It saves a project note through a has one relationship
-      const projectDetail = project.projectDetail()
-
-      expect(projectDetail.isNewRecord()).toBeFalse()
-      expect(projectDetail.isPersisted()).toBeTrue()
-      expect(projectDetail.note()).toEqual("Test note")
-      expect(projectDetail.projectId()).toEqual(project.id())
-
-
-      // It automatically sets the relationship that saved it on a has-one-relationship
-      const projectInstanceRelationship = projectDetail.getRelationshipByName("project")
-
-      expect(projectInstanceRelationship.getPreloaded()).toBeTrue()
-      expect(projectDetail.project().id()).toEqual(project.id())
-
-
-      // It automatically sets the relationship that saved it on a has-many-relationship
-      const tasksRelationship = project.getRelationshipByName("tasks")
-
-      expect(tasksRelationship.getPreloaded()).toBeTrue()
-
-      const projectTasksIDs = project.tasksLoaded().map((task) => task.id())
-
-      expect(projectTasksIDs).toEqual([task.id()])
-    })
-  })
-
-  it("sets the inversed relationship on has-many-relationships", async () => {
-    const project = new Project({name: "Test project"})
-
-    project.tasks().build({name: "Test task 1"})
-    project.tasks().build({name: "Test task 2"})
-
-    await project.save()
-
-    const tasks = project.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(task2?.projectId()).toEqual(project.id())
-    expect(task2?.project().id()).toEqual(project.id())
-  })
-
-  it("creates a new task with an existing project", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create({name: "Test project"})
-      const task = new Task({name: "Test task", project})
-
-      await task.save()
-
-      expect(task.id()).not.toBeUndefined()
-      expect(task.name()).toEqual("Test task")
-      expect(task.project().id()).toEqual(project.id())
-      expect(task.project()).toEqual(project)
-    })
-  })
-
-  it("uses transactions and rolls back in case of an error", async () => {
-    await Dummy.run(async () => {
-      const beforeProjectsCount = await Project.count()
-      const beforeTasksCount = await Task.count()
-
-      expect(beforeProjectsCount).toEqual(0)
-      expect(beforeTasksCount).toEqual(0)
-
-      const project = new Project({name: "Test project"})
-
-      project.tasks().build({name: " ", project})
-      project.buildProjectDetail({note: "Test note"})
-
-      try {
-        await project.save()
-
-        throw new Error("Didnt expect to succeed")
-      } catch (error) {
-        expect(error).toBeInstanceOf(ValidationError)
-
-        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()
-      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/destroy-spec.js

@@ -1,35 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Project from "../../dummy/src/models/project.js"
-import Task from "../../dummy/src/models/task.js"
-
-describe("Record - destroy", () => {
-  it("destroys a record", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      const task = new Task({name: "Test task", project})
-
-      await task.save()
-      await task.destroy()
-
-      const foundTask = await Task.where({id: task.id()}).first()
-
-      expect(foundTask).toEqual(undefined)
-    })
-  })
-
-  it("destroys all records in a collection", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      const task1 = await Task.create({name: "Test task 1", project})
-      const task2 = await Task.create({name: "Test task 2", project})
-
-      await Task.where({id: task1.id()}).destroyAll()
-
-      const foundTask1 = await Task.where({id: task1.id()}).first()
-      const foundTask2 = await Task.where({id: task2.id()}).first()
-
-      expect(foundTask1).toEqual(undefined)
-      expect(foundTask2).toBeDefined()
-    })
-  })
-})

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

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

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

@@ -1,32 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Project from "../../dummy/src/models/project.js"
-import Task from "../../dummy/src/models/task.js"
-
-describe("Record - find", () => {
-  it("finds an existing record", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      const task = new Task({name: "Test task", project})
-
-      await task.save()
-
-      const foundTask = /** @type {Task} */ (await Task.find(task.id()))
-
-      expect(foundTask.readAttribute("name")).toEqual("Test task")
-      expect(foundTask.readColumn("name")).toEqual("Test task")
-      expect(foundTask.hasName()).toBeTrue()
-    })
-  })
-
-  it("raises an error when a record isn't found", async () => {
-    await Dummy.run(async () => {
-      try {
-        await Task.find(123)
-        throw new Error("Didn't expect to reach this")
-      } catch (error) {
-        expect(error.message).toEqual("Couldn't find Task with 'id'=123")
-        expect(error.constructor.name).toEqual("RecordNotFoundError")
-      }
-    })
-  })
-})

package/spec/database/record/instance-relationships/belongs-to-relationship-spec.js

@@ -1,21 +0,0 @@
-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 = /** @type {Task} */ (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

@@ -1,24 +0,0 @@
-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 = /** @type {Project} */ (await Project.create())
-      const task = await Task.create({name: "Test task", project})
-      const foundProject = /** @type {Project} */ (await Project.find(project.id()))
-      const tasksInstanceRelationship = foundProject.getRelationshipByName("tasks")
-
-      expect(tasksInstanceRelationship.isLoaded()).toBeFalse()
-
-      await foundProject.loadTasks()
-
-      expect(tasksInstanceRelationship.isLoaded()).toBeTrue()
-
-      const taskIDs = foundProject.tasksLoaded().map((task) => task.id())
-
-      expect(taskIDs).toEqual([task.id()])
-    })
-  })
-})

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

@@ -1,24 +0,0 @@
-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 = /** @type {Project} */ (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/last-spec.js

@@ -1,29 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Project from "../../dummy/src/models/project.js"
-import Task from "../../dummy/src/models/task.js"
-
-describe("Record - last", () => {
-  it("finds the last record", async () => {
-    await Dummy.run(async () => {
-      const project1 = await Project.create()
-
-      await Task.create({name: "Test task 1", project: project1})
-      await Task.create({name: "Test task 2", project: project1})
-      await Task.create({name: "Test task 3", project: project1})
-
-      const project2 = await Project.create()
-
-      await Task.create({name: "Test task 4", project: project2})
-      await Task.create({name: "Test task 5", project: project2})
-      await Task.create({name: "Test task 6", project: project2})
-
-      const foundTask = /** @type {Task} */ (await Task.last())
-
-      expect(foundTask.name()).toEqual("Test task 6")
-
-      const foundTaskWithFilter = /** @type {Task} */ (await Task.where({project_id: project1.id()}).last())
-
-      expect(foundTaskWithFilter.name()).toEqual("Test task 3")
-    })
-  })
-})

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

@@ -1,15 +0,0 @@
-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 = /** @type {Project} */ (await Project.preload({creatingUser: true}).find(project.id()))
-
-      expect(foundProject.creatingUser().id()).toEqual(user.id())
-    })
-  })
-})

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

@@ -1,29 +0,0 @@
-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 = /** @type {User} */ (await User.preload({createdProjects: true}).find(user.id()))
-      const createdProjectsIDs = foundUser.createdProjectsLoaded().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 = /** @type {User} */ (await User.preload({createdProjects: true}).find(user.id()))
-      const createdProjectsIDs = foundUser.createdProjectsLoaded().map((createdProject) => createdProject.id())
-
-      expect(createdProjectsIDs).toEqual([])
-    })
-  })
-})

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

@@ -1,15 +0,0 @@
-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 = /** @type {User} */ (await User.preload({createdProject: true}).find(user.id()))
-
-      expect(foundUser.createdProject().id()).toEqual([project.id()])
-    })
-  })
-})