velocious 1.0.22 → 1.0.24

package/README.md

@@ -32,13 +32,90 @@ npx velocious db:migrate
 # Models
 
 ```bash
-npx velocious g:model Option
+npx velocious g:model Task
+```
+
+# Migrations
+```bash
+npx velocious g:migration create-tasks
+```
+
+```js
+import Migration from "velocious/src/database/migration/index.js"
+
+export default class CreateEvents extends Migration {
+  async up() {
+    await this.createTable("tasks", (t) => {
+      t.timestamps()
+    })
+
+    await this.createTable("task_translations", (t) => {
+      t.references("task", {foreignKey: true, null: false})
+      t.string("locale", {null: false})
+      t.string("name")
+      t.timestamps()
+    })
+
+    await this.addIndex("task_translations", ["task_id", "locale"], {unique: true})
+  }
+
+  async down() {
+    await this.dropTable("task_translations")
+    await this.dropTable("tasks")
+  }
+}
+```
+
+# Querying
+
+```js
+import {Task} from "@/src/models/task"
+
+const tasks = await Task
+  .preload({project: {account: true}})
+  .where({projects: {public: true}})
+  .toArray()
 ```
 
 # Testing
 
+If you are using Velocious for an app, Velocious has a built-in testing framework. You can run your tests like this:
 ```bash
-npm test
+npx velocious test
+```
+
+If you are developing on Velocious, you can run the tests with:
+
+```bash
+npm run test
+```
+
+# Writing a require test
+
+First create a test file under something like the following path 'src/routes/accounts/create-test.js' with something like the following content:
+
+```js
+import {describe, expect, it} from "velocious/src/testing/test.js"
+import Account from "../../models/account.js"
+
+await describe("accounts - create", {type: "request"}, async () => {
+  it("creates an account", async ({client}) => {
+    const response = await client.post("/accounts", {account: {name: "My event company"}})
+
+    expect(response.statusCode()).toEqual(200)
+    expect(response.contentType()).toEqual("application/json")
+
+    const data = JSON.parse(response.body())
+
+    expect(data.status).toEqual("success")
+
+    const createdAccount = await Account.last()
+
+    expect(createdAccount).toHaveAttributes({
+      name: "My event company"
+    })
+  })
+})
 ```
 
 # Running a server

package/package.json

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

package/spec/cli/commands/test/test-files-finder-spec.js

