velocious 1.0.5 → 1.0.6

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.mjs"
   },
   "name": "velocious",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "index.mjs",
   "scripts": {
     "test": "jasmine",
@@ -14,7 +14,7 @@
     "type": "git",
     "url": "git+https://github.com/kaspernj/velocious.git"
   },
-  "author": "k@spernj.org",
+  "author": "kasper@diestoeckels.de",
   "license": "ISC",
   "bugs": {
     "url": "https://github.com/kaspernj/velocious/issues"
@@ -24,9 +24,11 @@
   "devDependencies": {
     "jasmine": "^5.0.2",
     "mysql": "^2.18.1",
-    "node-fetch": "^3.3.1"
+    "node-fetch": "^3.3.1",
+    "require-context": "^1.1.0"
   },
   "dependencies": {
+    "better-localstorage": "^1.0.7",
     "diggerize": "^1.0.5",
     "ejs": "^3.1.6",
     "escape-string-regexp": "^1.0.5",

package/spec/cli/commands/db/create-spec.mjs

@@ -17,7 +17,7 @@ describe("Cli - Commands - db:create", () => {
           sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
         },
         {
-          createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` varchar(255) PRIMARY KEY)'
+          createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` varchar(255) PRIMARY KEY NOT NULL)'
         }
       ]
     )

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

