velocious 1.0.108 → 1.0.110

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

@@ -1,120 +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 - query", () => {
-  it("queries for records", 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"})
-
-      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")
-
-      const tasks = /** @type {Task[]} */ (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")
-      expect(task.project().id()).toEqual(newProject.id())
-      expect(newTask.project()).toEqual(newProject)
-
-      expect(newProject.id()).not.toBeUndefined()
-      expect(newProject.name()).toEqual("Test project")
-      expect(newProject.nameDe()).toEqual("Test projekt")
-      expect(newProject.nameEn()).toEqual("Test project")
-
-      expect(newProjectDetail.note()).toEqual("Test note")
-    })
-  })
-
-  it("finds the first record", async () => {
-    await Dummy.run(async () => {
-      const taskIDs = []
-      const project = await Project.create()
-
-      for (let i = 0; i < 5; i++) {
-        const task = await Task.create({name: `Task ${i}`, project})
-
-        taskIDs.push(task.id())
-      }
-
-      const lastTask = await Task.first()
-
-      expect(lastTask.id()).toEqual(taskIDs[0])
-    })
-  })
-
-  it("finds the last record", async () => {
-    await Dummy.run(async () => {
-      const taskIDs = []
-      const project = await Project.create()
-
-      for (let i = 0; i < 5; i++) {
-        const task = await Task.create({name: `Task ${i}`, project})
-
-        taskIDs.push(task.id())
-      }
-
-      const lastTask = await Task.last()
-
-      expect(lastTask.id()).toEqual(taskIDs[4])
-    })
-  })
-
-  it("finds the record with joins and where hashes", async () => {
-    await Dummy.run(async () => {
-      const project1 = await Project.create({name: "Test project 1"})
-      const project2 = await Project.create({name: "Test project 2"})
-
-      for (let i = 0; i < 5; i++) {
-        await Task.create({name: `Task 1-${i}`, project: project1})
-        await Task.create({name: `Task 2-${i}`, project: project2})
-      }
-
-      const tasks = /** @type {Task[]} */ (
-        await Task
-          .joins({project: {translations: true}})
-          .where({tasks: {name: "Task 2-2"}, project_translations: {name: "Test project 2"}})
-          .preload({project: {translations: true}})
-          .toArray()
-      )
-
-      const task = tasks[0]
-
-      expect(tasks.length).toEqual(1)
-      expect(task.name()).toEqual("Task 2-2")
-      expect(task.project().name()).toEqual("Test project 2")
-    })
-  })
-
-  it("counts the records", async () => {
-    await Dummy.run(async () => {
-      const taskIDs = []
-      const project = await Project.create()
-
-      for (let i = 0; i < 5; i++) {
-        const task = await Task.create({name: `Task ${i}`, project})
-
-        taskIDs.push(task.id())
-      }
-
-      const tasksCount = await Task.count()
-
-      expect(tasksCount).toEqual(5)
-    })
-  })
-})

package/spec/database/record/translation-fallbacks-spec.js

@@ -1,24 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Task from "../../dummy/src/models/task.js"
-
-describe("Record - translation fallbacks", () => {
-  it("creates a new simple record with relationships and translations with fallbacks", async () => {
-    await Dummy.run(async () => {
-      const task = new Task({name: "Test task"})
-      const project = task.buildProject({nameDe: "Test projekt"})
-
-      expect(project.name()).toEqual("Test projekt")
-      expect(project.nameEn()).toEqual(undefined)
-      expect(project.nameDe()).toEqual("Test projekt")
-
-      await task.save()
-
-      const sameTask = /** @type {Task} */ (await Task.preload({project: {translations: true}}).find(task.id()))
-      const sameProject = sameTask.project()
-
-      expect(sameProject.name()).toEqual("Test projekt")
-      expect(sameProject.nameEn()).toEqual(undefined)
-      expect(sameProject.nameDe()).toEqual("Test projekt")
-    })
-  })
-})

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

@@ -1,10 +0,0 @@
-import Record from "../../../src/database/record/index.js"
-
-class EventSeries extends Record {
-}
-
-describe("Record - translations", () => {
-  it("handles difficult table names", async () => {
-    expect(EventSeries.getTranslationsTableName()).toEqual("event_series_translations")
-  })
-})

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

