velocious 1.0.67 → 1.0.68

package/README.md

@@ -62,14 +62,51 @@ await project.loadTasks()
 const tasks = project.tasks().loaded()
 ```
 
+### Create records
+
+```js
+const task = new Task({identifier: "task-4"})
+
+task.assign({name: "New task})
+
+await task.save()
+```
+
+```js
+const task = await Task.create({name: "Task 4"})
+```
+
+### Find or create records
+
+```js
+const task = await Task.findOrInitializeBy({identifier: "task-5"})
+
+if (task.isNewRecord()) {
+  console.log("Task didn't already exist")
+
+  await task.save()
+}
+
+if (task.isPersisted()) {
+  console.log("Task already exist")
+}
+```
+
+```js
+const task = await Task.findOrCreateBy({identifier: "task-5"}, (newTask) => {
+  newTask.assign({description: "This callback only happens if not already existing"})
+})
+```
+
 # Migrations
 
-Make a new migration from a template like this:
+## Make a new migration from a template
 
 ```bash
 npx velocious g:migration create-tasks
 ```
 
+## Write a migration
 ```js
 import Migration from "velocious/src/database/migration/index.js"
 
@@ -96,12 +133,13 @@ export default class CreateEvents extends Migration {
 }
 ```
 
-Run migrations from the command line like this:
+## Run migrations from the command line
+
 ```bash
 npx velocious db:migrate
 ```
 
-Run migrations from anywhere if you want to:
+## Run migrations from anywhere if you want to:
 
 ```js
 const migrationsPath = `/some/dir/migrations`
@@ -122,7 +160,10 @@ import {Task} from "@/src/models/task"
 
 const tasks = await Task
   .preload({project: {account: true}})
+  .joins({project: true})
   .where({projects: {public: true}})
+  .joins("JOIN task_details ON task_details.task_id = tasks.id")
+  .where("task_details.id IS NOT NULL")
   .order("name")
   .limit(5)
   .toArray()
@@ -138,7 +179,7 @@ npx velocious test
 If you are developing on Velocious, you can run the tests with:
 
 ```bash
-npm run test
+./run-tests.sh
 ```
 
 # Writing a request test
@@ -169,8 +210,63 @@ await describe("accounts - create", {type: "request"}, async () => {
 })
 ```
 
+# Routes
+
+Create or edit the file `src/config/routes.js` and do something like this:
+
+```js
+import Routes from "velocious/src/routes/index.js"
+
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("projects")
+
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+
+  route.namespace("testing", (route) => {
+    route.post("truncate")
+  })
+
+  route.get("ping")
+})
+
+export default {routes}
+```
+
+# Controllers
+
+Create the file `src/routes/testing/controller.js` and do something like this:
+
+```js
+import Controller from "velocious/src/controller.js"
+
+export default class TestingController extends Controller {
+  async truncate() {
+    await doSomething()
+    this.renderJson({status: "database-truncated"})
+  }
+
+  async anotherAction() {
+    render("test-view")
+  }
+}
+```
+
+# Views
+
+Create the file `src/routes/testing/another-action.ejs` and so something like this:
+
+```ejs
+<p>
+  View for path: <%= controller.getRequest().path() %>
+</p>
+```
+
 # Running a server
 
 ```bash
