velocious 1.0.66 → 1.0.67

package/package.json

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

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

@@ -29,14 +29,55 @@ describe("Record - create", () => {
       // '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
+
+      // 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()])
     })
   })
 
+  it("sets the inversed relationship on has-many-relationships", async () => {
+    const project = new Project({name: "Test project"})
+
+    project.tasks().build({name: "Test task 1"})
+    project.tasks().build({name: "Test task 2"})
+
+    await project.save()
+
+    const tasks = project.tasks().loaded()
+    const task1 = tasks.find((task) => task.name() == "Test task 1")
+    const task2 = tasks.find((task) => task.name() == "Test task 2")
+
+    expect(tasks.length).toEqual(2)
+
+    expect(task1.projectId()).toEqual(project.id())
+    expect(task1.project().id()).toEqual(project.id())
+
+    expect(task2.projectId()).toEqual(project.id())
+    expect(task2.project().id()).toEqual(project.id())
+  })
+
   it("creates a new task with an existing project", async () => {
     await Dummy.run(async () => {
       const project = await Project.create({name: "Test project"})

package/src/database/query/preloader/has-many.js

@@ -46,13 +46,13 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
       for (const model of modelsByPrimaryKeyValue[modelValue]) {
         const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
 
-        modelRelationship.setPreloaded(true)
-
         if (preloadedCollection.length == 0) {
           modelRelationship.setLoaded([])
         } else {
           modelRelationship.addToLoaded(preloadedCollection)
         }
+
+        modelRelationship.setPreloaded(true)
       }
     }
 

package/src/database/record/index.js

@@ -85,8 +85,24 @@ class VelociousDatabaseRecord {
       }
 
       this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+        const instanceRelationship = this.getRelationshipByName(relationshipName)
+        const record = instanceRelationship.build(attributes)
+
+        const inverseOf = instanceRelationship.getRelationship().getInverseOf()
+
+        if (inverseOf) {
+          const inverseInstanceRelationship = record.getRelationshipByName(inverseOf)
+
+          inverseInstanceRelationship.setAutoSave(false)
+
+          if (inverseInstanceRelationship.getType() == "hasOne") {
+            inverseInstanceRelationship.setLoaded(this)
+          } else if (inverseInstanceRelationship.getType() == "hasMany") {
+            inverseInstanceRelationship.addToLoaded(this)
+          } else {
+            throw new Error(`Unknown relationship type: ${inverseInstanceRelationship.getType()}`)
+          }
+        }
 
         return record
       }
@@ -119,8 +135,17 @@ class VelociousDatabaseRecord {
       }
 
       this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        const relationship = this.getRelationshipByName(relationshipName)
-        const record = relationship.build(attributes)
+        const instanceRelationship = this.getRelationshipByName(relationshipName)
+        const record = instanceRelationship.build(attributes)
+
+        const inverseOf = instanceRelationship.getRelationship().getInverseOf()
+
+        if (inverseOf) {
+          const inverseInstanceRelationship = record.getRelationshipByName(inverseOf)
+
+          inverseInstanceRelationship.setAutoSave(false)
+          inverseInstanceRelationship.setLoaded(this)
+        }
 
         return record
       }
@@ -151,6 +176,10 @@ class VelociousDatabaseRecord {
     return []
   }
 
+  static getRelationshipNames() {
+    return this.getRelationships().map((relationship) => relationship.getRelationshipName())
+  }
+
   getRelationshipByName(relationshipName) {
     if (!this._instanceRelationships) this._instanceRelationships = {}
 
@@ -435,6 +464,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       const model = instanceRelationship.loaded()
 
       if (model?.isChanged()) {
@@ -443,6 +476,7 @@ class VelociousDatabaseRecord {
         const foreignKey = instanceRelationship.getForeignKey()
 
         this.setAttribute(foreignKey, model.id())
+
         instanceRelationship.setPreloaded(true)
         instanceRelationship.setDirty(false)
 
@@ -463,6 +497,10 @@ class VelociousDatabaseRecord {
         continue
       }
 
+      if (instanceRelationship.getAutoSave() === false) {
+        continue
+      }
+
       let loaded
 
       if (instanceRelationship.getType() == "hasOne") {
@@ -500,7 +538,7 @@ class VelociousDatabaseRecord {
 
   async _autoSaveHasManyAndHasOneRelationships({isNewRecord}) {
     for (const instanceRelationship of this._autoSaveHasManyAndHasOneRelationshipsToSave()) {
-      let loaded = instanceRelationship._loaded
+      let loaded = instanceRelationship.getLoadedOrNull()
 
       if (!Array.isArray(loaded)) loaded = [loaded]
 
@@ -804,6 +842,10 @@ class VelociousDatabaseRecord {
         const instanceRelationship = this._instanceRelationships[instanceRelationshipName]
         let loaded = instanceRelationship._loaded
 
+        if (instanceRelationship.getAutoSave() === false) {
+          continue
+        }
+
         if (!loaded) continue
         if (!Array.isArray(loaded)) loaded = [loaded]
 
@@ -915,6 +957,10 @@ class VelociousDatabaseRecord {
     for (const relationship of this.constructor.getRelationships()) {
       const instanceRelationship = this.getRelationshipByName(relationship.getRelationshipName())
 
+      if (instanceRelationship.getType() == "hasMany" && instanceRelationship.getLoadedOrNull() === null) {
+        instanceRelationship.setLoaded([])
+      }
+
       instanceRelationship.setPreloaded(true)
     }
   }

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

@@ -1,10 +1,13 @@
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
   constructor({model, relationship}) {
+    this._autoSave = null
     this._dirty = false
     this.model = model
     this.relationship = relationship
   }
 
+  getAutoSave() { return this._autoSave }
+  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }
   setDirty(newValue) { this._dirty = newValue }
   getDirty() { return this._dirty }
   isLoaded() { return Boolean(this._loaded) }
@@ -18,6 +21,7 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
   }
 
   setLoaded(model) { this._loaded = model }
+  getPreloaded() { return this._preloaded }
   setPreloaded(preloadedValue) { this._preloaded = preloadedValue }
   getForeignKey() { return this.getRelationship().getForeignKey() }
   getModel() { return this.model }

package/src/database/record/instance-relationships/belongs-to.js

@@ -10,9 +10,7 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
     return newInstance
   }
 
-  getLoadedOrNull() {
-    return this._loaded
-  }
+  getLoadedOrNull() { return this._loaded }
 
   async load() {
     const foreignKey = this.getForeignKey()

package/src/database/record/instance-relationships/has-many.js

@@ -7,13 +7,29 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
   }
 
   build(data) {
+    // Spawn new model of the targeted class
     const targetModelClass = this.getTargetModelClass()
     const newInstance = new targetModelClass(data)
 
+
+    // Add it to the loaded models of this relationship
     if (this._loaded === null) this._loaded = []
 
     this._loaded.push(newInstance)
 
+
+    // Set loaded on the models inversed relationship
+    const inverseOf = this.getRelationship().getInverseOf()
+
+    if (inverseOf) {
+      const inverseInstanceRelationship = newInstance.getRelationshipByName(inverseOf)
+
+      inverseInstanceRelationship.setAutoSave(false)
+      inverseInstanceRelationship.setLoaded(this.getModel())
+    }
+
+
+    // Return the new contructed model
     return newInstance
   }
 
@@ -38,13 +54,15 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
     }
 
-    return this._loaded
-  }
+    if (this._loaded === null && this.model.isNewRecord()) {
+      return []
+    }
 
-  getLoadedOrNull() {
     return this._loaded
   }
 
+  getLoadedOrNull() { return this._loaded }
+
   addToLoaded(models) {
     if (Array.isArray(models)) {
       for (const model of models) {
@@ -53,6 +71,8 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
         this._loaded.push(model)
       }
     } else {
+      if (this._loaded === null) this._loaded = []
+
       this._loaded.push(models)
     }
   }
@@ -63,5 +83,13 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     this._loaded = models
   }
 
-  getTargetModelClass = () => this.relationship.getTargetModelClass()
+  setPreloaded(preloaded) {
+    if (preloaded && !Array.isArray(this._loaded)) {
+      throw new Error("Trying to set preloaded without a loaded value")
+    }
+
+    this._preloaded = preloaded
+  }
+
+  getTargetModelClass() { return this.relationship.getTargetModelClass() }
 }

package/src/database/record/instance-relationships/has-one.js

@@ -39,9 +39,7 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     return this._loaded
   }
 
-  getLoadedOrNull() {
-    return this._loaded
-  }
+  getLoadedOrNull() { return this._loaded }
 
   setLoaded(model) {
     if (Array.isArray(model)) throw new Error(`Argument given to setLoaded was an array: ${typeof model}`)
@@ -49,5 +47,5 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     this._loaded = model
   }
 
-  getTargetModelClass = () => this.relationship.getTargetModelClass()
+  getTargetModelClass() { return this.relationship.getTargetModelClass() }
 }

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

