velocious 1.0.2 → 1.0.4

package/src/database/query/delete-base.mjs

@@ -1,15 +1,9 @@
-export default class VelociousDatabaseQueryDeleteBase {
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
   constructor({conditions, driver, tableName}) {
+    super({driver})
     this.conditions = conditions
-    this.driver = driver
     this.tableName = tableName
   }
-
-  getOptions() {
-    return this.driver.options()
-  }
-
-  toSql() {
-    throw new Error("'toSql' wasn't implemented")
-  }
 }

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

@@ -1,12 +1,10 @@
 import FromBase from "./from-base.mjs"
 
 export default class VelociousDatabaseQueryFromPlain extends FromBase {
-  constructor({plain}) {
-    super()
+  constructor({driver, plain}) {
+    super({driver})
     this.plain = plain
   }
 
-  toSql() {
-    return this.plain
-  }
+  toSql = () => this.plain
 }

package/src/database/query/from-table.mjs

@@ -1,8 +1,8 @@
 import FromBase from "./from-base.mjs"
 
 export default class VelociousDatabaseQueryFromTable extends FromBase {
-  constructor({tableName}) {
-    super()
+  constructor({driver, tableName}) {
+    super({driver})
     this.tableName = tableName
   }
 

package/src/database/record/index.mjs

@@ -1,4 +1,4 @@
-import DatabasePool from "../pool/index.mjs"
+import Configuration from "../../configuration.mjs"
 import Handler from "../handler.mjs"
 import inflection from "inflection"
 import Query from "../query/index.mjs"
@@ -6,7 +6,7 @@ import RecordNotFoundError from "./record-not-found-error.mjs"
 
 export default class VelociousDatabaseRecord {
   static connection() {
-    const connection = DatabasePool.current().singleConnection()
+    const connection = Configuration.current().getDatabasePoolType().current().getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 

package/src/database/table-data/index.mjs

@@ -0,0 +1,83 @@
+class TableColumn {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+class TableIndex {
+  constructor(columns, args) {
+    this.args = args
+    this.columns = columns
+  }
+
+  getColumns = () => this.columns
+  getName = () => this.args.name
+  getUnique = () => Boolean(this.args.unique)
+}
+
+class TableReference {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+export default class TableData {
+  _columns = []
+  _indexes = []
+  _references = []
+
+  constructor(name, args = {}) {
+    this.args = args
+    this._name = name
+  }
+
+  getColumns = () => this._columns
+  getName = () => this._name
+  getIfNotExists = () => this.args.ifNotExists
+  getIndexes = () => this._indexes
+  getReferences = () => this._references
+
+  bigint(name, args = {}) {
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  references(name, args = {}) {
+    const columnName = `${name}_id`
+    const indexName = `index_on_${columnName}`
+    const reference = new TableReference(name, args)
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(columnName, columnArgs)
+    const index = new TableIndex([column], {name: indexName})
+
+    this._columns.push(column)
+    this._indexes.push(index)
+    this._references.push(reference)
+  }
+
+  string(name, args) {
+    const columnArgs = Object.assign({type: "string"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  text(name, args) {
+    const columnArgs = Object.assign({type: "text"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  timestamps() {
+    const createdAtColumn = new TableColumn("created_at", {type: "datetime"})
+    const updatedAtColumn = new TableColumn("updated_at", {type: "datetime"})
+
+    this._columns.push(createdAtColumn)
+    this._columns.push(updatedAtColumn)
+  }
+}

package/src/http-server/worker-handler/index.mjs

@@ -13,7 +13,8 @@ export default class VelociousHttpServerWorker {
 
   async start() {
     return new Promise((resolve) => {
-      const {debug, directory} = digs(this.configuration, "debug", "directory")
+      const {debug} = digs(this.configuration, "debug")
+      const directory = this.configuration.getDirectory()
       const __filename = fileURLToPath(import.meta.url)
       const __dirname = dirname(__filename)
 

package/src/http-server/worker-handler/worker-thread.mjs

@@ -1,32 +1,40 @@
 import Application from "../../application.mjs"
 import Client from "../client/index.mjs"
-import DatabasePool from "../../database/pool/index.mjs"
 import {digg, digs} from "diggerize"
 import errorLogger from "../../error-logger.mjs"
 import logger from "../../logger.mjs"
 
 export default class VelociousHttpServerWorkerHandlerWorkerThread {
   constructor({parentPort, workerData}) {
-    const {debug, directory, workerCount} = digs(workerData, "debug", "directory", "workerCount")
+    const {workerCount} = digs(workerData, "workerCount")
 
-    this.application = new Application({debug, directory})
-    this.databasePool = DatabasePool.current()
     this.clients = {}
-    this.configuration = this.application.configuration
     this.parentPort = parentPort
+    this.workerData = workerData
     this.workerCount = workerCount
 
     parentPort.on("message", errorLogger(this.onCommand))
 
-    logger(this, `Worker ${workerCount} started`)
-
-    this.application.initialize().then(() => {
-      this.databasePool.connect().then(() => {
+    this.initialize().then(() => {
+      this.application.initialize().then(() => {
+        logger(this, `Worker ${workerCount} started`)
         parentPort.postMessage({command: "started"})
       })
     })
   }
 
+  async initialize() {
+    const {debug, directory} = digs(this.workerData, "debug", "directory")
+    const configurationPath = `${this.workerData.directory}/src/config/configuration.mjs`
+    const configurationImport = await import(configurationPath)
+    const configuration = configurationImport.default
+
+    this.application = new Application({configuration, debug, directory})
+
+    this.configuration = configuration
+    this.configuration.setCurrent()
+  }
+
   onCommand = (data) => {
     logger(this, `Worker ${this.workerCount} received command`, data)
 

package/src/routes/app-routes.mjs

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousRoutesAppRoutes {
+  static async getRoutes(configuration) {
+    // Every client need to make their own routes because they probably can't be shared across different worker threads
+    const routesImport = await import(`${configuration.getDirectory()}/src/config/routes.mjs`)
+
+    return digg(routesImport, "default", "routes")
+  }
+}

package/src/routes/resolver.mjs

@@ -21,7 +21,7 @@ export default class VelociousRoutesResolver {
     if (!matchResult) throw new Error(`Couldn't match a route with the given path: ${currentPath}`)
 
     if (this.params.action && this.params.controller) {
-      const controllerPath = `${digg(this, "configuration", "directory")}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
+      const controllerPath = `${this.configuration.getDirectory()}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
       const controllerClassImport = await import(controllerPath)
       const controllerClass = controllerClassImport.default
       const controllerInstance = new controllerClass({
@@ -35,7 +35,9 @@ export default class VelociousRoutesResolver {
         throw new Error(`Missing action on controller: ${this.params.controller}#${this.params.action}`)
       }
 
-      await controllerInstance[this.params.action]()
+      await this.configuration.getDatabasePool().withConnection(async () => {
+        await controllerInstance[this.params.action]()
+      })
 
       return
     }

package/src/spec/index.mjs

@@ -0,0 +1,5 @@
+export default class VelocuiousSpec {
+  static describe(description) {
+    throw new Error("stub", description)
+  }
+}

package/src/templates/configuration.mjs

@@ -0,0 +1,19 @@
+import AsyncTrackedMultiConnection from "velocious/src/database/pool/async-tracked-multi-connection.mjs"
+import Configuration from "velocious/src/configuration.mjs"
+import MysqlDriver from "velocious/src/database/drivers/mysql/index.mjs"
+
+export default new Configuration({
+  database: {
+    default: {
+      master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "database"
+      }
+    }
+  }
+})

package/src/templates/generate-migration.mjs

@@ -0,0 +1,11 @@
+import Migration from "velocious/src/database/migration/index.mjs"
+
+export default class __MIGRATION_NAME__ extends Migration {
+  async up() {
+    await this.connection().execute("...")
+  }
+
+  async down() {
+    await this.connection().execute("...")
+  }
+}

package/src/templates/generate-model.mjs

@@ -0,0 +1,4 @@
+import Record from "velocious/src/database/record/index.mjs"
+
+export default class __MODEL_NAME__ extends Record {
+}

package/src/templates/routes.mjs

@@ -0,0 +1,11 @@
+import Routes from "velocious/src/routes/index.mjs"
+
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+})
+
+export default {routes}

package/src/utils/file-exists.mjs

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises"
+
+const fileExists = async (path) => {
+  try {
+    await fs.access(path)
+
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export default fileExists

package/spec/cli/generate/migration-spec.mjs

@@ -1,9 +0,0 @@
-import Cli from "../../../src/cli/index.mjs"
-
-describe("Cli - generate - migration", () => {
-  it("generates a new migration", async () => {
-    const cli = new Cli()
-
-    await cli.execute({args: ["g:migration", "create_tasks"]})
-  })
-})

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

@@ -1,15 +0,0 @@
-const databaseConfiguration = () => {
-  return {
-    "default": {
-      "master": {
-        "type": "mysql",
-        "host": "mariadb",
-        "username": "username",
-        "password": "password",
-        "database": "velocious_test"
-      }
-    }
-  }
-}
-
-export {databaseConfiguration}

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

@@ -1,15 +0,0 @@
-const databaseConfiguration = () => {
-  return {
-    "default": {
-      "master": {
-        "type": "mysql",
-        "host": "mariadb",
-        "username": "peakflow",
-        "password": "password",
-        "database": "velocious_test"
-      }
-    }
-  }
-}
-
-export {databaseConfiguration}

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

@@ -1,12 +0,0 @@
-import {Database} from "../../../../index.mjs"
-
-export default class CreateTasks extends Database.Migration {
-  change() {
-    this.createTable("tasks", (table) => {
-      table.bigint("id", {autoIncrement: true, primaryKey: true})
-      table.string("name")
-      table.text("description")
-      table.timestamps()
-    })
-  }
-}

package/src/database/pool/index.mjs

@@ -1,43 +0,0 @@
-import Configuration from "../../configuration.mjs"
-import {digg} from "diggerize"
-
-export default class VelociousDatabasePool {
-  static current() {
-    if (!global.velociousDatabasePool) global.velociousDatabasePool = new VelociousDatabasePool()
-
-    return global.velociousDatabasePool
-  }
-
-  async connect() {
-    if (this.connection) {
-      console.warn("DatabasePoool#connect: Already connected")
-    } else {
-      this.connection = await this.spawnConnection()
-
-      if (!this.connection) throw new Error("spawnConnection didn't set a connection")
-
-      await this.connection.connect()
-    }
-  }
-
-  isConnected = () => Boolean(this.connection)
-
-  singleConnection() {
-    if (!this.connection) throw new Error("Not connected")
-
-    return this.connection
-  }
-
-  async spawnConnection() {
-    const databaseConfigPath = `${Configuration.current().directory}/src/config/database.mjs`
-    const {databaseConfiguration} = await import(databaseConfigPath)
-    const config = databaseConfiguration()
-    const defaultConfig = digg(config, "default", "master")
-    const driverPath = `../drivers/${digg(defaultConfig, "type")}/index.mjs`
-    const DriverClassImport = await import(driverPath)
-    const DriverClass = DriverClassImport.default
-    const connection = new DriverClass(defaultConfig)
-
-    return connection
-  }
-}