@@ -1,31 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Project from "../../dummy/src/models/project.js"
-import Task from "../../dummy/src/models/task.js"
-import wait from "awaitery/src/wait.js"
-
-describe("Record - update", () => {
-  it("updates 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.update({name: "Updated name"})
-
-      expect(task.readAttribute("name")).toEqual("Updated name")
-    })
-  })
-
-  it("updates a record with timestamps", async () => {
-    await Dummy.run(async () => {
-      const project = new Project({name: "Test project"})
-
-      await project.save()
-      await wait(1000)
-      await project.update({name: "Updated name"})
-
-      expect(project.name()).toEqual("Updated name")
-      expect(project.updatedAt()).not.toEqual(project.createdAt())
-    })
-  })
-})

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

@@ -1,42 +0,0 @@
-import Dummy from "../../dummy/index.js"
-import Task from "../../dummy/src/models/task.js"
-import {ValidationError} from "../../../src/database/record/index.js"
-import Project from "../../dummy/src/models/project.js"
-
-describe("Record - validations", () => {
-  it("raises validations if trying to create an invalid record because of a presence validation", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      const task = new Task({name: " ", project})
-
-      await expect(async () => task.save()).toThrowError(new ValidationError("Name can't be blank"))
-    })
-  })
-
-  it("raises validations if trying to create an invalid record with a blank value because of a presence validation", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      const task = new Task({name: null, project})
-
-      await expect(async () => task.save()).toThrowError(new ValidationError("Name can't be blank"))
-    })
-  })
-
-  it("raises validations if trying to create an invalid record because of a uniqueness validation", async () => {
-    await Dummy.run(async () => {
-      const project = await Project.create()
-      await Task.create({name: "Task 1", project})
-
-      const task2 = await Task.create({name: "Task 2", project})
-
-      try {
-        await task2.update({name: "Task 1"})
-
-        throw new Error("Task 2 save didn't fail")
-      } catch (error) {
-        expect(error).toBeInstanceOf(ValidationError)
-        expect(error.message).toEqual("Name has already been taken")
-      }
-    })
-  })
-})

package/spec/database/transactions-spec.js