@@ -1,7 +1,7 @@
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseRecordBaseRelationship {
-  constructor({className, configuration, dependent, foreignKey, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) {
+  constructor({className, configuration, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
@@ -11,6 +11,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this.configuration = configuration
     this._dependent = dependent
     this.foreignKey = foreignKey
+    this._inverseOf
     this.klass = klass
     this.modelClass = modelClass
     this._primaryKey = primaryKey

package/src/database/record/relationships/belongs-to.js

@@ -9,4 +9,28 @@ export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRe
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedHasOneInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+        const autoGeneratedHasManyInverseOfName = inflection.pluralize(autoGeneratedHasOneInverseOfName)
+
+        if (targetClassRelationshipNames.includes(autoGeneratedHasOneInverseOfName)) {
+          this._inverseOf = autoGeneratedHasOneInverseOfName
+        } else if (targetClassRelationshipNames.includes(autoGeneratedHasManyInverseOfName)) {
+          this._inverseOf = autoGeneratedHasManyInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }

package/src/database/record/relationships/has-many.js

@@ -9,4 +9,25 @@ export default class VelociousDatabaseRecordHasManyRelationship extends BaseRela
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = inflection.singularize(`${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`)
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+
+        if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {
+          this._inverseOf = autoGeneratedBelongsToInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }

package/src/database/record/relationships/has-one.js

@@ -9,4 +9,25 @@ export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelat
 
     return this.foreignKey
   }
+
+  getInverseOf() {
+    if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
+      this._autoGenerateInverseOfAttempted = true
+
+      // Only make auto-inverse-of if the relationships name matches the target model class's name
+      const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
+
+      if (targetClassSimpleName == this.getTargetModelClass().name) {
+        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
+        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
+
+        if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {
+          this._inverseOf = autoGeneratedBelongsToInverseOfName
+        }
+      }
+    }
+
+    return this._inverseOf
+  }
 }