velocious 1.0.32 → 1.0.34

package/README.md

@@ -1,7 +1,5 @@
 # README
 
-This is still work in progress.
-
 * Concurrent multi threadded web server
 * Database framework ala Rails
 * Database models ala Rails
@@ -19,23 +17,29 @@ npm install velocious
 npx velocious init
 ```
 
-# Migrations
+# Models
 
 ```bash
-npx velocious g:migration create_tasks
+npx velocious g:model Account
+npx velocious g:model Task
 ```
 
-```bash
-npx velocious db:migrate
-```
+```js
+import Record from "velocious/src/database/record/index.js"
 
-# Models
+class Task extends Record {
+}
 
-```bash
-npx velocious g:model Task
+Task.belongsTo("account")
+Task.translates("description", "subTitle", "title")
+
+export default Task
 ```
 
 # Migrations
+
+Make a new migration from a template like this:
+
 ```bash
 npx velocious g:migration create-tasks
 ```
@@ -66,7 +70,12 @@ export default class CreateEvents extends Migration {
 }
 ```
 
-Run migrations from anywhere
+Run migrations from the command line like this:
+```bash
+npx velocious db:migrate
+```
+
+Run migrations from anywhere if you want to:
 
 ```js
 const migrationsPath = `/some/dir/migrations`
@@ -88,6 +97,8 @@ import {Task} from "@/src/models/task"
 const tasks = await Task
   .preload({project: {account: true}})
   .where({projects: {public: true}})
+  .order("name")
+  .limit(5)
   .toArray()
 ```
 
@@ -104,7 +115,7 @@ If you are developing on Velocious, you can run the tests with:
 npm run test
 ```
 
-# Writing a require test
+# Writing a request test
 
 First create a test file under something like the following path 'src/routes/accounts/create-test.js' with something like the following content:
 

package/package.json

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

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

@@ -0,0 +1,10 @@
+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/http-server/get-spec.js

@@ -4,23 +4,27 @@ import Dummy from "../dummy/index.js"
 describe("HttpServer", () => {
   it("handles get requests", async () => {
     await Dummy.run(async () => {
-      const response = await fetch("http://localhost:3006/tasks")
-      const text = await response.text()
+      for (let i = 0; i <= 5; i++) {
+        const response = await fetch("http://localhost:3006/tasks")
+        const text = await response.text()
 
-      expect(response.status).toEqual(200)
-      expect(response.statusText).toEqual("OK")
-      expect(text).toEqual("1, 2, 3, 4, 5\n")
+        expect(response.status).toEqual(200)
+        expect(response.statusText).toEqual("OK")
+        expect(text).toEqual("1, 2, 3, 4, 5\n")
+      }
     })
   })
 
   it("returns a 404 error when a collection action isnt found", async () => {
     await Dummy.run(async () => {
-      const response = await fetch("http://localhost:3006/tasks/doesnt-exist")
-      const text = await response.text()
+      for (let i = 0; i <= 5; i++) {
+        const response = await fetch("http://localhost:3006/tasks/doesnt-exist")
+        const text = await response.text()
 
-      expect(response.status).toEqual(404)
-      expect(response.statusText).toEqual("Not Found")
-      expect(text).toEqual("Not found!\n")
+        expect(response.status).toEqual(404)
+        expect(response.statusText).toEqual("Not Found")
+        expect(text).toEqual("Not found!\n")
+      }
     })
   })
 })

package/spec/http-server/post-spec.js