@@ -1,47 +0,0 @@
-// @ts-check
-
-import Dummy from "../dummy/index.js"
-import dummyConfiguration from "../dummy/src/config/configuration.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"
-
-describe("database - transactions", () => {
-  it("supports transactions and savepoints", async () => {
-    await Dummy.run(async () => {
-      await dummyConfiguration.ensureConnections(async (dbs) => {
-        const db = dbs.default
-        const project = await Project.create()
-
-        await db.transaction(async () => {
-          await Task.create({name: "Task 1", project})
-
-          await db.transaction(async () => {
-            await Task.create({name: "Task 2", project})
-
-            try {
-              await db.transaction(async () => {
-                await Task.create({name: "Task 3", project})
-                await Task.create({name: "    ", project})
-
-                throw new Error("Didn't 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(`'error' wasn't an 'Error': ${typeof error}`)
-              }
-            }
-          })
-        })
-      })
-
-      const tasksCount = await Task.count()
-
-      expect(tasksCount).toEqual(2)
-    })
-  })
-})

package/spec/dummy/dummy-directory.js

@@ -1,13 +0,0 @@
-// @ts-check
-
-import {dirname} from "path"
-import {fileURLToPath} from "url"
-
-function dummyDirectory() {
-  const __filename = fileURLToPath(import.meta.url)
-  const __dirname = dirname(__filename)
-
-  return __dirname
-}
-
-export default dummyDirectory

package/spec/dummy/index.js

@@ -1,83 +0,0 @@
-// @ts-check
-
-import Application from "../../src/application.js"
-import {digg} from "diggerize"
-import dummyConfiguration from "./src/config/configuration.js"
-import EnvironmentHandlerNode from "../../src/environment-handlers/node.js"
-import Migrator from "../../src/database/migrator.js"
-
-export default class Dummy {
-  static current() {
-    if (!this.velociousDummy) {
-      this.velociousDummy = new Dummy()
-    }
-
-    return this.velociousDummy
-  }
-
-  static async prepare() {
-    dummyConfiguration.setCurrent()
-
-    await dummyConfiguration.ensureConnections(async () => {
-      await this.runMigrations()
-
-      if (!dummyConfiguration.isInitialized()) {
-        await dummyConfiguration.initialize()
-      }
-    })
-  }
-
-  static async runMigrations() {
-    const environmentHandlerNode = new EnvironmentHandlerNode()
-
-    environmentHandlerNode.setConfiguration(dummyConfiguration)
-
-    const migrator = new Migrator({configuration: dummyConfiguration})
-
-    await migrator.prepare()
-    await migrator.migrateFiles(await environmentHandlerNode.findMigrations(), digg(environmentHandlerNode, "requireMigration"))
-  }
-
-  /** @param {function(): Promise<any>} callback */
-  static async run(callback) {
-    await this.current().run(callback)
-  }
-
-  /** @param {function(): Promise<void>} callback */
-  async run(callback) {
-    await dummyConfiguration.ensureConnections(async () => {
-      await Dummy.prepare()
-      await this.start()
-
-      try {
-        await callback()
-      } finally {
-        await this.stop()
-      }
-    })
-  }
-
-  async start() {
-    if (!dummyConfiguration.isDatabasePoolInitialized()) {
-      await dummyConfiguration.initializeDatabasePool()
-    }
-
-    this.application = new Application({
-      configuration: dummyConfiguration,
-      httpServer: {
-        maxWorkers: 1,
-        port: 3006
-      },
-      type: "dummy"
-    })
-
-    await this.application.initialize()
-    await this.application.startHttpServer()
-  }
-
-  async stop() {
-    if (this.application?.isActive()) {
-      await this.application.stop()
-    }
-  }
-}

package/spec/dummy/src/config/configuration.example.js

@@ -1,70 +0,0 @@
-import "../../../../src/utils/with-tracked-stack-async-hooks.js"
-import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
-import Configuration from "../../../../src/configuration.js"
-import dummyDirectory from "../../dummy-directory.js"
-import fs from "fs/promises"
-import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
-import MysqlDriver from "../../../../src/database/drivers/mysql/index.js"
-import NodeEnvironmentHandler from "../../../../src/environment-handlers/node.js"
-import path from "path"
-import requireContext from "require-context"
-
-export default new Configuration({
-  database: {
-    development: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "velocious_development",
-        migrations: true
-      }
-    },
-    production: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "velocious_production",
-        migrations: true
-      }
-    },
-    test: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "velocious_test",
-        migrations: true
-      }
-    }
-  },
-  directory: dummyDirectory(),
-  environment: "development",
-  environmentHandler: new NodeEnvironmentHandler(),
-  initializeModels: async ({configuration}) => {
-    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
-    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
-    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
-
-    await configuration.ensureConnections(async () => {
-      await initializerFromRequireContext.initialize({configuration})
-    })
-  },
-  locale: () => "en",
-  localeFallbacks: {
-    de: ["de", "en"],
-    en: ["en", "de"]
-  },
-  locales: ["de", "en"],
-  testing: `${dummyDirectory()}/src/config/testing.js`
-})

package/spec/dummy/src/config/configuration.peakflow.mariadb.js

@@ -1,65 +0,0 @@
-import "../../../../src/utils/with-tracked-stack-async-hooks.js"
-import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
-import Configuration from "../../../../src/configuration.js"
-import dummyDirectory from "../../dummy-directory.js"
-import fs from "fs/promises"
-import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
-import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
-import MysqlDriver from "../../../../src/database/drivers/mysql/index.js"
-import NodeEnvironmentHandler from "../../../../src/environment-handlers/node.js"
-import path from "path"
-import requireContext from "require-context"
-
-export default new Configuration({
-  database: {
-    test: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "peakflow",
-        password: "password",
-        database: "velocious_test",
-        useDatabase: "velocious_test",
-        migrations: true
-      },
-      mssql: {
-        driver: MssqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mssql",
-        database: "velocious_test",
-        useDatabase: "default",
-        migrations: true,
-        sqlConfig: {
-          user: "sa",
-          password: "Super-Secret-Password",
-          database: "velocious_test",
-          server: "mssql",
-          options: {
-            encrypt: true, // for azure
-            trustServerCertificate: true // change to true for local dev / self-signed certs
-          }
-        }
-      }
-    }
-  },
-  directory: dummyDirectory(),
-  environmentHandler: new NodeEnvironmentHandler(),
-  initializeModels: async ({configuration}) => {
-    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
-    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
-    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
-
-    await configuration.ensureConnections(async () => {
-      await initializerFromRequireContext.initialize({configuration})
-    })
-  },
-  locale: () => "en",
-  localeFallbacks: {
-    de: ["de", "en"],
-    en: ["en", "de"]
-  },
-  locales: ["de", "en"],
-  testing: `${dummyDirectory()}/src/config/testing.js`
-})