@@ -17,6 +17,7 @@ describe("Cli - Commands - db:migrate", () => {
     await db.withConnection(async () => {
       await db.query("DROP TABLE IF EXISTS tasks")
       await db.query("DROP TABLE IF EXISTS projects")
+      await db.query("DROP TABLE IF EXISTS project_translations")
     })
 
     await cli.execute()
@@ -29,6 +30,7 @@ describe("Cli - Commands - db:migrate", () => {
 
     expect(tablesResult).toEqual(
       [
+        {Tables_in_velocious_test: "project_translations"},
         {Tables_in_velocious_test: "projects"},
         {Tables_in_velocious_test: "tasks"}
       ]

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

@@ -5,10 +5,19 @@ describe("Record - create", () => {
   it("creates a new simple record", async () => {
     await Dummy.run(async () => {
       const task = new Task({name: "Test task"})
+      const project = task.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
 
       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")
     })
   })
 })

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

@@ -1,5 +1,4 @@
 import Dummy from "../../dummy/index.mjs"
-import RecordNotFoundError from "../../../src/database/record/record-not-found-error.mjs"
 import Task from "../../dummy/src/models/task.mjs"
 
 describe("Record - find", () => {

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

@@ -0,0 +1,37 @@
+import Dummy from "../../dummy/index.mjs"
+import Task from "../../dummy/src/models/task.mjs"
+
+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"})
+
+      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 = await Task.preload({project: {translations: true}}).toArray()
+      const newTask = tasks[0]
+      const newProject = newTask.project()
+
+      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")
+    })
+  })
+})

package/spec/dummy/index.mjs

@@ -11,11 +11,23 @@ export default class Dummy {
   }
 
   static async prepare() {
+    dummyConfiguration.setCurrent()
+
     const db = dummyConfiguration.getDatabasePool()
 
     await db.withConnection(async () => {
       await db.query("DROP TABLE IF EXISTS tasks")
-      await db.query("CREATE TABLE tasks (id MEDIUMINT NOT NULL AUTO_INCREMENT, name VARCHAR(255), description TEXT, PRIMARY KEY (id))")
+      await db.query("DROP TABLE IF EXISTS projects")
+      await db.query("DROP TABLE IF EXISTS project_translations")
+
+      await db.query("CREATE TABLE tasks (id MEDIUMINT NOT NULL AUTO_INCREMENT, project_id MEDIUMINT, name VARCHAR(255), description TEXT, PRIMARY KEY (id))")
+      await db.query("CREATE TABLE projects (id MEDIUMINT NOT NULL AUTO_INCREMENT, PRIMARY KEY (id))")
+      await db.query("CREATE TABLE project_translations (id MEDIUMINT NOT NULL AUTO_INCREMENT, project_id MEDIUMINT, locale VARCHAR(255), name VARCHAR(255), PRIMARY KEY (id))")
+      await db.query("CREATE UNIQUE INDEX unique_project_translation ON project_translations (project_id, locale)")
+
+      if (!dummyConfiguration.isInitialized()) {
+        await dummyConfiguration.initialize()
+      }
     })
   }
 
@@ -25,10 +37,10 @@ export default class Dummy {
 
   async run(callback) {
     await dummyConfiguration.getDatabasePool().withConnection(async () => {
+      await Dummy.prepare()
       await this.start()
 
       try {
-        await Dummy.prepare()
         await callback()
       } finally {
         await this.stop()

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

@@ -1,7 +1,11 @@
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.mjs"
 import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
+import path from "path"
+import requireContext from "require-context"
 
 export default new Configuration({
   database: {
@@ -17,5 +21,16 @@ export default new Configuration({
       }
     }
   },
-  directory: dummyDirectory()
+  directory: dummyDirectory(),
+  initializeModels: async ({configuration}) => {
+    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
+    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.mjs$/)
+    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
+
+    await configuration.getDatabasePool().withConnection(async () => {
+      await initializerFromRequireContext.initialize({configuration})
+    })
+  },
+  locale: () => "en",
+  locales: ["de", "en"]
 })

package/spec/dummy/src/config/configuration.peakflow.mjs

@@ -1,7 +1,11 @@
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.mjs"
 import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
+import path from "path"
+import requireContext from "require-context"
 
 export default new Configuration({
   database: {
@@ -18,5 +22,16 @@ export default new Configuration({
       }
     }
   },
-  directory: dummyDirectory()
+  directory: dummyDirectory(),
+  initializeModels: async ({configuration}) => {
+    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
+    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.mjs$/)
+    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
+
+    await configuration.getDatabasePool().withConnection(async () => {
+      await initializerFromRequireContext.initialize({configuration})
+    })
+  },
+  locale: () => "en",
+  locales: ["de", "en"]
 })

package/spec/dummy/src/database/migrations/20230728075328-create-projects.mjs

@@ -3,7 +3,6 @@ import Migration from "../../../../../src/database/migration/index.mjs"
 export default class CreateProjects extends Migration {
   async change() {
     await this.createTable("projects", (table) => {
-      table.bigint("id", {autoIncrement: true, primaryKey: true})
       table.string("name", {maxLength: 100, null: false})
       table.timestamps()
     })

package/spec/dummy/src/database/migrations/20230728075329-create-tasks.mjs

@@ -3,7 +3,6 @@ import Migration from "../../../../../src/database/migration/index.mjs"
 export default class CreateTasks extends Migration {
   async change() {
     await this.createTable("tasks", (table) => {
-      table.bigint("id", {autoIncrement: true, primaryKey: true})
       table.references("project")
       table.string("name")
       table.text("description")

package/spec/dummy/src/database/migrations/20250605133926-create-project-translations.mjs

@@ -0,0 +1,16 @@
+import Migration from "../../../../../src/database/migration/index.mjs"
+
+export default class CreateProjectTranslations extends Migration {
+  async up() {
+    await this.createTable("project_translations", (t) => {
+      t.references("project", {null: false})
+      t.string("locale", {null: false})
+      t.string("name")
+      t.timestamps()
+    })
+  }
+
+  async down() {
+    await this.dropTable("project_translations")
+  }
+}

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

@@ -0,0 +1,9 @@
+import DatabaseRecord from "../../../../src/database/record/index.mjs"
+
+class Project extends DatabaseRecord {
+}
+
+Project.hasMany("tasks")
+Project.translates("name")
+
+export default Project

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

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

package/src/big-brother.mjs

@@ -0,0 +1,37 @@
+export default class VelociousBigBrother {
+  constructor() {
+    this.enabledLoggers = {
+      databaseQuery: false
+    }
+  }
+
+  checkExists(name) {
+    if (!(name in this.enabledLoggers)) throw new Error(`Invalid logger name: ${name}`)
+  }
+
+  isEnabled(name) {
+    this.checkExists(name)
+
+    return this.enabledLoggers[name]
+  }
+
+  async run({after, before, name}, callback) {
+    this.checkExists(name)
+
+    if (!this.enabledLoggers[name]) {
+      return await callback()
+    }
+
+    if (before) {
+      before()
+    }
+
+    const startTime = new Date()
+    const result = await callback()
+    const endTime = new Date()
+
+    if (after) {
+      after({result})
+    }
+  }
+}

package/src/cli/commands/db/create.mjs

@@ -39,12 +39,14 @@ export default class DbCreate extends BaseCommand{
 
     schemaMigrationsTable.string("version", {null: false, primaryKey: true})
 
-    const createSchemaMigrationsTableSql = this.databaseConnection.createTableSql(schemaMigrationsTable)
-
-    if (this.args.testing) {
-      this.result.push({createSchemaMigrationsTableSql})
-    } else {
-      await this.databaseConnection.query(createSchemaMigrationsTableSql)
+    const createSchemaMigrationsTableSqls = this.databaseConnection.createTableSql(schemaMigrationsTable)
+
+    for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
+      if (this.args.testing) {
+        this.result.push({createSchemaMigrationsTableSql})
+      } else {
+        await this.databaseConnection.query(createSchemaMigrationsTableSql)
+      }
     }
   }
 }

package/src/cli/commands/db/migrate.mjs

@@ -1,7 +1,6 @@
 import BaseCommand from "../../base-command.mjs"
-import {digg} from "diggerize"
 import fs from "node:fs/promises"
-import inflection from "inflection"
+import * as inflection from "inflection"
 
 export default class DbMigrate extends BaseCommand {
   async execute() {

package/src/cli/commands/generate/migration.mjs

@@ -3,7 +3,7 @@ import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fileExists from "../../../utils/file-exists.mjs"
 import fs from "node:fs/promises"
-import inflection from "inflection"
+import * as inflection from "inflection"
 import strftime from "strftime"
 
 export default class DbGenerateMigration extends BaseCommand {

package/src/cli/commands/generate/model.mjs

@@ -3,7 +3,7 @@ import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fileExists from "../../../utils/file-exists.mjs"
 import fs from "node:fs/promises"
-import inflection from "inflection"
+import * as inflection from "inflection"
 
 export default class DbGenerateModel extends BaseCommand {
   async execute() {

package/src/configuration.mjs

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import restArgsError from "./utils/rest-args-error.mjs"
 
 export default class VelociousConfiguration {
   static current(throwError = true) {
@@ -7,10 +8,19 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({database, debug, directory}) {
+  constructor({database, debug, directory, initializeModels, locale, locales, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!initializeModels) throw new Error("initializeModels wasn't given")
+
     this.database = database
     this.debug = debug
     this._directory = directory
+    this._initializeModels = initializeModels
+    this._isInitialized = false
+    this.locale = locale
+    this.locales = locales
+    this.modelClasses = {}
   }
 
   getDatabasePool() {
@@ -39,6 +49,26 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  getLocale() {
+    if (typeof this.locale == "function") {
+      return this.locale()
+    } else if (this.locale) {
+      return this.locale
+    } else {
+      return this.getLocales()[0]
+    }
+  }
+
+  getLocales = () => digg(this, "locales")
+
+  getModelClass(name) {
+    const modelClass = this.modelClasses[name]
+
+    if (!modelClass) throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(", ")}}`)
+
+    return modelClass
+  }
+
   initializeDatabasePool() {
     if (!this.database) throw new Error("No 'database' was given")
     if (this.databasePool) throw new Error("DatabasePool has already been initialized")
@@ -50,9 +80,15 @@ export default class VelociousConfiguration {
   }
 
   isDatabasePoolInitialized = () => Boolean(this.databasePool)
+  isInitialized = () => this._isInitialized
+
+  async initialize() {
+    await this._initializeModels({configuration: this})
+    this._isInitialized = true
+  }
 
-  initialize() {
-    // Doesn't currently do anything.
+  registerModelClass(modelClass) {
+    this.modelClasses[modelClass.name] = modelClass
   }
 
   setCurrent() {

package/src/database/drivers/base.mjs

@@ -7,9 +7,11 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async createTable(...args) {
-    const sql = this.createTableSql(...args)
+    const sqls = this.createTableSql(...args)
 
-    await this.query(sql)
+    for (const sql of sqls) {
+      await this.query(sql)
+    }
   }
 
   async delete(...args) {
@@ -26,12 +28,29 @@ export default class VelociousDatabaseDriversBase {
     return this.idSeq
   }
 
+  getTables() {
+    throw new Error(`${this.constructor.name}#getTables not implemented`)
+  }
+
+  async getTableByName(name) {
+    const tables = await this.getTables()
+    const table = tables.find((table) => table.getName() == name)
+
+    if (!table) throw new Error(`Couldn't find a table by that name: ${name}`)
+
+    return table
+  }
+
   async insert(...args) {
     const sql = this.insertSql(...args)
 
     await this.query(sql)
   }
 
+  lastInsertID() {
+    throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
+  }
+
   async select(tableName) {
     const handler = new Handler()
     const query = new Query({

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

@@ -0,0 +1,8 @@
+export default class VelociousDatabaseDriversMysqlColumn {
+  constructor(table, data) {
+    this.data = data
+    this.table = table
+  }
+
+  getName = () => this.data["Field"]
+}

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

@@ -9,6 +9,7 @@ import Options from "./options.mjs"
 import mysql from "mysql"
 import query from "./query.mjs"
 import QueryParser from "./query-parser.mjs"
+import Table from "./table.mjs"
 import Update from "./sql/update.mjs"
 
 export default class VelociousDatabaseDriversMysql extends Base{
@@ -64,13 +65,25 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return new QueryParser({query}).toSql()
   }
 
-  quote(string) {
+  escape(string) {
     if (!this.connection) throw new Error("Can't escape before connected")
 
     return this.connection.escape(string)
   }
 
-  quoteColumn(string) {
+  quote(string) {
+    return `${this.escape(string)}`
+  }
+
+  quoteColumn = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `\`${string}\``
+  }
+
+  quoteTable = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
     return `\`${string}\``
   }
 
@@ -86,6 +99,25 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return insert.toSql()
   }
 
+  async getTables() {
+    const result = await this.query("SHOW FULL TABLES")
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table(this, row)
+
+      tables.push(table)
+    }
+
+    return tables
+  }
+
+  async lastInsertID() {
+    const result = await this.query("SELECT LAST_INSERT_ID() AS last_insert_id")
+
+    return digg(result, 0, "last_insert_id")
+  }
+
   options() {
     if (!this._options) {
       this._options = new Options({driver: this})

package/src/database/drivers/mysql/options.mjs

@@ -3,6 +3,7 @@ import QueryParserOptions from "../../query-parser/options.mjs"
 export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
   constructor(options) {
     options.columnQuote = "`"
+    options.indexQuote = "`"
     options.stringQuote = "'"
     options.tableQuote = "`"
 

package/src/database/drivers/mysql/query-parser.mjs

@@ -1,25 +1,4 @@
-import {digs} from "diggerize"
-import FromParser from "../../query-parser/from-parser.mjs"
-import JoinsParser from "../../query-parser/joins-parser.mjs"
-import SelectParser from "../../query-parser/select-parser.mjs"
+import BaseQueryParser from "../../query-parser/base-query-parser.mjs"
 
-export default class VelociousDatabaseConnectionDriversMysqlQueryParser {
-  constructor({pretty, query}) {
-    if (!query) throw new Error("No query given")
-
-    this.pretty = pretty
-    this.query = query
-  }
-
-  toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
-
-    let sql = ""
-
-    sql += new SelectParser({pretty, query}).toSql()
-    sql += new FromParser({pretty, query}).toSql()
-    sql += new JoinsParser({pretty, query}).toSql()
-
-    return sql
-  }
+export default class VelociousDatabaseConnectionDriversMysqlQueryParser extends BaseQueryParser {
 }

package/src/database/drivers/mysql/table.mjs

@@ -0,0 +1,25 @@
+import Column from "./column.mjs"
+
+export default class VelociousDatabaseDriversMysqlTable {
+  constructor(driver, data) {
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    const result = await this.driver.query(`SHOW FULL COLUMNS FROM \`${this.getName()}\``)
+    const columns = []
+
+    for (const data of result) {
+      const column = new Column(this, data)
+
+      columns.push(column)
+    }
+
+    return columns
+  }
+
+  getName() {
+    return Object.values(this.data)[0]
+  }
+}