@@ -7,66 +7,72 @@ import Project from "../dummy/src/models/project.js"
 describe("HttpServer", () => {
   it("handles post requests", async () => {
     await Dummy.run(async () => {
-      const postData = querystring.stringify({"project[name]": "Test create project"})
-      const response = await fetch(
-        "http://localhost:3006/projects",
-        {
-          body: postData,
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Content-Length": Buffer.byteLength(postData)
-          },
-          method: "POST"
-        }
-      )
-      const text = await response.text()
-      const createdProject = await Project.preload({translations: true}).last()
+      for (let i = 0; i <= 5; i++) {
+        const postData = querystring.stringify({"project[name]": "Test create project"})
+        const response = await fetch(
+          "http://localhost:3006/projects",
+          {
+            body: postData,
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+              "Content-Length": Buffer.byteLength(postData)
+            },
+            method: "POST"
+          }
+        )
+        const text = await response.text()
+        const createdProject = await Project.preload({translations: true}).last()
 
-      expect(text).toEqual('{"status":"success"}')
-      expect(createdProject.name()).toEqual("Test create project")
+        expect(text).toEqual('{"status":"success"}')
+        expect(createdProject.name()).toEqual("Test create project")
+      }
     })
   })
 
   it("handles post json requests", async () => {
     await Dummy.run(async () => {
-      const postData = JSON.stringify({project: {name: "Test create project"}})
-      const response = await fetch(
-        "http://localhost:3006/projects",
-        {
-          body: postData,
-          headers: {
-            "Content-Type": "application/json",
-            "Content-Length": Buffer.byteLength(postData)
-          },
-          method: "POST"
-        }
-      )
-      const text = await response.text()
-      const createdProject = await Project.preload({translations: true}).last()
+      for (let i = 0; i <= 5; i++) {
+        const postData = JSON.stringify({project: {name: "Test create project"}})
+        const response = await fetch(
+          "http://localhost:3006/projects",
+          {
+            body: postData,
+            headers: {
+              "Content-Type": "application/json",
+              "Content-Length": Buffer.byteLength(postData)
+            },
+            method: "POST"
+          }
+        )
+        const text = await response.text()
+        const createdProject = await Project.preload({translations: true}).last()
 
-      expect(text).toEqual('{"status":"success"}')
-      expect(createdProject.name()).toEqual("Test create project")
+        expect(text).toEqual('{"status":"success"}')
+        expect(createdProject.name()).toEqual("Test create project")
+      }
     })
   })
 
   it("handles post form-data requests", async () => {
     await Dummy.run(async () => {
-      const body = new FormData()
+      for (let i = 0; i <= 5; i++) {
+        const body = new FormData()
 
-      body.append("project[name]", "Test create project")
+        body.append("project[name]", "Test create project")
 
-      const response = await fetch(
-        "http://localhost:3006/projects",
-        {
-          body,
-          method: "POST"
-        }
-      )
-      const text = await response.text()
-      const createdProject = await Project.preload({translations: true}).last()
+        const response = await fetch(
+          "http://localhost:3006/projects",
+          {
+            body,
+            method: "POST"
+          }
+        )
+        const text = await response.text()
+        const createdProject = await Project.preload({translations: true}).last()
 
-      expect(text).toEqual('{"status":"success"}')
-      expect(createdProject.name()).toEqual("Test create project")
+        expect(text).toEqual('{"status":"success"}')
+        expect(createdProject.name()).toEqual("Test create project")
+      }
     })
   })
 })

package/spec/http-server/root-get-spec.js

@@ -4,23 +4,27 @@ import Dummy from "../dummy/index.js"
 describe("HttpServer", () => {
   it("handles root get requests", async () => {
     await Dummy.run(async () => {
-      const response = await fetch("http://localhost:3006/ping")
-      const text = await response.text()
+      for (let i = 0; i <= 5; i++) {
+        const response = await fetch("http://localhost:3006/ping")
+        const text = await response.text()
 
-      expect(response.status).toEqual(200)
-      expect(response.statusText).toEqual("OK")
-      expect(text).toEqual("{\"message\":\"Pong\"}")
+        expect(response.status).toEqual(200)
+        expect(response.statusText).toEqual("OK")
+        expect(text).toEqual("{\"message\":\"Pong\"}")
+      }
     })
   })
 
   it("returns a 404 error when a root get isn't found", async () => {
     await Dummy.run(async () => {
-      const response = await fetch("http://localhost:3006/doesnt-exist")
-      const text = await response.text()
+      for (let i = 0; i <= 5; i++) {
+        const response = await fetch("http://localhost:3006/doesnt-exist")
+        const text = await response.text()
 
-      expect(response.status).toEqual(404)
-      expect(response.statusText).toEqual("Not Found")
-      expect(text).toEqual("Not found!\n")
+        expect(response.status).toEqual(404)
+        expect(response.statusText).toEqual("Not Found")
+        expect(text).toEqual("Not found!\n")
+      }
     })
   })
 })

package/src/database/record/index.js

