velocious 1.0.19 → 1.0.21

package/README.md

@@ -40,3 +40,9 @@ npx velocious g:model Option
 ```bash
 npm test
 ```
+
+# Running a server
+
+```bash
+npx velocious server
+```

package/bin/velocious.js

@@ -6,3 +6,5 @@ const processArgs = process.argv.slice(2)
 const cli = new Cli({processArgs})
 
 await cli.execute()
+
+process.exit(0)

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",

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

@@ -18,11 +18,12 @@ describe("Cli - Commands - db:migrate", () => {
       await db.query("DROP TABLE IF EXISTS tasks")
       await db.query("DROP TABLE IF EXISTS project_translations")
       await db.query("DROP TABLE IF EXISTS projects")
+      await db.query("DROP TABLE IF EXISTS schema_migrations")
     })
 
     await cli.execute()
 
-    let projectForeignKey, tablesResult
+    let projectForeignKey, schemaMigrations, tablesResult
 
     await dbPool.withConnection(async (db) => {
       const tables = await db.getTables()
@@ -33,12 +34,15 @@ describe("Cli - Commands - db:migrate", () => {
       const foreignKeys = await table.getForeignKeys()
 
       projectForeignKey = foreignKeys.find((foreignKey) => foreignKey.getColumnName() == "project_id")
+
+      schemaMigrations = (await db.query("SELECT * FROM schema_migrations ORDER BY version")).map((schemaMigration) => schemaMigration.version)
     })
 
     expect(tablesResult).toEqual(
       [
         "project_translations",
         "projects",
+        "schema_migrations",
         "tasks"
       ]
     )
@@ -47,5 +51,7 @@ describe("Cli - Commands - db:migrate", () => {
     expect(projectForeignKey.getColumnName()).toEqual("project_id")
     expect(projectForeignKey.getReferencedTableName()).toEqual("projects")
     expect(projectForeignKey.getReferencedColumnName()).toEqual("id")
+
+    expect(schemaMigrations).toEqual(["20230728075328", "20230728075329", "20250605133926"])
   })
 })

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

@@ -1,6 +1,7 @@
 import BaseCommand from "../../base-command.js"
 import fs from "node:fs/promises"
 import * as inflection from "inflection"