package/spec/dummy/src/config/configuration.peakflow.mssql.js

@@ -1,71 +0,0 @@
-import "../../../../src/utils/with-tracked-stack-async-hooks.js"
-import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
-import Configuration from "../../../../src/configuration.js"
-import dummyDirectory from "../../dummy-directory.js"
-import fs from "fs/promises"
-import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
-import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
-import NodeEnvironmentHandler from "../../../../src/environment-handlers/node.js"
-import path from "path"
-import requireContext from "require-context"
-
-export default new Configuration({
-  database: {
-    test: {
-      default: {
-        driver: MssqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mssql",
-        database: "velocious_test",
-        useDatabase: "default",
-        migrations: true,
-        sqlConfig: {
-          user: "sa",
-          password: "Super-Secret-Password",
-          database: "velocious_test",
-          server: "mssql",
-          options: {
-            encrypt: true, // for azure
-            trustServerCertificate: true // change to true for local dev / self-signed certs
-          }
-        }
-      },
-      mssql: {
-        driver: MssqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mssql",
-        database: "velocious_test",
-        useDatabase: "default",
-        migrations: true,
-        sqlConfig: {
-          user: "sa",
-          password: "Super-Secret-Password",
-          database: "velocious_test",
-          server: "mssql",
-          options: {
-            encrypt: true, // for azure
-            trustServerCertificate: true // change to true for local dev / self-signed certs
-          }
-        }
-      }
-    }
-  },
-  directory: dummyDirectory(),
-  environmentHandler: new NodeEnvironmentHandler(),
-  initializeModels: async ({configuration}) => {
-    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
-    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
-    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
-
-    await configuration.ensureConnections(async () => {
-      await initializerFromRequireContext.initialize({configuration})
-    })
-  },
-  locale: () => "en",
-  localeFallbacks: {
-    de: ["de", "en"],
-    en: ["en", "de"]
-  },
-  locales: ["de", "en"],
-  testing: `${dummyDirectory()}/src/config/testing.js`
-})

package/spec/dummy/src/config/configuration.peakflow.pgsql.js

@@ -1,65 +0,0 @@
-import "../../../../src/utils/with-tracked-stack-async-hooks.js"
-import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
-import Configuration from "../../../../src/configuration.js"
-import dummyDirectory from "../../dummy-directory.js"
-import fs from "fs/promises"
-import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
-import MssqlDriver from "../../../../src/database/drivers/mssql/index.js"
-import NodeEnvironmentHandler from "../../../../src/environment-handlers/node.js"
-import path from "path"
-import PgsqlDriver from "../../../../src/database/drivers/pgsql/index.js"
-import requireContext from "require-context"
-
-export default new Configuration({
-  database: {
-    test: {
-      default: {
-        driver: PgsqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "pgsql",
-        host: "postgres",
-        username: "peakflow",
-        password: "password",
-        database: "velocious_test",
-        useDatabase: "velocious_test",
-        migrations: true
-      },
-      mssql: {
-        driver: MssqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mssql",
-        database: "velocious_test",
-        useDatabase: "default",
-        migrations: true,
-        sqlConfig: {
-          user: "sa",
-          password: "Super-Secret-Password",
-          database: "velocious_test",
-          server: "mssql",
-          options: {
-            encrypt: true, // for azure
-            trustServerCertificate: true // change to true for local dev / self-signed certs
-          }
-        }
-      }
-    }
-  },
-  directory: dummyDirectory(),
-  environmentHandler: new NodeEnvironmentHandler(),
-  initializeModels: async ({configuration}) => {
-    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
-    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
-    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
-
-    await configuration.ensureConnections(async () => {
-      await initializerFromRequireContext.initialize({configuration})
-    })
-  },
-  locale: () => "en",
-  localeFallbacks: {
-    de: ["de", "en"],
-    en: ["en", "de"]
-  },
-  locales: ["de", "en"],
-  testing: `${dummyDirectory()}/src/config/testing.js`
-})