-npx velocious server
+npx velocious server --host 0.0.0.0 --port 8082
 ```

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.67",
+  "version": "1.0.68",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",

package/spec/database/record/find-or-create-spec.js

@@ -0,0 +1,59 @@
+import Dummy from "../../dummy/index.js"
+import Task from "../../dummy/src/models/task.js"
+
+describe("Record - find or create", () => {
+  it("doesnt find but then creates a record", async () => {
+    await Dummy.run(async () => {
+      const task = await Task.findOrCreateBy({name: "Test task"}, (newTask) => {
+        const project = newTask.buildProject({nameEn: "Test project", nameDe: "Test projekt"})
+
+        project.buildProjectDetail({note: "Test note"})
+      })
+
+      const project = task.project()
+
+      expect(task.isPersisted()).toBeTrue()
+      expect(task.isNewRecord()).toBeFalse()
+      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")
+      expect(project.createdAt()).toBeInstanceOf(Date)
+      expect(project.updatedAt()).toBeInstanceOf(Date)
+
+      // 'name' is not a column but rather a column on the translation data model.
+      expect(() => project.readColumn("name")).toThrowError("No such attribute or not selected Project#name")
+
+
+      // It saves a project note through a has one relationship
+      const projectDetail = project.projectDetail()
+
+      expect(projectDetail.isNewRecord()).toBeFalse()
+      expect(projectDetail.isPersisted()).toBeTrue()
+      expect(projectDetail.note()).toEqual("Test note")
+      expect(projectDetail.projectId()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-one-relationship
+      const projectInstanceRelationship = projectDetail.getRelationshipByName("project")
+
+      expect(projectInstanceRelationship.getPreloaded()).toBeTrue()
+      expect(projectDetail.project().id()).toEqual(project.id())
+
+
+      // It automatically sets the relationship that saved it on a has-many-relationship
+      const tasksRelationship = project.getRelationshipByName("tasks")
+
+      expect(tasksRelationship.getPreloaded()).toBeTrue()
+
+      const projectTasksIDs = project.tasks().loaded().map((task) => task.id())
+
+      expect(projectTasksIDs).toEqual([task.id()])
+    })
+  })
+})

package/src/database/drivers/base.js

@@ -125,7 +125,7 @@ export default class VelociousDatabaseDriversBase {
   }
 
   quoteTable(tableName) {
-    return this.options().quoteColumnName(tableName)
+    return this.options().quoteTableName(tableName)
   }
 
   newQuery() {

package/src/database/query/index.js

@@ -108,8 +108,8 @@ export default class VelociousDatabaseQuery {
     return await this.clone().where(newConditions).first()
   }
 
-  async findOrCreateBy(conditions) {
-    const record = await this.findOrInitializeBy(conditions)
+  async findOrCreateBy(...args) {
+    const record = await this.findOrInitializeBy(...args)
 
     if (record.isNewRecord()) {
       await record.save()
@@ -118,13 +118,17 @@ export default class VelociousDatabaseQuery {
     return record
   }
 
-  async findOrInitializeBy(conditions) {
+  async findOrInitializeBy(conditions, callback) {
     const record = await this.findBy(conditions)
 
     if (record) return record
 
     const newRecord = new this.modelClass(conditions)
 
+    if (callback) {
+      callback(newRecord)
+    }
+
     return newRecord
   }
 

package/src/database/query-parser/where-parser.js

@@ -23,7 +23,7 @@ export default class VelocuiousDatabaseQueryParserWhereParser {
     for (const whereKey in query._wheres) {
       const where = query._wheres[whereKey]
 
-      if (whereKey > 0) sql += " &&"
+      if (whereKey > 0) sql += " AND"
 
       if (pretty) {
         sql += "\n  "

package/src/database/record/validators/uniqueness.js

@@ -3,16 +3,24 @@ import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
   async validate({model, attributeName}) {
+    const modelClass = model.constructor
+    const connection = modelClass.connection()
+    const tableName = modelClass._getTable().getName()
     const attributeValue = model.readAttribute(attributeName)
     const attributeNameUnderscore = inflection.underscore(attributeName)
     const whereArgs = {}
 
     whereArgs[attributeNameUnderscore] = attributeValue
 
-    const existingRecord = await model.constructor
-      .select(model.constructor.primaryKey())
+    let existingRecordQuery = model.constructor
+      .select(modelClass.primaryKey())
       .where(whereArgs)
-      .first()
+
+    if (model.isPersisted()) {
+      existingRecordQuery.where(`${connection.quoteTable(tableName)}.${connection.quoteColumn(modelClass.primaryKey())} != ${connection.quote(model.id())}`)
+    }
+
+    const existingRecord = await existingRecordQuery.first()
 
     if (existingRecord) {
       if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []

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

@@ -92,7 +92,9 @@ export default class VeoliciousHttpServerClient {
       response.addHeader("Connection", "Close")
     }
 
-    response.addHeader("Content-Length", response.body.length)
+    const textEncoded = new TextEncoder().encode(body)
+
+    response.addHeader("Content-Length", textEncoded.length)
     response.addHeader("Date", date.toUTCString())
     response.addHeader("Server", "Velocious")