+import Migrator from "../../../database/migrator.js"
 
 export default class DbMigrate extends BaseCommand {
   async execute() {
@@ -8,6 +9,10 @@ export default class DbMigrate extends BaseCommand {
     const migrationsPath = `${projectPath}/src/database/migrations`
     let files = await fs.readdir(migrationsPath)
 
+    this.migrator = new Migrator({configuration: this.configuration})
+
+    await this.migrator.prepare()
+
     files = files
       .map((file) => {
         const match = file.match(/^(\d{14})-(.+)\.js$/)
@@ -16,7 +21,7 @@ export default class DbMigrate extends BaseCommand {
 
         const date = parseInt(match[1])
         const migrationName = match[2]
-        const migrationClassName = inflection.camelize(migrationName)
+        const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
 
         return {
           file,
@@ -29,7 +34,9 @@ export default class DbMigrate extends BaseCommand {
       .sort((migration1, migration2) => migration1.date - migration2.date)
 
     for (const migration of files) {
-      await this.runMigrationFile(migration)
+      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
+        await this.runMigrationFile(migration)
+      }
     }
   }
 
@@ -57,7 +64,9 @@ export default class DbMigrate extends BaseCommand {
       .sort((migration1, migration2) => migration1.date - migration2.date)
 
     for (const migration of files) {
-      await this.runMigrationFileFromRequireContext(migration, requireContext)
+      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
+        await this.runMigrationFileFromRequireContext(migration, requireContext)
+      }
     }
   }
 
@@ -65,7 +74,7 @@ export default class DbMigrate extends BaseCommand {
     if (!this.configuration) throw new Error("No configuration set")
     if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
 
-    await this.configuration.getDatabasePool().withConnection(async () => {
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
       const MigrationClass = requireContext(migration.file).default
       const migrationInstance = new MigrationClass({
         configuration: this.configuration
@@ -78,6 +87,8 @@ export default class DbMigrate extends BaseCommand {
       } else {
         throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
       }
+
+      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
     })
   }
 
@@ -85,7 +96,7 @@ export default class DbMigrate extends BaseCommand {
     if (!this.configuration) throw new Error("No configuration set")
     if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
 
-    await this.configuration.getDatabasePool().withConnection(async () => {
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
       const migrationImport = await import(migration.fullPath)
       const MigrationClass = migrationImport.default
       const migrationInstance = new MigrationClass({
@@ -99,6 +110,8 @@ export default class DbMigrate extends BaseCommand {
       } else {
         throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
       }
+
+      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
     })
   }
 }

package/src/cli/commands/init.js

@@ -22,7 +22,9 @@ export default class VelociousCliCommandsInit extends BaseCommand {
     ]
     const paths = [
       projectConfigPath,
-      `${projectPath}/database/migrations`
+      `${projectPath}/database/migrations`,
+      `${projectPath}/models`,
+      `${projectPath}/routes`
     ]
 
     if (this.args.testing) {

package/src/cli/commands/server.js

@@ -1,6 +1,7 @@
+import Application from "../../application.js"
 import BaseCommand from "../base-command.js"
 
-export default class DbCreate extends BaseCommand{
+export default class VelociousCliCommandsServer extends BaseCommand{
   async execute() {
     this.databasePool = this.configuration.getDatabasePool()
     this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
@@ -10,6 +11,19 @@ export default class DbCreate extends BaseCommand{
     this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
     await this.databaseConnection.connect()
 
-    throw new Error("stub")
+    const host = "0.0.0.0"
+    const port = 3006
+    const application = new Application({
+      configuration: this.configuration,
+      httpServer: {
+        host,
+        port
+      }
+    })
+
+    await application.initialize()
+    await application.startHttpServer()
+
+    console.log(`Started Velocious HTTP server on ${host}:${port}`)
   }
 }

package/src/cli/index.js

@@ -1,6 +1,8 @@
-import configurationResolver from "../configuration-resolver.js"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
+import fs from "fs/promises"
+
+import configurationResolver from "../configuration-resolver.js"
 import fileExists from "../utils/file-exists.js"
 
 export default class VelociousCli {
@@ -9,11 +11,11 @@ export default class VelociousCli {
   }
 
   async execute() {
-    const __filename = fileURLToPath(`${import.meta.url}/../..`)
-    const __dirname = dirname(__filename)
+    const __filename = fileURLToPath(import.meta.url)
+    const basePath = await fs.realpath(`${dirname(__filename)}/../..`)
     const commandParts = this.args.processArgs[0].split(":")
     const filePaths = []
-    let filePath = `${__dirname}/src/cli/commands`
+    let filePath = `${basePath}/src/cli/commands`
 
     for (let commandPart of commandParts) {
       if (commandPart == "d") commandPart = "destroy"

package/src/configuration.js

@@ -11,8 +11,6 @@ export default class VelociousConfiguration {
   constructor({database, debug, directory, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
     restArgsError(restArgs)
 
-    if (!initializeModels) throw new Error("initializeModels wasn't given")
-
     this.database = database
     this.debug = debug
     this._directory = directory
@@ -99,7 +97,10 @@ export default class VelociousConfiguration {
   isInitialized = () => this._isInitialized
 
   async initialize() {
-    await this._initializeModels({configuration: this})
+    if (this._initializeModels) {
+      await this._initializeModels({configuration: this})
+    }
+
     this._isInitialized = true
   }
 

package/src/controller.js

@@ -1,32 +1,46 @@
-import {digg, digs} from "diggerize"
+import {digs} from "diggerize"
 import ejs from "ejs"
+import * as inflection from "inflection"
+import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousController {
-  constructor({configuration, params, request, response}) {
+  constructor({action, configuration, controller, params, request, response, viewPath}) {
+    if (!action) throw new Error("No action given")
     if (!configuration) throw new Error("No configuration given")
+    if (!controller) throw new Error("No controller given")
     if (!params) throw new Error("No params given")
     if (!request) throw new Error("No request given")
     if (!response) throw new Error("No response given")
+    if (!viewPath) throw new Error("No viewPath given")
 
+    this._action = action
+    this._controller = controller
     this._configuration = configuration
     this._params = params
     this._request = request
     this._response = response
     this.viewParams = {}
+    this._viewPath = viewPath
   }
 
   params = () => this._params
 
-  render(args = {}) {
-    if (args.json) {
-      return this.renderJsonArg(args)
+  render({json, status, ...restArgs} = {}) {
+    restArgsError(restArgs)
+
+    if (json) {
+      return this.renderJsonArg(json)
+    }
+
+    if (status) {
+      this._response.setStatus(status)
     }
 
     return this.renderView()
   }
 
-  renderJsonArg(args) {
-    const body = JSON.stringify(args.json)
+  renderJsonArg(json) {
+    const body = JSON.stringify(json)
 
     this._response.addHeader("Content-Type", "application/json")
     this._response.setBody(body)
@@ -34,10 +48,7 @@ export default class VelociousController {
 
   renderView() {
     return new Promise((resolve, reject) => {
-      const actionName = digg(this, "_params", "action")
-      const controllerName = digg(this, "_params", "controller")
-      const directory = digg(this, "_configuration").getDirectory()
-      const viewPath = `${directory}/src/routes/${controllerName}/${actionName}.ejs`
+      const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`
       const {viewParams} = digs(this, "viewParams")
 
       ejs.renderFile(viewPath, viewParams, {}, (err, str) => {

package/src/http-server/client/index.js

@@ -14,12 +14,14 @@ export default class VeoliciousHttpServerClient {
     this.clientCount = clientCount
     this.configuration = configuration
     this.onExecuteRequest = onExecuteRequest
+    this.requestRunners = []
   }
 
   executeCurrentRequest = () => {
     logger(this, "executeCurrentRequest")
 
-    this.state = "response"
+    // We are done parsing the given request and can theoretically start parsing a new one, before the current request is done - so reset the state.
+    this.state = "initial"
 
     const requestRunner = new RequestRunner({
       configuration: this.configuration,
@@ -27,7 +29,9 @@ export default class VeoliciousHttpServerClient {
       routes: this.routes
     })
 
-    requestRunner.events.on("done", this.sendResponse)
+    this.requestRunners.push(requestRunner)
+
+    requestRunner.events.on("done", this.requestDone)
     requestRunner.run()
   }
 
@@ -42,7 +46,24 @@ export default class VeoliciousHttpServerClient {
     } else if (this.state == "requestStarted") {
       this.currentRequest.feed(data)
     } else {
-      throw new Error(`Unknown state: ${this.state}`)
+      throw new Error(`Unknown state for client: ${this.state}`)
+    }
+  }
+
+  requestDone = () => {
+    this.sendDoneRequests()
+  }
+
+  sendDoneRequests() {
+    while (true) {
+      const requestRunner = this.requestRunners[0]
+
+      if (requestRunner?.getState() == "done") {
+        this.requestRunners.shift()
+        this.sendResponse(requestRunner)
+      } else {
+        break
+      }
     }
   }
 
@@ -58,7 +79,7 @@ export default class VeoliciousHttpServerClient {
 
     let headers = ""
 
-    headers += "HTTP/1.1 200 OK\r\n"
+    headers += `HTTP/1.1 ${response.getStatusCode()} ${response.getStatusMessage()}\r\n`
 
     for (const headerKey in response.headers) {
       for (const headerValue of response.headers[headerKey]) {

package/src/http-server/client/request-buffer/index.js

@@ -82,7 +82,7 @@ export default class RequestBuffer {
 
           break
         default:
-          console.error(`Unknown state: ${this.state}`)
+          console.error(`Unknown state for request buffer: ${this.state}`)
       }
     }
   }
@@ -128,7 +128,7 @@ export default class RequestBuffer {
         this.setState("multi-part-form-data-body")
       }
     } else {
-      throw new Error(`Unknown state: ${this.state}`)
+      throw new Error(`Unknown state parsing line: ${this.state}`)
     }
   }
 
@@ -200,7 +200,7 @@ export default class RequestBuffer {
   }
 
   completeRequest = () => {
-    this.state = "completed"
+    this.state = "status" // Reset state to new request
 
     if (this.getHeader("content-type")?.value?.startsWith("application/json")) {
       this.parseApplicationJsonParams()

package/src/http-server/client/request-runner.js

@@ -13,8 +13,11 @@ export default class VelociousHttpServerClientRequestRunner {
     this.configuration = configuration
     this.request = request
     this.response = new Response({configuration})
+    this.state = "running"
   }
 
+  getState = () => this.state
+
   async run() {
     if (!this.request) throw new Error("No request?")
 
@@ -27,6 +30,7 @@ export default class VelociousHttpServerClientRequestRunner {
     })
 
     await routesResolver.resolve()
+    this.state = "done"
     this.events.emit("done", this)
   }
 }

package/src/http-server/client/response.js

@@ -22,7 +22,24 @@ export default class VelociousHttpServerClientResponse {
     throw new Error("No body has been set")
   }
 
+  getStatusCode() {
+    return this.statusCode || 200
+  }
+
+  getStatusMessage() {
+    return this.statusMessage || "OK"
+  }
+
   setBody(value) {
     this.body = value
   }
+
+  setStatus(status) {
+    if (status == "not-found" || status == 404) {
+      this.statusCode = 404
+      this.statusMessage = "Not Found"
+    } else {
+      throw new Error(`Unhandled status: ${status}`)
+    }
+  }
 }

package/src/routes/built-in/errors/controller.js

@@ -0,0 +1,7 @@
+import Controller from "../../../controller.js"
+
+export default class BuiltInErrorsController extends Controller {
+  async notFound() {
+    this.render({status: "not-found"})
+  }
+}

package/src/routes/built-in/errors/not-found.ejs

@@ -0,0 +1 @@
+Not found!

package/src/routes/resolver.js

@@ -1,4 +1,7 @@
 import {digg, digs} from "diggerize"
+import {fileURLToPath} from "url"
+import fs from "fs/promises"
+import {dirname} from "path"
 
 export default class VelociousRoutesResolver {
   constructor({configuration, request, response}) {
@@ -13,36 +16,49 @@ export default class VelociousRoutesResolver {
   }
 
   async resolve() {
+    let controllerPath
     let currentRoute = digg(this, "configuration", "routes", "rootRoute")
     let currentPath = this.request.path()
+    let viewPath
 
     const matchResult = this.matchPathWithRoutes(currentRoute, currentPath)
+    let action = this.params.action
+    let controller = this.params.controller
+
+    if (!matchResult) {
+      const __filename = fileURLToPath(import.meta.url)
+      const __dirname = dirname(__filename)
+
+      controller = "errors"
+      controllerPath = "./built-in/errors/controller.js"
+      action = "notFound"
+      viewPath = await fs.realpath(`${__dirname}/built-in/errors`) // eslint-disable-line no-undef
+    } else if (action && controller) {
+      controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`
+      viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`
+    } else {
+      throw new Error(`Matched the route but didn't know what to do with it: ${currentPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`)
+    }
 
-    if (!matchResult) throw new Error(`Couldn't match a route with the given path: ${currentPath}`)
-
-    if (this.params.action && this.params.controller) {
-      const controllerPath = `${this.configuration.getDirectory()}/src/routes/${digg(this, "params", "controller")}/controller.js`
-      const controllerClassImport = await import(controllerPath)
-      const controllerClass = controllerClassImport.default
-      const controllerInstance = new controllerClass({
-        configuration: this.configuration,
-        params: this.params,
-        request: this.request,
-        response: this.response
-      })
-
-      if (!(this.params.action in controllerInstance)) {
-        throw new Error(`Missing action on controller: ${this.params.controller}#${this.params.action}`)
-      }
-
-      await this.configuration.getDatabasePool().withConnection(async () => {
-        await controllerInstance[this.params.action]()
-      })
-
-      return
+    const controllerClassImport = await import(controllerPath)
+    const controllerClass = controllerClassImport.default
+    const controllerInstance = new controllerClass({
+      action,
+      configuration: this.configuration,
+      controller,
+      params: this.params,
+      request: this.request,
+      response: this.response,
+      viewPath
+    })
+
+    if (!(action in controllerInstance)) {
+      throw new Error(`Missing action on controller: ${controller}#${action}`)
     }
 
-    throw new Error(`Matched the route but didn't know what to do with it: ${currentPath}`)
+    await this.configuration.getDatabasePool().withConnection(async () => {
+      await controllerInstance[action]()
+    })
   }
 
   matchPathWithRoutes(route, path) {