velocious 1.0.15 → 1.0.17

package/package.json

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

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

@@ -14,4 +14,19 @@ describe("Record - destroy", () => {
       expect(foundTask).toEqual(undefined)
     })
   })
+
+  it("destroys all records in a collection", async () => {
+    await Dummy.run(async () => {
+      const task1 = await Task.create({name: "Test task 1"})
+      const task2 = await Task.create({name: "Test task 2"})
+
+      await Task.where({id: task1.id()}).destroyAll()
+
+      const foundTask1 = await Task.where({id: task1.id()}).first()
+      const foundTask2 = await Task.where({id: task2.id()}).first()
+
+      expect(foundTask1).toEqual(undefined)
+      expect(foundTask2).toBeDefined()
+    })
+  })
 })

package/src/database/drivers/sqlite/base.js

@@ -66,6 +66,8 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   async insertMultiple(...args) {
+    await this.registerVersion()
+
     if (this.supportsMultipleInsertValues()) {
       return await this.insertMultipleWithSingleInsert(...args)
     } else {
@@ -130,6 +132,10 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   queryToSql = (query) => new QueryParser({query}).toSql()
 
   async registerVersion() {
+    if (this.versionMajor || this.versionMinor) {
+      return
+    }
+
     const versionResult = await this.query("SELECT sqlite_version() AS version")
 
     this.version = versionResult[0].version

package/src/database/drivers/sqlite/column.js

@@ -1,10 +1,14 @@
-import {digg} from "diggerize"
-
 export default class VelociousDatabaseDriversSqliteColumn {
   constructor({column, driver}) {
     this.column = column
     this.driver = driver
   }
 
-  getName = () => digg(this, "column", "name")
+  getName() {
+    if (!this.column.name) {
+      throw new Error("No name given for SQLite column")
+    }
+
+    return this.column.name
+  }
 }

package/src/database/drivers/sqlite/connection-remote.js

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseDriversSqliteConnectionRemote {
+  async query(sql) {
+    throw new Error("stub")
+  }
+}

package/src/database/drivers/sqlite/connection-sql-js.js

@@ -0,0 +1,37 @@
+import debounce from "debounce"
+import query from "./query"
+
+export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
+  constructor(driver, connection) {
+    this.connection = connection
+    this.driver = driver
+  }
+
+  async close() {
+    await this.saveDatabase()
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  disconnect = () => this.saveDatabase()
+
+  async query(sql) {
+    const result = await query(this.connection, sql)
+    const downcasedSQL = sql.toLowerCase().trim()
+
+    // Auto-save database in local storage in case we can find manipulating instructions in the SQL
+    if (downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
+      this.saveDatabaseDebounce()
+    }
+
+    return result
+  }
+
+  saveDatabase = async () => {
+    const localStorageContent = this.connection.export()
+
+    await this.driver.betterLocalStorage.set(this.driver.localStorageName(), localStorageContent)
+  }
+
+  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
+}

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

@@ -1,4 +1,3 @@
-import {digg} from "diggerize"
 import fs from "fs/promises"
 import query from "./query.js"
 import sqlite3 from "sqlite3"
@@ -22,7 +21,13 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
     await this.registerVersion()
   }
 
-  localStorageName = () => `VelociousDatabaseDriversSqlite---${digg(this.getArgs(), "name")}`
+  localStorageName() {
+    const args = this.getArgs()
+
+    if (!args.name) throw new Error("No name given for SQLite Node")
+
+    return `VelociousDatabaseDriversSqlite---${args.name}`
+  }
 
   async close() {
     await this.connection.close()

package/src/database/drivers/sqlite/index.native.js

@@ -7,7 +7,10 @@ import Base from "./base"
 export default class VelociousDatabaseDriversSqliteNative extends Base {
   async connect() {
     const args = this.getArgs()
-    const databaseName = digg(args, "name")
+
+    if (!args.name) throw new Error("No name given for SQLite Native")
+
+    const databaseName = args.name
 
     if (args.reset) {
       try {

package/src/database/drivers/sqlite/index.web.js

@@ -1,56 +1,50 @@
 import BetterLocalStorage from "better-localstorage"
-import debounce from "debounce"
+import ConnectionSqlJs from "./connection-sql-js"
 import {digg} from "diggerize"
 import initSqlJs from "sql.js"
-import query from "./query"
 
 import Base from "./base.js"
 
 export default class VelociousDatabaseDriversSqliteWeb extends Base {
   async connect() {
-    this.betterLocaleStorage ||= new BetterLocalStorage()
+    this.args = this.getArgs()
 
-    const args = this.getArgs()
+    if (!this.args.getConnection) {
+      this.betterLocalStorage ||= new BetterLocalStorage()
 
-    if (args.reset) {
-      await this.betterLocaleStorage.delete(this.localStorageName())
-    }
-
-    const SQL = await initSqlJs({
-      // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want you can omit locateFile completely when running in Node.
-      locateFile: (file) => `https://sql.js.org/dist/${file}`
-    })
+      if (this.args.reset) {
+        await this.betterLocalStorage.delete(this.localStorageName())
+      }
 
-    const databaseContent = await this.betterLocaleStorage.get(this.localStorageName())
+      const SQL = await initSqlJs({
+        // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want you can omit locateFile completely when running in Node.
+        locateFile: (file) => `https://sql.js.org/dist/${file}`
+      })
 
-    this.connection = new SQL.Database(databaseContent)
-    await this.registerVersion()
-  }
+      const databaseContent = await this.betterLocalStorage.get(this.localStorageName())
+      const connectionSqlJs = new ConnectionSqlJs(this, new SQL.Database(databaseContent))
 
-  localStorageName = () => `VelociousDatabaseDriversSqliteWeb---${digg(this.getArgs(), "name")}`
-  disconnect = () => this.saveDatabase()
-  saveDatabase = async () => {
-    const localStorageContent = this.connection.export()
-    await this.betterLocaleStorage.set(this.localStorageName(), localStorageContent)
+      this._connection = connectionSqlJs
+    }
   }
 
-  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
+  close = async () => await this.getConnection().close()
 
-  async close() {
-    await this.saveDatabase()
-    await this.connection.end()
-    this.connection = undefined
+  getConnection() {
+    if (this.args.getConnection) {
+      return this.args.getConnection()
+    } else {
+      return this._connection
+    }
   }
 
-  query = async (sql) => {
-    const result = await query(this.connection, sql)
-    const downcasedSQL = sql.toLowerCase().trim()
-
-    // Auto-save database in local storage in case we can find manipulating instructions in the SQL
-    if (downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
-      this.saveDatabaseDebounce()
+  localStorageName() {
+    if (!this.args.name) {
+      throw new Error("No name given in arguments for SQLite Web database")
     }
 
-    return result
+    return `VelociousDatabaseDriversSqliteWeb---${this.args.name}`
   }
+
+  query = async (sql) => await this.getConnection().query(sql)
 }

package/src/database/drivers/sqlite/table.js

@@ -1,5 +1,4 @@
 import Column from "./column.js"
-import {digg} from "diggerize"
 import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversSqliteTable {
@@ -34,5 +33,11 @@ export default class VelociousDatabaseDriversSqliteTable {
     return foreignKeys
   }
 
-  getName = () => digg(this, "row", "name")
+  getName() {
+    if (!this.row.name) {
+      throw new Error("No name given for SQLite table")
+    }
+
+    return this.row.name
+  }
 }

package/src/database/query/index.js

@@ -47,6 +47,14 @@ export default class VelociousDatabaseQuery {
 
   getOptions = () => this.driver.options()
 
+  async destroyAll() {
+    const records = await this.toArray()
+
+    for (const record of records) {
+      await record.destroy()
+    }
+  }
+
   async find(recordId) {
     const conditions = {}
 

package/src/database/record/index.js

@@ -457,6 +457,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery()
   }
 
+  static async destroyAll(...args) {
+    return this._newQuery().destroyAll(...args)
+  }
+
   static async find(...args) {
     return this._newQuery().find(...args)
   }
@@ -477,6 +481,14 @@ export default class VelociousDatabaseRecord {
     return this._newQuery().joins(...args)
   }
 
+  static limit(...args) {
+    return this._newQuery().limit(...args)
+  }
+
+  static order(...args) {
+    return this._newQuery().order(...args)
+  }
+
   static preload(...args) {
     return this._newQuery().preload(...args)
   }
@@ -518,6 +530,39 @@ export default class VelociousDatabaseRecord {
   }
 
   async destroy() {
+    for (const relationship of this.constructor.getRelationships()) {
+      if (relationship.getDependent() != "destroy") {
+        continue
+      }
+
+      const instanceRelationship = this.getRelationshipByName(relationship.getRelationshipName())
+      let models
+
+      if (instanceRelationship.getType() == "belongsTo") {
+        if (!instanceRelationship.isLoaded()) {
+          await instanceRelationship.load()
+        }
+
+        const model = instanceRelationship.loaded()
+
+        models = [model]
+      } else if (instanceRelationship.getType() == "hasMany") {
+        if (!instanceRelationship.isLoaded()) {
+          await instanceRelationship.load()
+        }
+
+        models = instanceRelationship.loaded()
+      } else {
+        throw new Error(`Unhandled relationship type: ${instanceRelationship.getType()}`)
+      }
+
+      for (const model of models) {
+        if (model.isPersisted()) {
+          await model.destroy()
+        }
+      }
+    }
+
     const conditions = {}
 
     conditions[this.constructor.primaryKey()] = this.id()

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

@@ -1,5 +1,5 @@
 export default class VelociousDatabaseRecordBaseRelationship {
-  constructor({className, configuration, foreignKey, klass, modelClass, relationshipName, through, type, ...restArgs}) {
+  constructor({className, configuration, dependent, foreignKey, klass, modelClass, relationshipName, through, type, ...restArgs}) {
     const restArgsKeys = Object.keys(restArgs)
 
     if (restArgsKeys.length > 0) throw new Error(`Unknown args given: ${restArgsKeys.join(", ")}`)
@@ -8,6 +8,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
 
     this.className = className
     this.configuration = configuration
+    this._dependent = dependent
     this.foreignKey = foreignKey
     this.klass = klass
     this.modelClass = modelClass
@@ -16,6 +17,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this.type = type
   }
 
+  getDependent = () => this._dependent
   getRelationshipName = () => this.relationshipName
   getPrimaryKey = () => "id" // TODO: Support custom given primary key
   getType = () => this.type

package/src/logger.js

@@ -4,7 +4,11 @@ export default function log(object, ...messages) {
   if (!object.configuration) console.error(`No configuration on ${object.constructor.name}`)
 
   if (object.configuration?.debug) {
-    const className = digg(object, "constructor", "name")
+    if (!object.constructor.name) {
+      throw new Error(`No constructor name for object`)
+    }
+
+    const className = object.constructor.name
 
     console.log(className, ...messages)
   }