velocious 1.0.26 → 1.0.28

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",
@@ -30,6 +30,7 @@
     "sqlite3": "^5.1.7"
   },
   "dependencies": {
+    "bcryptjs": "^3.0.2",
     "better-localstorage": "^1.0.7",
     "debounce": "^2.2.0",
     "diggerize": "^1.0.5",
@@ -40,6 +41,7 @@
     "inflection": "^3.0.0",
     "sql-escape-string": "^1.1.0",
     "sql.js": "^1.12.0",
-    "strftime": "^0.10.2"
+    "strftime": "^0.10.2",
+    "uuid": "^11.1.0"
   }
 }

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

@@ -1,4 +1,5 @@
 import Dummy from "../../dummy/index.js"
+import Project from "../../dummy/src/models/project.js"
 import Task from "../../dummy/src/models/task.js"
 
 describe("Record - create", () => {
@@ -20,4 +21,18 @@ describe("Record - create", () => {
       expect(project.nameEn()).toEqual("Test project")
     })
   })
+
+  it("creates a new task with an existing project", async () => {
+    await Dummy.run(async () => {
+      const project = await Project.create({name: "Test project"})
+      const task = new Task({name: "Test task", project})
+
+      await task.save()
+
+      expect(task.id()).not.toBeUndefined()
+      expect(task.name()).toEqual("Test task")
+      expect(task.project().id()).toEqual(project.id())
+      expect(task.project()).toEqual(project)
+    })
+  })
 })

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

@@ -34,4 +34,52 @@ describe("Record - query", () => {
       expect(newProject.nameEn()).toEqual("Test project")
     })
   })
+
+  it("finds the first record", async () => {
+    await Dummy.run(async () => {
+      const taskIDs = []
+
+      for (let i = 0; i < 5; i++) {
+        const task = await Task.create({name: `Task ${i}`})
+
+        taskIDs.push(task.id())
+      }
+
+      const lastTask = await Task.first()
+
+      expect(lastTask.id()).toEqual(taskIDs[0])
+    })
+  })
+
+  it("finds the last record", async () => {
+    await Dummy.run(async () => {
+      const taskIDs = []
+
+      for (let i = 0; i < 5; i++) {
+        const task = await Task.create({name: `Task ${i}`})
+
+        taskIDs.push(task.id())
+      }
+
+      const lastTask = await Task.last()
+
+      expect(lastTask.id()).toEqual(taskIDs[4])
+    })
+  })
+
+  it("counts the records", async () => {
+    await Dummy.run(async () => {
+      const taskIDs = []
+
+      for (let i = 0; i < 5; i++) {
+        const task = await Task.create({name: `Task ${i}`})
+
+        taskIDs.push(task.id())
+      }
+
+      const tasksCount = await Task.count()
+
+      expect(tasksCount).toEqual(5)
+    })
+  })
 })

package/src/application.js

@@ -1,12 +1,13 @@
 import AppRoutes from "../src/routes/app-routes.js"
 import {digs} from "diggerize"