@@ -1,4 +1,4 @@
-import TestFilesFinder from "../../../../src/cli/commands/test/test-files-finder.js"
+import TestFilesFinder from "../../../../src/testing/test-files-finder.js"
 
 describe("Cli - Commands - test - TestFilesFinder", () => {
   it("finds the correct test files", async () => {

package/src/application.js

@@ -43,6 +43,7 @@ export default class VelociousApplication {
     logger(this, `Starting server on port ${port}`)
 
     this.httpServer = new HttpServer({configuration, port})
+    this.httpServer.events.on("close", this.onHttpServerClose)
 
     await this.httpServer.start()
   }
@@ -52,4 +53,18 @@ export default class VelociousApplication {
 
     await this.httpServer.stop()
   }
+
+  onHttpServerClose = () => {
+    console.log("HTTP server closed")
+
+    if (this.waitResolve) {
+      this.waitResolve()
+    }
+  }
+
+  wait() {
+    return new Promise((resolve) => {
+      this.waitResolve = resolve
+    })
+  }
 }

package/src/cli/commands/server.js

@@ -5,10 +5,8 @@ export default class VelociousCliCommandsServer extends BaseCommand{
   async execute() {
     this.databasePool = this.configuration.getDatabasePool()
     this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
-
-    if (this.args.testing) this.result = []
-
     this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+
     await this.databaseConnection.connect()
 
     const host = "0.0.0.0"
@@ -23,7 +21,7 @@ export default class VelociousCliCommandsServer extends BaseCommand{
 
     await application.initialize()
     await application.startHttpServer()
-
     console.log(`Started Velocious HTTP server on ${host}:${port}`)
+    await application.wait()
   }
 }

package/src/cli/commands/{test/index.js → test.js}

@@ -1,13 +1,12 @@
-import BaseCommand from "../../base-command.js"
-import TestFilesFinder from "./test-files-finder.js"
-import TestRunner from "./test-runner.js"
+import BaseCommand from "../base-command.js"
+import TestFilesFinder from "../../testing/test-files-finder.js"
+import TestRunner from "../../testing/test-runner.js"
 
 export default class VelociousCliCommandsInit extends BaseCommand {
   async execute() {
     const testFilesFinder = new TestFilesFinder({directory: this.directory(), processArgs: this.processArgs})
     const testFiles = await testFilesFinder.findTestFiles()
-
-    const testRunner = new TestRunner(testFiles)
+    const testRunner = new TestRunner({configuration: this.configuration, testFiles})
 
     await testRunner.run()
   }

package/src/database/migrate-from-require-context.js

@@ -13,16 +13,27 @@ export default class VelociousDatabaseMigrateFromRequireContext {
 
     const files = requireContext.keys()
       .map((file) => {
-        const match = file.match(/(\d{14})-(.+)\.js$/)
+        // "13,14" because somes "require-context"-npm-module deletes first character!?
+        const match = file.match(/(\d{13,14})-(.+)\.js$/)
 
         if (!match) return null
 
-        const date = parseInt(match[1])
+        // Fix require-context-npm-module deletes first character
+        let fileName = file
+        let dateNumber = match[1]
+
+        if (dateNumber.length == 13) {
+          dateNumber = `2${dateNumber}`
+          fileName = `2${fileName}`
+        }
+
+        // Parse regex
+        const date = parseInt(dateNumber)
         const migrationName = match[2]
         const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
 
         return {
-          file,
+          file: fileName,
           date,
           migrationClassName
         }

package/src/database/use-database.js

@@ -5,29 +5,30 @@ import useEnvSense from "env-sense/src/use-env-sense.js"
 import Configuration from "../configuration.js"
 import restArgsError from "../utils/rest-args-error.js"
 
-const shared = {
-  loaded: false
-}
-
 const loadMigrations = function loadMigrations({migrationsRequireContext, ...restArgs}) {
+  const instance = React.useMemo(() => ({running: false}), [])
   const {isServer} = useEnvSense()
-  const [loaded, setLoaded] = React.useState(shared.loaded)
+  const [loaded, setLoaded] = React.useState(false)
 
   const loadDatabase = React.useCallback(async () => {
-    await Configuration.current().getDatabasePool().withConnection(async () => {
-      const databaseMigrateFromRequireContext = new DatabaseMigrateFromRequireContext()
+    instance.running = true
 
-      await databaseMigrateFromRequireContext.execute(migrationsRequireContext)
-    })
+    try {
+      await Configuration.current().getDatabasePool().withConnection(async () => {
+        const databaseMigrateFromRequireContext = new DatabaseMigrateFromRequireContext()
 
-    await Configuration.current().initialize()
+        await databaseMigrateFromRequireContext.execute(migrationsRequireContext)
+      })
 
-    shared.loaded = true
-    setLoaded(true)
+      await Configuration.current().initialize()
+      setLoaded(true)
+    } finally {
+      instance.running = false
+    }
   }, [])
 
   React.useMemo(() => {
-    if (!loaded && !isServer) {
+    if (!loaded && !isServer && !instance.running) {
       loadDatabase()
     }
   }, [loaded])

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

@@ -157,7 +157,7 @@ export default class RequestBuffer {
       } else if (this.httpMethod.toUpperCase() == "POST") {
         this.readingBody = true
 
-        const match = this.getHeader("content-type").value.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
+        const match = this.getHeader("content-type")?.value?.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
 
         if (match) {
           this.boundary = match[1]

package/src/http-server/index.js

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import EventEmitter from "events"
 import logger from "../logger.js"
 import Net from "net"
 import ServerClient from "./server-client.js"
@@ -7,6 +8,7 @@ import WorkerHandler from "./worker-handler/index.js"
 export default class VelociousHttpServer {
   clientCount = 0
   clients = {}
+  events = new EventEmitter()
   workerCount = 0
   workerHandlers = []
 
@@ -20,6 +22,7 @@ export default class VelociousHttpServer {
   async start() {
     await this._ensureAtLeastOneWorker()
     this.netServer = new Net.Server()
+    this.netServer.on("close", this.onClose)
     this.netServer.on("connection", this.onConnection)
     await this._netServerListen()
   }
@@ -72,6 +75,10 @@ export default class VelociousHttpServer {
     await this.stopServer()
   }
 
+  onClose = () => {
+    this.events.emit("close")
+  }
+
   onConnection = (socket) => {
     const clientCount = this.clientCount
 

package/src/logger.js

@@ -1,5 +1,3 @@
-import {digg} from "diggerize"
-
 export default function log(object, ...messages) {
   if (!object.configuration) console.error(`No configuration on ${object.constructor.name}`)
 

package/src/testing/request-client.js

@@ -0,0 +1,42 @@
+class Response {
+  constructor(fetchResponse) {
+    this.fetchResponse = fetchResponse
+  }
+
+  async parse() {
+    this._body = await this.fetchResponse.text()
+  }
+
+  body = () => this._body
+  contentType = () => this.fetchResponse.headers.get("content-type")
+  statusCode = () => this.fetchResponse.status
+}
+
+export default class RequestClient {
+  host = "localhost"
+  port = 31006
+
+  get() {
+    throw new Error("get stub")
+  }
+
+  async post(path, data) {
+    const fetchResponse = await fetch(
+      `http://${this.host}:${this.port}${path}`,
+      {
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST",
+        signal: AbortSignal.timeout(5000)
+      }
+    )
+
+    const response = new Response(fetchResponse)
+
+    await response.parse()
+
+    return response
+  }
+}

package/src/{cli/commands/test → testing}/test-files-finder.js

@@ -90,7 +90,7 @@ export default class TestFilesFinder {
           return true
         }
       }
-    } else if (file.match(/-spec\.js/)) {
+    } else if (file.match(/-(spec|test)\.js/)) {
       return true
     }
 

package/src/testing/test-runner.js

@@ -0,0 +1,85 @@
+import Application from "../../src/application.js"
+import RequestClient from "./request-client.js"
+import {tests} from "./test.js"
+
+export default class TestRunner {
+  constructor({configuration, testFiles}) {
+    this.configuration = configuration
+    this.testFiles = testFiles
+  }
+
+  async application() {
+    if (!this._application) {
+      this._application = new Application({
+        configuration: this.configuration,
+        databases: {
+          default: {
+            host: "mysql",
+            username: "user",
+            password: ""
+          }
+        },
+        httpServer: {port: 31006}
+      })
+
+      await this._application.initialize()
+      await this._application.startHttpServer()
+    }
+
+    return this._application
+  }
+
+  async requestClient() {
+    if (!this._requestClient) {
+      this._requestClient = new RequestClient()
+    }
+
+    return this._requestClient
+  }
+
+  async importTestFiles() {
+    for (const testFile of this.testFiles) {
+      const importTestFile = await import(testFile)
+    }
+  }
+
+  async run() {
+    await this.importTestFiles()
+    await this.runTests(tests, [], 0)
+  }
+
+  async runTests(tests, descriptions, indentLevel) {
+    const leftPadding = " ".repeat(indentLevel * 2)
+
+    for (const testDescription in tests.tests) {
+      const testData = tests.tests[testDescription]
+      const testArgs = Object.assign({}, testData.args)
+      const testName = descriptions.concat([`it ${testDescription}`]).join(" - ")
+
+      if (testArgs.type == "request") {
+        testArgs.application = await this.application()
+        testArgs.client = await this.requestClient()
+      }
+
+      console.log(`${leftPadding}it ${testDescription}`)
+
+      try {
+        await testData.function(testArgs)
+      } catch (error) {
+        // console.error(`${leftPadding}  Test failed: ${error.message}`)
+        console.error(error.stack)
+      }
+    }
+
+    await this.configuration.getDatabasePool().withConnection(async () => {
+      for (const subDescription in tests.subs) {
+        const subTest = tests.subs[subDescription]
+        const newDecriptions = descriptions.concat([subDescription])
+
+        console.log(`${leftPadding}${subDescription}`)
+
+        await this.runTests(subTest, newDecriptions, indentLevel + 1)
+      }
+    })
+  }
+}

package/src/testing/test.js

@@ -0,0 +1,92 @@
+const tests = {
+  args: {},
+  subs: {},
+  tests: {}
+}
+
+let currentPath = [tests]
+
+class Expect {
+  constructor(object) {
+    this._object = object
+  }
+
+  toEqual(result) {
+    if (this._object != result) {
+      throw new Error(`${this._object} wasn't equal to ${result}`)
+    }
+  }
+
+  toHaveAttributes(result) {
+    const differences = {}
+
+    for (const key in result) {
+      const value = result[key]
+      const objectValue = this._object[key]()
+
+      if (value != objectValue) {
+        differences[key] = [value, objectValue]
+      }
+    }
+
+    if (Object.keys(differences).length > 0)
+    throw new Error(`Object had differet values: ${JSON.stringify(differences)}`)
+  }
+}
+
+async function describe(description, arg1, arg2) {
+  let testArgs, testFunction
+
+  if (typeof arg2 == "function") {
+    testFunction = arg2
+    testArgs = arg1
+  } else if (typeof arg1 == "function") {
+    testFunction = arg1
+    testArgs = {}
+  } else {
+    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)
+  }
+
+  const currentTest = currentPath[currentPath.length - 1]
+  const newTestArgs = Object.assign({}, currentTest.args, testArgs)
+
+  if (description in currentTest.subs) {
+    throw new Error(`Duplicate test description: ${description}`)
+  }
+
+  const newTestData = {args: newTestArgs, subs: {}, tests: {}}
+
+  currentTest.subs[description] = newTestData
+  currentPath.push(newTestData)
+
+  try {
+    await testFunction()
+  } finally {
+    currentPath.pop()
+  }
+}
+
+function expect(arg) {
+  return new Expect(arg)
+}
+
+function it(description, arg1, arg2) {
+  const currentTest = currentPath[currentPath.length - 1]
+  let testArgs, testFunction
+
+  if (typeof arg1 == "function") {
+    testFunction = arg1
+    testArgs = {}
+  } else if (typeof arg2 == "function") {
+    testFunction = arg2
+    testArgs = arg1
+  } else {
+    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
+  }
+
+  const newTestArgs = Object.assign({}, currentTest.args, testArgs)
+
+  currentTest.tests[description] = {args: newTestArgs, function: testFunction}
+}
+
+export {describe, expect, it, tests}

package/src/cli/commands/test/test-runner.js

@@ -1,19 +0,0 @@
-export default class TestRunner {
-  constructor(testFiles) {
-    this.testFiles = testFiles
-  }
-
-  async importTestFiles() {
-    for (const testFile of this.testFiles) {
-      const importTestFile = await import(testFile)
-    }
-  }
-
-  async run() {
-    await this.importTestFiles()
-
-    console.log({foundTestFiles: this.testFiles})
-
-    throw new Error("stub")
-  }
-}