@@ -395,10 +395,9 @@ export default class VelociousDatabaseRecord {
     const className = `${this.name}Translation`
     const TranslationClass = class Translation extends VelociousDatabaseRecord {}
     const belongsTo = `${inflection.camelize(inflection.singularize(this.tableName()), true)}`
-    const tableName = `${inflection.singularize(this.tableName())}_translations`
 
     Object.defineProperty(TranslationClass, "name", {value: className})
-    TranslationClass.setTableName(tableName)
+    TranslationClass.setTableName(this.getTranslationsTableName())
     TranslationClass.belongsTo(belongsTo)
 
     this._translationClass = TranslationClass
@@ -407,7 +406,11 @@ export default class VelociousDatabaseRecord {
   }
 
   static getTranslationsTableName() {
-    return `${inflection.singularize(this.tableName())}_translations`
+    const tableNameParts = this.tableName().split("_")
+
+    tableNameParts[tableNameParts.length - 1] = inflection.singularize(tableNameParts[tableNameParts.length - 1])
+
+    return `${tableNameParts.join("_")}_translations`
   }
 
   static async hasTranslationsTable() {

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

@@ -38,10 +38,7 @@ export default class VeoliciousHttpServerClient {
 
   onWrite(data) {
     if (this.state == "initial") {
-      this.currentRequest = new Request({
-        configuration: this.configuration
-      })
-
+      this.currentRequest = new Request({configuration: this.configuration})
       this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest)
       this.currentRequest.feed(data)
       this.state = "requestStarted"

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

@@ -13,8 +13,6 @@ export default class RequestBuffer {
   headers = []
   headersByName = {}
   params = {}
-  postBody = ""
-  postBodyChars = []
   readingBody = false
   state = "status"
 
@@ -74,10 +72,9 @@ export default class RequestBuffer {
 
           break
         case "post-body":
-          this.bodyLength += 1
-          this.postBodyChars.push(char)
+          this.postBodyChars[this.bodyLength - 1] = char
 
-          if (this.contentLength && this.postBodyChars.length >= this.contentLength) {
+          if (this.contentLength && this.bodyLength >= this.contentLength) {
             this.postRequestDone()
           }
 
@@ -157,6 +154,7 @@ export default class RequestBuffer {
         this.completeRequest()
       } else if (this.httpMethod.toUpperCase() == "POST") {
         this.readingBody = true
+        this.bodyLength = 0
 
         const match = this.getHeader("content-type")?.value?.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
 
@@ -168,6 +166,11 @@ export default class RequestBuffer {
           this.multiPartyFormData = true
           this.setState("multi-part-form-data")
         } else {
+          if (!this.contentLength) throw new Error("Content length hasn't been set")
+
+          this.postBodyBuffer = new ArrayBuffer(this.contentLength)
+          this.postBodyChars = new Uint8Array(this.postBodyBuffer)
+
           this.setState("post-body")
         }
       } else {
@@ -190,7 +193,11 @@ export default class RequestBuffer {
   }
 
   postRequestDone() {
-    this.postBody += String.fromCharCode.apply(null, this.postBodyChars)
+    this.postBody = String.fromCharCode.apply(null, this.postBodyChars)
+
+    delete this.postBodyChars
+    delete this.postBodyBuffer
+
     this.parseQueryStringPostParams()
     this.completeRequest()
   }

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

@@ -19,6 +19,13 @@ export default class VelociousHttpServerClientRequestParser {
     this.requestBuffer.events.on("request-done", this.requestDone)
   }
 
+  destroy() {
+    this.requestBuffer.events.off("completed", this.requestDone)
+    this.requestBuffer.events.off("form-data-part", this.onFormDataPart)
+    this.requestBuffer.events.off("request-done", this.requestDone)
+    this.requestBuffer.destroy()
+  }
+
   onFormDataPart = (formDataPart) => {
     const unorderedParams = {}
 
@@ -78,6 +85,7 @@ export default class VelociousHttpServerClientRequestParser {
     const incorporator = new Incorporator({objects: [this.params, this.requestBuffer.params]})
 
     incorporator.merge()
+
     this.state = "done"
     this.events.emit("done")
   }

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

@@ -19,9 +19,13 @@ export default class ServerClient {
 
   close() {
     return new Promise((resolve, reject) => {
-      this.socket.destroy()
-      this.events.emit("close", this)
-      resolve()
+      try {
+        this.socket.destroy()
+        this.events.emit("close", this)
+        resolve()
+      } catch (error) {
+        reject(error)
+      }
     })
   }
 

package/src/routes/resolver.js

@@ -1,7 +1,8 @@
 import {digg, digs} from "diggerize"
+import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fs from "fs/promises"
-import {dirname} from "path"
+import * as inflection from "inflection"
 
 export default class VelociousRoutesResolver {
   constructor({configuration, request, response}) {
@@ -22,7 +23,7 @@ export default class VelociousRoutesResolver {
     let viewPath
 
     const matchResult = this.matchPathWithRoutes(currentRoute, currentPath)
-    let action = this.params.action
+    let action = this.params.action ? inflection.camelize(this.params.action.replaceAll("-", "_"), true) : undefined
     let controller = this.params.controller
 
     if (!matchResult) {

package/src/testing/request-client.js

@@ -5,6 +5,8 @@ class Response {
 
   async parse() {
     this._body = await this.fetchResponse.text()
+
+    if (this.statusCode() != 200) throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`)
   }
 
   body = () => this._body
@@ -16,8 +18,13 @@ export default class RequestClient {
   host = "localhost"
   port = 31006
 
-  get() {
-    throw new Error("get stub")
+  async get(path) {
+    const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`)
+    const response = new Response(fetchResponse)
+
+    await response.parse()
+
+    return response
   }
 
   async post(path, data) {