-import logger from "./logger.js"
+import {Logger} from "./logger.js"
 import HttpServer from "./http-server/index.js"
 
 export default class VelociousApplication {
   constructor({configuration, httpServer}) {
     this.configuration = configuration
     this.httpServerConfiguration = httpServer ?? {}
+    this.logger = new Logger(this)
   }
 
   async initialize() {
@@ -40,7 +41,7 @@ export default class VelociousApplication {
 
     const port = httpServerConfiguration.port || 3006
 
-    logger(this, `Starting server on port ${port}`)
+    await this.logger.debug(`Starting server on port ${port}`)
 
     this.httpServer = new HttpServer({configuration, port})
     this.httpServer.events.on("close", this.onHttpServerClose)
@@ -49,13 +50,12 @@ export default class VelociousApplication {
   }
 
   async stop() {
-    logger(this, "Stopping server")
-
+    await this.logger.debug("Stopping server")
     await this.httpServer.stop()
   }
 
   onHttpServerClose = () => {
-    logger(this, "HTTP server closed")
+    this.logger.debug("HTTP server closed")
 
     if (this.waitResolve) {
       this.waitResolve()

package/src/controller.js

@@ -1,7 +1,7 @@
 import {digs} from "diggerize"
 import ejs from "ejs"
 import * as inflection from "inflection"
-import logger from "./logger.js"
+import {Logger} from "./logger.js"
 import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousController {
@@ -23,6 +23,7 @@ export default class VelociousController {
     this._action = action
     this._controller = controller
     this._configuration = configuration
+    this.logger = new Logger(this)
     this._params = params
     this._request = request
     this._response = response
@@ -31,12 +32,12 @@ export default class VelociousController {
   }
 
   async _runBeforeCallbacks() {
-    await logger(this, "_runBeforeCallbacks")
+    await this.logger.debug("_runBeforeCallbacks")
 
     let currentControllerClass = this.constructor
 
     while (currentControllerClass) {
-      await logger(this, `Running callbacks for ${currentControllerClass.name}`)
+      await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`)
 
       const beforeActions = currentControllerClass._beforeActions
 
@@ -57,7 +58,7 @@ export default class VelociousController {
       if (!currentControllerClass?.name?.endsWith("Controller")) break
     }
 
-    await logger(this, "After runBeforeCallbacks")
+    await this.logger.debug("After runBeforeCallbacks")
   }
 
   params = () => this._params

package/src/database/drivers/base.js

@@ -1,10 +1,12 @@
 import Query from "../query/index.js"
 import Handler from "../handler.js"
+import {v4 as uuidv4} from "uuid"
 
 export default class VelociousDatabaseDriversBase {
   constructor(config, configuration) {
     this._args = config
     this.configuration = configuration
+    this._transactionsCount = 0
   }
 
   async createTable(...args) {
@@ -81,16 +83,41 @@ export default class VelociousDatabaseDriversBase {
     return false
   }
 
+  async startTransaction() {
+    return await this.query("BEGIN TRANSACTION")
+  }
+
   async transaction(callback) {
-    await this.query("BEGIN TRANSACTION")
+    const savePointName = `sp${uuidv4().replaceAll("-", "")}`
+    let transactionStarted = false
+
+    if (this._transactionsCount == 0) {
+      await this.startTransaction()
+      transactionStarted = true
+      this._transactionsCount++
+    }
+
+    await this.query(`SAVEPOINT ${savePointName}`)
 
     let result
 
     try {
       result = await callback()
-      await this.query("COMMIT")
+
+      await this.query(`RELEASE SAVEPOINT ${savePointName}`)
+
+      if (transactionStarted) {
+        await this.query("COMMIT")
+        this._transactionsCount--
+      }
     } catch (error) {
-      this.query("ROLLBACK")
+      await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
+
+      if (transactionStarted) {
+        await this.query("ROLLBACK")
+        this._transactionsCount--
+      }
+
       throw error
     }
 

package/src/database/drivers/mysql/index.js

@@ -140,6 +140,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return this._options
   }
 
+  async startTransaction() {
+    return await this.query("START TRANSACTION")
+  }
+
   updateSql({conditions, data, tableName}) {
     const update = new Update({conditions, data, driver: this, tableName})
 

package/src/database/query/index.js

@@ -2,6 +2,7 @@ import FromPlain from "./from-plain.js"
 import {incorporate} from "incorporator"
 import * as inflection from "inflection"
 import JoinPlain from "./join-plain.js"
+import {Logger} from "../../logger.js"
 import OrderPlain from "./order-plain.js"
 import Preloader from "./preloader.js"
 import RecordNotFoundError from "../record/record-not-found-error.js"
@@ -16,6 +17,7 @@ export default class VelociousDatabaseQuery {
 
     this.driver = driver
     this.handler = handler
+    this.logger = new Logger(this)
     this.modelClass = modelClass
     this._froms = froms
     this._groups = groups
@@ -45,6 +47,21 @@ export default class VelociousDatabaseQuery {
     return newQuery
   }
 
+  async count() {
+    const countQuery = this.clone()
+
+    countQuery._selects = []
+    countQuery.select("COUNT(id) AS count")
+
+    const results = await countQuery._executeQuery()
+
+    if (results.length == 1) {
+      return results[0].count
+    }
+
+    throw new Error("count multiple stub")
+  }
+
   getOptions = () => this.driver.options()
 
   async destroyAll() {
@@ -136,7 +153,11 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
-  last = async () => await this.clone().reverseOrder().first()
+  last = async () => {
+    const results = await this.clone().reorder("id DESC").limit(1).toArray()
+
+    return results[0]
+  }
 
   limit(value) {
     this._limits.push(value)
@@ -188,10 +209,18 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
-  async toArray() {
+  async _executeQuery() {
     const sql = this.toSql()
     const results = await this.driver.query(sql)
+
+    this.logger.debug("SQL: ", sql)
+
+    return results
+  }
+
+  async toArray() {
     const models = []
+    const results = await this._executeQuery()
 
     for (const result of results) {
       const model = new this.modelClass()

package/src/database/record/index.js

@@ -41,6 +41,7 @@ export default class VelociousDatabaseRecord {
       relationship = new BelongsToRelationship(actualData)
 
       const buildMethodName = `build${inflection.camelize(relationshipName)}`
+      const setMethodName = `set${inflection.camelize(relationshipName)}`
 
       this.prototype[relationshipName] = function () {
         const relationship = this.getRelationshipByName(relationshipName)
@@ -54,6 +55,13 @@ export default class VelociousDatabaseRecord {
 
         return record
       }
+
+      this.prototype[setMethodName] = function (model) {
+        const relationship = this.getRelationshipByName(relationshipName)
+
+        relationship.setLoaded(model)
+        relationship.setDirty(true)
+      }
     } else if (actualData.type == "hasMany") {
       relationship = new HasManyRelationship(actualData)
 
@@ -276,19 +284,20 @@ export default class VelociousDatabaseRecord {
   }
 
   async save() {
-    let result
-
     const isNewRecord = this.isNewRecord()
+    let result
 
-    await this._autoSaveBelongsToRelationships()
+    await this.constructor.transaction(async () => {
+      await this._autoSaveBelongsToRelationships()
 
-    if (this.isPersisted()) {
-      result = await this._updateRecordWithChanges()
-    } else {
-      result = await this._createNewRecord()
-    }
+      if (this.isPersisted()) {
+        result = await this._updateRecordWithChanges()
+      } else {
+        result = await this._createNewRecord()
+      }
 
-    await this._autoSaveHasManyRelationships({isNewRecord})
+      await this._autoSaveHasManyRelationships({isNewRecord})
+    })
 
     return result
   }
@@ -310,6 +319,7 @@ export default class VelociousDatabaseRecord {
 
         this.setAttribute(foreignKey, model.id())
         instanceRelationship.setPreloaded(true)
+        instanceRelationship.setDirty(false)
       }
     }
   }
@@ -350,6 +360,10 @@ export default class VelociousDatabaseRecord {
     this._tableName = tableName
   }
 
+  static async transaction(callback) {
+    return await this.connection().transaction(callback)
+  }
+
   static translates(...names) {
     for (const name of names) {
       if (!this._translations) this._translations = {}
@@ -457,6 +471,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery()
   }
 
+  static async count() {
+    return this._newQuery().count()
+  }
+
   static async destroyAll(...args) {
     return this._newQuery().destroyAll(...args)
   }
@@ -477,6 +495,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery().findOrInitializeBy(...args)
   }
 
+  static async first() {
+    return this._newQuery().first()
+  }
+
   static joins(...args) {
     return this._newQuery().joins(...args)
   }
@@ -636,14 +658,31 @@ export default class VelociousDatabaseRecord {
     return this._attributes[attributeNameUnderscore]
   }
 
+  _belongsToChanges() {
+    const belongsToChanges = {}
+
+    if (this._instanceRelationships) {
+      for (const relationshipName in this._instanceRelationships) {
+        const relationship = this._instanceRelationships[relationshipName]
+
+        if (relationship.getType() == "belongsTo" && relationship.getDirty()) {
+          belongsToChanges[relationship.getForeignKey()] = relationship.loaded()?.id()
+        }
+      }
+    }
+
+    return belongsToChanges
+  }
+
   async _createNewRecord() {
     if (!this.constructor.connection()["insertSql"]) {
       throw new Error(`No insertSql on ${this.constructor.connection().constructor.name}`)
     }
 
+    const data = Object.assign({}, this._belongsToChanges(), this.attributes())
     const sql = this._connection().insertSql({
       tableName: this._tableName(),
-      data: this.attributes()
+      data
     })
     await this._connection().query(sql)
     const id = await this._connection().lastInsertID()
@@ -666,9 +705,11 @@ export default class VelociousDatabaseRecord {
 
     conditions[this.constructor.primaryKey()] = this.id()
 
+    const changes = Object.assign({}, this._belongsToChanges(), this._changes)
+
     const sql = this._connection().updateSql({
       tableName: this._tableName(),
-      data: this._changes,
+      data: changes,
       conditions
     })
     await this._connection().query(sql)

package/src/database/record/instance-relationships/base.js

@@ -1,9 +1,16 @@
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
   constructor({model, relationship}) {
+    this._dirty = false
     this.model = model
     this.relationship = relationship
   }
 
+  setDirty(newValue) {
+    this._dirty = newValue
+  }
+
+  getDirty = () => this._dirty
+
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)

package/src/database/record/user-module.js

@@ -0,0 +1,28 @@
+import bcryptjs from "bcryptjs"
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class UserModule {
+  constructor({secretKey, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!secretKey) throw new Error(`Invalid secret key given: ${secretKey}`)
+
+    this.secretKey = secretKey
+  }
+
+  attachTo(UserClass) {
+    UserClass.prototype.setPassword = function(newPassword) {
+      const salt = bcryptjs.genSaltSync(10)
+      const encryptedPassword = bcryptjs.hashSync(newPassword, salt)
+
+      this.setEncryptedPassword(encryptedPassword)
+    }
+
+    UserClass.prototype.setPasswordConfirmation = function(newPasswordConfirmation) {
+      const salt = bcryptjs.genSaltSync(10)
+      const encryptedPassword = bcryptjs.hashSync(newPasswordConfirmation, salt)
+
+      this._encryptedPasswordConfirmation = encryptedPassword
+    }
+  }
+}

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

@@ -1,6 +1,6 @@
 import {digg} from "diggerize"
 import {EventEmitter} from "events"
-import logger from "../../logger.js"
+import {Logger} from "../../logger.js"
 import Request from "./request.js"
 import RequestRunner from "./request-runner.js"
 
@@ -11,6 +11,7 @@ export default class VeoliciousHttpServerClient {
   constructor({clientCount, configuration, onExecuteRequest}) {
     if (!configuration) throw new Error("No configuration given")
 
+    this.logger = new Logger(this)
     this.clientCount = clientCount
     this.configuration = configuration
     this.onExecuteRequest = onExecuteRequest
@@ -18,7 +19,7 @@ export default class VeoliciousHttpServerClient {
   }
 
   executeCurrentRequest = () => {
-    logger(this, "executeCurrentRequest")
+    this.logger.debug("executeCurrentRequest")
 
     // 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"

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

@@ -2,7 +2,7 @@ import {EventEmitter} from "events"
 import FormDataPart from "./form-data-part.js"
 import Header from "./header.js"
 import Incorporator from "incorporator"
-import logger from "../../../logger.js"
+import {Logger} from "../../../logger.js"
 import ParamsToObject from "../params-to-object.js"
 import querystring from "querystring"
 
@@ -20,6 +20,7 @@ export default class RequestBuffer {
 
   constructor({configuration}) {
     this.configuration = configuration
+    this.logger = new Logger(this)
   }
 
   feed(data) {
@@ -185,8 +186,7 @@ export default class RequestBuffer {
     this.httpMethod = match[1]
     this.path = match[2]
     this.setState("headers")
-
-    logger(this, () => ["Parsed status line", {httpMethod: this.httpMethod, path: this.path}])
+    this.logger.debug(() => ["Parsed status line", {httpMethod: this.httpMethod, path: this.path}])
   }
 
   postRequestDone() {
@@ -196,8 +196,7 @@ export default class RequestBuffer {
   }
 
   setState(newState) {
-    logger(this, () => [`Changing state from ${this.state} to ${newState}`])
-
+    this.logger.debug(() => [`Changing state from ${this.state} to ${newState}`])
     this.state = newState
   }
 

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

@@ -1,5 +1,5 @@
 import EventEmitter from "events"
-import logger from "../../logger.js"
+import {Logger} from "../../logger.js"
 import Response from "./response.js"
 import RoutesResolver from "../../routes/resolver.js"
 
@@ -10,6 +10,7 @@ export default class VelociousHttpServerClientRequestRunner {
     if (!configuration) throw new Error("No configuration given")
     if (!request) throw new Error("No request given")
 
+    this.logger = new Logger(this)
     this.configuration = configuration
     this.request = request
     this.response = new Response({configuration})
@@ -25,7 +26,7 @@ export default class VelociousHttpServerClientRequestRunner {
 
     try {
       if (request.header("sec-fetch-mode") == "cors") {
-        await logger(this, () => ["Run CORS", {httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode")}])
+        await this.logger.debug(() => ["Run CORS", {httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode")}])
         await configuration.cors({request, response})
       }
 
@@ -33,13 +34,13 @@ export default class VelociousHttpServerClientRequestRunner {
         response.setStatus(200)
         response.setBody("")
       } else {
-        await logger(this, "Run request")
+        await this.logger.debug("Run request")
         const routesResolver = new RoutesResolver({configuration, request, response})
 
         await routesResolver.resolve()
       }
     } catch (error) {
-      await logger(this, `Error while running request: ${error.message}`)
+      await this.logger.error(() => [`Error while running request: ${error.message}\n\n${error.stack}`])
 
       response.setStatus(500)
       response.setErrorBody(error)

package/src/http-server/index.js

@@ -1,6 +1,6 @@
 import {digg} from "diggerize"
 import EventEmitter from "events"
-import logger from "../logger.js"
+import {Logger} from "../logger.js"
 import Net from "net"
 import ServerClient from "./server-client.js"
 import WorkerHandler from "./worker-handler/index.js"
@@ -14,6 +14,7 @@ export default class VelociousHttpServer {
 
   constructor({configuration, host, maxWorkers, port}) {
     this.configuration = configuration
+    this.logger = new Logger(this)
     this.host = host || "0.0.0.0"
     this.port = port || 3006
     this.maxWorkers = maxWorkers || 16
@@ -31,7 +32,7 @@ export default class VelociousHttpServer {
     return new Promise((resolve, reject) => {
       try {
         this.netServer.listen(this.port, this.host, () => {
-          logger(this, `Velocious listening on ${this.host}:${this.port}`)
+          this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)
           resolve()
         })
       } catch (error) {
@@ -82,8 +83,7 @@ export default class VelociousHttpServer {
   onConnection = (socket) => {
     const clientCount = this.clientCount
 
-    logger(this, `New client ${clientCount}`)
-
+    this.logger.debug(`New client ${clientCount}`)
     this.clientCount++
 
     const workerHandler = this.workerHandlerToUse()
@@ -95,10 +95,8 @@ export default class VelociousHttpServer {
 
     client.events.on("close", this.onClientClose)
 
-    logger(this, `Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
-
+    this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
     workerHandler.addSocketConnection(client)
-
     this.clients[clientCount] = client
   }
 
@@ -130,7 +128,7 @@ export default class VelociousHttpServer {
   }
 
   workerHandlerToUse() {
-    logger(this, `Worker handlers length: ${this.workerHandlers.length}`)
+    this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)
 
     const randomWorkerNumber = parseInt(Math.random() * this.workerHandlers.length)
     const workerHandler = this.workerHandlers[randomWorkerNumber]

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

@@ -1,5 +1,5 @@
 import EventEmitter from "events"
-import logger from "../logger.js"
+import {Logger} from "../logger.js"
 
 export default class ServerClient {
   events = new EventEmitter()
@@ -8,6 +8,7 @@ export default class ServerClient {
     if (!configuration) throw new Error("No configuration given")
 
     this.configuration = configuration
+    this.logger = new Logger(this)
     this.socket = socket
     this.clientCount = clientCount
 
@@ -25,7 +26,7 @@ export default class ServerClient {
   }
 
   onSocketData = (chunk) => {
-    logger(this, () => [`Socket ${this.clientCount}: ${chunk}`])
+    this.logger.debug(() => [`Socket ${this.clientCount}: ${chunk}`])
 
     this.worker.postMessage({
       command: "clientWrite",
@@ -35,13 +36,12 @@ export default class ServerClient {
   }
 
   onSocketEnd = () => {
-    logger(this, `Socket ${this.clientCount} end`)
+    this.logger.debug(`Socket ${this.clientCount} end`)
     this.events.emit("close", this)
   }
 
   send(data) {
-    logger(this, "Send", data)
-
+    this.logger.debug("Send", data)
     this.socket.write(data)
   }
 }

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

@@ -1,13 +1,14 @@
 import {digg, digs} from "diggerize"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
-import logger from "../../logger.js"
+import {Logger} from "../../logger.js"
 import {Worker} from "worker_threads"
 
 export default class VelociousHttpServerWorker {
   constructor({configuration, workerCount}) {
     this.configuration = configuration
     this.clients = {}
+    this.logger = new Logger(this)
     this.workerCount = workerCount
   }
 
@@ -36,7 +37,7 @@ export default class VelociousHttpServerWorker {
     const clientCount = digg(client, "clientCount")
 
     client.socket.on("end", () => {
-      logger(this, `Removing ${clientCount} from clients`)
+      this.logger.debug(`Removing ${clientCount} from clients`)
       delete this.clients[clientCount]
     })
 
@@ -55,12 +56,12 @@ export default class VelociousHttpServerWorker {
     if (code !== 0) {
       throw new Error(`Client worker stopped with exit code ${code}`)
     } else {
-      logger(this, () => [`Client worker stopped with exit code ${code}`])
+      this.logger.debug(() => [`Client worker stopped with exit code ${code}`])
     }
   }
 
   onWorkerMessage = (data) => {
-    logger(this, `Worker message`, data)
+    this.logger.debug(`Worker message`, data)
 
     const {command} = digs(data, "command")
 
@@ -68,7 +69,7 @@ export default class VelociousHttpServerWorker {
       this.onStartCallback()
       this.onStartCallback = null
     } else if (command == "clientOutput") {
-      logger(this, () => ["CLIENT OUTPUT", data])
+      this.logger.debug("CLIENT OUTPUT", data)
 
       const {clientCount, output} = digs(data, "clientCount", "output")
 

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

@@ -2,13 +2,14 @@ import Application from "../../application.js"
 import Client from "../client/index.js"
 import {digg, digs} from "diggerize"
 import errorLogger from "../../error-logger.js"
-import logger from "../../logger.js"
+import {Logger} from "../../logger.js"
 
 export default class VelociousHttpServerWorkerHandlerWorkerThread {
   constructor({parentPort, workerData}) {
     const {workerCount} = digs(workerData, "workerCount")
 
     this.clients = {}
+    this.logger = new Logger(this)
     this.parentPort = parentPort
     this.workerData = workerData
     this.workerCount = workerCount
@@ -17,7 +18,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
 
     this.initialize().then(() => {
       this.application.initialize().then(() => {
-        logger(this, `Worker ${workerCount} started`)
+        this.logger.debug(`Worker ${workerCount} started`)
         parentPort.postMessage({command: "started"})
       })
     })
@@ -39,7 +40,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
   }
 
   onCommand = async (data) => {
-    await logger(this, () => [`Worker ${this.workerCount} received command`, data])
+    await this.logger.debug(() => [`Worker ${this.workerCount} received command`, data])
 
     const command = data.command
 
@@ -56,12 +57,12 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
 
       this.clients[clientCount] = client
     } else if (command == "clientWrite") {
-      await logger(this, "Looking up client")
+      await this.logger.debug("Looking up client")
 
       const {chunk, clientCount} = digs(data, "chunk", "clientCount")
       const client = digg(this.clients, clientCount)
 
-      await logger(this, `Sending to client ${clientCount}`)
+      await this.logger.debug(`Sending to client ${clientCount}`)
 
       client.onWrite(chunk)
     } else {

package/src/logger.js

@@ -2,50 +2,88 @@ import Configuration from "./configuration.js"
 
 function consoleLog(message) {
   return new Promise((resolve) => {
-    process.stdout.write(message, "utf8", resolve)
+    process.stdout.write(`${message}\n`, "utf8", resolve)
   })
 }
 
-export default async function log(object, ...messages) {
-  let configuration
+function consoleError(message) {
+  return new Promise((resolve) => {
+    process.stderr.write(`${message}\n`, "utf8", resolve)
+  })
+}
 
-  if (object.configuration) {
-    configuration = object.configuration
-  } else {
-    configuration = Configuration.current()
+function functionOrMessages(messages) {
+  if (messages.length === 1 && typeof messages[0] == "function") {
+    messages = messages[0]()
   }
 
-  if (configuration?.debug) {
-    try {
-      if (!object.constructor.name) {
-        throw new Error(`No constructor name for object`)
-      }
+  return messages
+}
 
-      const className = object.constructor.name
+function messagesToMessage(...messages) {
+  let message = ""
 
-      if (messages.length === 1 && typeof messages[0] == "function") {
-        messages = messages[0]()
-      }
+  for (const messagePartIndex in messages) {
+    const messagePart = messages[messagePartIndex]
 
-      let message = ""
+    if (messagePartIndex > 0) {
+      message += " "
+    }
 
-      for (const messagePartIndex in messages) {
-        const messagePart = messages[messagePartIndex]
+    if (typeof messagePart == "object") {
+      message += JSON.stringify(messagePart)
+    } else {
+      message += messagePart
+    }
+  }
 
-        if (messagePartIndex > 0) {
-          message += " "
-        }
+  return message
+}
+
+class Logger {
+  constructor(object) {
+    if (typeof object == "string") {
+      this._subject = object
+    } else {
+      this._object = object
+      this._subject = object.constructor.name
+    }
 
-        if (typeof messagePart == "object") {
-          message += JSON.stringify(messagePart)
-        } else {
-          message += messagePart
-        }
-      }
+    if (!this._subject) {
+      throw new Error(`No subject given`)
+    }
+  }
 
-      await consoleLog(`${className} ${message}\n`)
-    } catch (error) {
-      console.error(`ERROR ${error.message}`)
+  getConfiguration() {
+    if (!this._configuration) {
+      this._configuration = this._object?.configuration || Configuration.current()
     }
+
+    return this._configuration
+  }
+
+  async debug(...messages) {
+    if (this.getConfiguration()?.debug) {
+      await this.log(...messages)
+    }
+  }
+
+  async log(...messages) {
+    await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(messages)))
+  }
+
+  async error(...messages) {
+    await consoleError(messagesToMessage(this._subject, ...functionOrMessages(messages)))
+  }
+}
+
+export {Logger}
+
+export default async function logger(object, ...messages) {
+  const className = object.constructor.name
+  const configuration = object.configuration || Configuration.current()
+
+  if (configuration.debug) {
+    await consoleLog(messagesToMessage(className, ...functionOrMessages(messages)))
   }
 }

package/src/testing/test.js

@@ -1,3 +1,5 @@
+import restArgsError from "../utils/rest-args-error.js"
+
 const tests = {
   args: {},
   subs: {},
@@ -6,9 +8,53 @@ const tests = {
 
 let currentPath = [tests]
 
+class ExpectToChange {
+  constructor({changeCallback, expect, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.expect = expect
+    this.changeCallback = changeCallback
+  }
+
+  by(count) {
+    this.count = count
+
+    return this.expect
+  }
+
+  async runBefore() {
+    this.oldCount = await this.changeCallback()
+  }
+
+  async runAfter() {
+    this.newCount = await this.changeCallback()
+  }
+
+  async execute() {
+    const difference = this.newCount - this.oldCount
+
+    if (difference != this.count) {
+      throw new Error(`Expected to change by ${this.count} but changed by ${difference}`)
+    }
+  }
+}
+
 class Expect {
   constructor(object) {
     this._object = object
+    this.expectations = []
+  }
+
+  toChange(changeCallback) {
+    const expectToChange = new ExpectToChange({changeCallback, expect: this})
+
+    this.expectations.push(expectToChange)
+
+    return expectToChange
+  }
+
+  andChange(...args) {
+    return this.toChange(...args)
   }
 
   toEqual(result) {
@@ -17,6 +63,24 @@ class Expect {
     }
   }
 
+  async execute() {
+    for (const expectation of this.expectations) {
+      await expectation.runBefore()
+    }
+
+    const result = await this._object()
+
+    for (const expectation of this.expectations) {
+      await expectation.runAfter()
+    }
+
+    for (const expectation of this.expectations) {
+      await expectation.execute()
+    }
+
+    return result
+  }
+
   toHaveAttributes(result) {
     const differences = {}