velocious 1.0.5 → 1.0.6

package/src/database/record/index.mjs

@@ -1,24 +1,130 @@
+import BelongsToInstanceRelationship from "./instance-relationships/belongs-to.mjs"
+import BelongsToRelationship from "./relationships/belongs-to.mjs"
 import Configuration from "../../configuration.mjs"
+import FromTable from "../query/from-table.mjs"
 import Handler from "../handler.mjs"
-import inflection from "inflection"
+import HasManyRelationship from "./relationships/has-many.mjs"
+import HasManyInstanceRelationship from "./instance-relationships/has-many.mjs"
+import * as inflection from "inflection"
 import Query from "../query/index.mjs"
 import RecordNotFoundError from "./record-not-found-error.mjs"
 
 export default class VelociousDatabaseRecord {
+  static _relationshipExists(relationshipName) {
+    if (this._relationships && relationshipName in this._relationships) {
+      return true
+    }
+
+    return false
+  }
+
+  static _defineRelationship(relationshipName, data) {
+    if (!this._relationships) this._relationships = {}
+    if (this._relationshipExists(relationshipName)) throw new Error(`Relationship ${relationshipName} already exists`)
+
+    const actualData = Object.assign(
+      {
+        modelClass: this,
+        relationshipName,
+        type: "hasMany"
+      },
+      data
+    )
+
+    if (!actualData.className && !actualData.klass) {
+      actualData.className = inflection.camelize(inflection.singularize(relationshipName))
+    }
+
+    let relationship
+
+    if (actualData.type == "belongsTo") {
+      relationship = new BelongsToRelationship(actualData)
+
+      const buildMethodName = `build${inflection.camelize(relationshipName)}`
+
+      this.prototype[relationshipName] = function () {
+        const relationship = this.getRelationshipByName(relationshipName)
+
+        return relationship.loaded()
+      }
+
+      this.prototype[buildMethodName] = function (attributes) {
+        const relationship = this.getRelationshipByName(relationshipName)
+        const record = relationship.build(attributes)
+
+        return record
+      }
+    } else if (actualData.type == "hasMany") {
+      relationship = new HasManyRelationship(actualData)
+
+      this.prototype[relationshipName] = function () {
+        return this.getRelationshipByName(relationshipName)
+      }
+    } else {
+      throw new Error(`Unknown relationship type: ${actualData.type}`)
+    }
+
+    this._relationships[relationshipName] = relationship
+  }
+
+  static getRelationshipByName(relationshipName) {
+    if (!this._relationships) this._relationships = {}
+
+    const relationship = this._relationships[relationshipName]
+
+    if (!relationship) throw new Error(`No relationship by that name: ${relationshipName}`)
+
+    return relationship
+  }
+
+  getRelationshipByName(relationshipName) {
+    if (!this._instanceRelationships) this._instanceRelationships = {}
+
+    if (!(relationshipName in this._instanceRelationships)) {
+      const modelClassRelationship = this.constructor.getRelationshipByName(relationshipName)
+      let instanceRelationship
+
+      if (modelClassRelationship.getType() == "belongsTo") {
+        instanceRelationship = new BelongsToInstanceRelationship({model: this, relationship: modelClassRelationship})
+      } else if (modelClassRelationship.getType() == "hasMany") {
+        instanceRelationship = new HasManyInstanceRelationship({model: this, relationship: modelClassRelationship})
+      } else {
+        throw new Error(`Unknown relationship type: ${modelClassRelationship.getType()}`)
+      }
+
+      this._instanceRelationships[relationshipName] = instanceRelationship
+    }
+
+    return this._instanceRelationships[relationshipName]
+  }
+
+  static belongsTo(relationshipName) {
+    this._defineRelationship(relationshipName, {type: "belongsTo"})
+  }
+
   static connection() {
-    const connection = Configuration.current().getDatabasePoolType().current().getCurrentConnection()
+    const connection = this._getConfiguration().getDatabasePoolType().current().getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 
     return connection
   }
 
+  static async create(attributes) {
+    const record = new this(attributes)
+
+    await record.save()
+
+    return record
+  }
+
   static async find(recordId) {
     const conditions = {}
 
     conditions[this.primaryKey()] = recordId
 
-    const record = await this.where(conditions).first()
+    const query = this.where(conditions)
+    const record = await query.first()
 
     if (!record) {
       throw new RecordNotFoundError(`Couldn't find ${this.name} with '${this.primaryKey()}'=${recordId}`)
@@ -27,8 +133,144 @@ export default class VelociousDatabaseRecord {
     return record
   }
 
+  static _getConfiguration() {
+    if (!this._configuration) {
+      this._configuration = Configuration.current()
+
+      if (!this._configuration) {
+        throw new Error("Configuration hasn't been set (model class probably hasn't been initialized)")
+      }
+    }
+
+    return this._configuration
+  }
+
+  _getConfiguration() {
+    return this.constructor._getConfiguration()
+  }
+
+  static hasMany(relationshipName, options = {}) {
+    return this._defineRelationship(relationshipName, Object.assign({type: "hasMany"}, options))
+  }
+
+  static async initializeRecord({configuration}) {
+    if (!configuration) throw new Error("No configuration given")
+
+    this._configuration = configuration
+    this._configuration.registerModelClass(this)
+
+    this._table = await this.connection().getTableByName(this.tableName())
+    this._columns = await this._getTable().getColumns()
+    this._columnsAsHash = {}
+
+    for (const column of this._columns) {
+      this._columnsAsHash[column.getName()] = column
+
+      const camelizedColumnName = inflection.camelize(column.getName(), true)
+      const camelizedColumnNameBigFirst = inflection.camelize(column.getName())
+      const setterMethodName = `set${camelizedColumnNameBigFirst}`
+
+      this.prototype[camelizedColumnName] = function () {
+        return this.readAttribute(camelizedColumnName)
+      }
+
+      this.prototype[setterMethodName] = function (newValue) {
+        return this._setColumnAttribute(camelizedColumnName, newValue)
+      }
+    }
+
+    await this._defineTranslationMethods()
+    this._initialized = true
+  }
+
+  static isInitialized() {
+    if (this._initialized) return true
+
+    return false
+  }
+
+  static async _defineTranslationMethods() {
+    if (this._translations) {
+      const locales = this._getConfiguration().getLocales()
+
+      if (!locales) throw new Error("Locales hasn't been set in the configuration")
+
+      await this.getTranslationClass().initializeRecord({configuration: this._getConfiguration()})
+
+      for (const name in this._translations) {
+        const nameCamelized = inflection.camelize(name)
+        const setterMethodName = `set${nameCamelized}`
+
+        this.prototype[name] = function () {
+          const locale = this._getConfiguration().getLocale()
+
+          return this._getTranslatedAttribute(name, locale)
+        }
+
+        this.prototype[setterMethodName] = function (newValue) {
+          const locale = this._getConfiguration().getLocale()
+
+          return this._setTranslatedAttribute(name, locale, newValue)
+        }
+
+        for (const locale of locales) {
+          const localeCamelized = inflection.camelize(locale)
+          const getterMethodNameLocalized = `${name}${localeCamelized}`
+          const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
+
+          this.prototype[getterMethodNameLocalized] = function () {
+            return this._getTranslatedAttribute(name, locale)
+          }
+
+          this.prototype[setterMethodNameLocalized] = function (newValue) {
+            return this._setTranslatedAttribute(name, locale, newValue)
+          }
+        }
+      }
+    }
+  }
+
+  getAttribute(name) {
+    const columnName = inflection.underscore(name)
+
+    if (!this.isNewRecord() && !(columnName in this._attributes)) {
+      throw new Error(`${this.constructor.name}#${name} attribute hasn't been loaded yet in ${Object.keys(this._attributes).join(", ")}`)
+    }
+
+    return this._attributes[columnName]
+  }
+
+  setAttribute(name, newValue) {
+    const setterName = `set${inflection.camelize(name)}`
+
+    if (!this.constructor.isInitialized()) throw new Error(`${this.constructor.name} model isn't initialized yet`)
+    if (!(setterName in this)) throw new Error(`No such setter method: ${this.constructor.name}#${setterName}`)
+
+    this[setterName](newValue)
+  }
+
+  _setColumnAttribute(name, newValue) {
+    const columnName = inflection.underscore(name)
+
+    if (this._attributes[columnName] != newValue) {
+      this._changes[columnName] = newValue
+    }
+  }
+
+  static getColumns() {
+    if (!this._columns) throw new Error(`${this.name} hasn't been initialized yet`)
+
+    return this._columns
+  }
+
+  static _getTable() {
+    if (!this._table) throw new Error(`${this.name} hasn't been initialized yet`)
+
+    return this._table
+  }
+
   static async last() {
-    const query = this._newQuery().order(this.primaryKey()).limit(1)
+    const query = this._newQuery().order(this.primaryKey())
     const record = await query.last()
 
     return record
@@ -39,10 +281,69 @@ export default class VelociousDatabaseRecord {
   }
 
   async save() {
+    let result
+
+    const isNewRecord = this.isNewRecord()
+
+    await this._autoSaveBelongsToRelationships()
+
     if (this.isPersisted()) {
-      return await this._updateRecordWithChanges()
+      result = await this._updateRecordWithChanges()
     } else {
-      return await this._createNewRecord()
+      result = await this._createNewRecord()
+    }
+
+    await this._autoSaveHasManyRelationships({isNewRecord})
+
+    return result
+  }
+
+  async _autoSaveBelongsToRelationships() {
+    for (const relationshipName in this._instanceRelationships) {
+      const instanceRelationship = this._instanceRelationships[relationshipName]
+
+      if (instanceRelationship.getType() != "belongsTo") {
+        continue
+      }
+
+      const model = instanceRelationship.loaded()
+
+      if (model.isChanged()) {
+        await model.save()
+
+        const foreignKey = instanceRelationship.getForeignKey()
+
+        this.setAttribute(foreignKey, model.id())
+        instanceRelationship.setPreloaded(true)
+      }
+    }
+  }
+
+  async _autoSaveHasManyRelationships({isNewRecord}) {
+    for (const relationshipName in this._instanceRelationships) {
+      const instanceRelationship = this._instanceRelationships[relationshipName]
+
+      if (instanceRelationship.getType() != "hasMany") {
+        continue
+      }
+
+      let loaded = instanceRelationship._loaded
+
+      if (!Array.isArray(loaded)) loaded = [loaded]
+
+      for (const model of loaded) {
+        const foreignKey = instanceRelationship.getForeignKey()
+
+        model.setAttribute(foreignKey, this.id())
+
+        if (model.isChanged()) {
+          await model.save()
+        }
+      }
+
+      if (isNewRecord) {
+        instanceRelationship.setPreloaded(true)
+      }
     }
   }
 
@@ -50,6 +351,75 @@ export default class VelociousDatabaseRecord {
     return inflection.underscore(inflection.pluralize(this.name))
   }
 
+  static setTableName(tableName) {
+    this._tableName = tableName
+  }
+
+  static translates(...names) {
+    for (const name of names) {
+      if (!this._translations) this._translations = {}
+      if (name in this._translations) throw new Error(`Translation already exists: ${name}`)
+
+      this._translations[name] = {}
+
+      if (!this._relationshipExists("translations")) {
+        this._defineRelationship("translations", {klass: this.getTranslationClass(), type: "hasMany"})
+      }
+    }
+  }
+
+  static getTranslationClass() {
+    if (this._translationClass) return this._translationClass
+    if (this.tableName().endsWith("_translations")) throw new Error("Trying to define a translations class for a translation class")
+
+    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.belongsTo(belongsTo)
+
+    this._translationClass = TranslationClass
+
+    return this._translationClass
+  }
+
+  static getTranslationsTableName() {
+    return `${inflection.singularize(this.tableName())}_translations`
+  }
+
+  static async hasTranslationsTable() {
+    try {
+      await this.connection().getTableByName(this.getTranslationsTableName())
+
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  _getTranslatedAttribute(name, locale) {
+    const translation = this.translations().loaded().find((translation) => translation.locale() == locale)
+
+    if (translation) {
+      return translation[name]()
+    }
+  }
+
+  _setTranslatedAttribute(name, locale, newValue) {
+    let translation = this.translations().loaded()?.find((translation) =>translation.locale() == locale)
+
+    if (!translation) translation = this.translations().build({locale})
+
+    const assignments = {}
+
+    assignments[name] = newValue
+
+    translation.assign(assignments)
+  }
+
   static _newQuery() {
     const handler = new Handler()
     const query = new Query({
@@ -58,29 +428,62 @@ export default class VelociousDatabaseRecord {
       modelClass: this
     })
 
-    return query.from(this.tableName())
+    return query.from(new FromTable({driver: this.connection(), tableName: this.tableName()}))
   }
 
   static orderableColumn() {
-    // Allow to change to 'created_at' if using UUID?
+    // FIXME: Allow to change to 'created_at' if using UUID?
 
     return this.primaryKey()
   }
 
-  static where(object) {
-    const query = this._newQuery().where(object)
+  static all() {
+    return this._newQuery()
+  }
 
-    return query
+  static async findBy(...args) {
+    return this._newQuery().findBy(...args)
   }
 
-  constructor(attributes = {}) {
-    this._attributes = attributes
+  static async findOrCreateBy(...args) {
+    return this._newQuery().findOrCreateBy(...args)
+  }
+
+  static async findOrInitializeBy(...args) {
+    return this._newQuery().findOrInitializeBy(...args)
+  }
+
+  static joins(...args) {
+    return this._newQuery().joins(...args)
+  }
+
+  static preload(...args) {
+    return this._newQuery().preload(...args)
+  }
+
+  static where(...args) {
+    return this._newQuery().where(...args)
+  }
+
+  constructor(changes = {}) {
+    this._attributes = {}
     this._changes = {}
+    this._isNewRecord = true
+    this._relationships = {}
+
+    for (const key in changes) {
+      this.setAttribute(key, changes[key])
+    }
+  }
+
+  loadExistingRecord(attributes) {
+    this._attributes = attributes
+    this._isNewRecord = false
   }
 
   assign(attributesToAssign) {
     for (const attributeToAssign in attributesToAssign) {
-      this._changes[attributeToAssign] = attributesToAssign[attributeToAssign]
+      this.setAttribute(attributeToAssign, attributesToAssign[attributeToAssign])
     }
   }
 
@@ -107,6 +510,33 @@ export default class VelociousDatabaseRecord {
     await this._connection().query(sql)
   }
 
+  _hasChanges = () => Object.keys(this._changes).length > 0
+
+  isChanged() {
+    if (this.isNewRecord() || this._hasChanges()) {
+      return true
+    }
+
+    // Check if a loaded sub-model of a relationship is changed and should be saved along with this model.
+    if (this._instanceRelationships) {
+      for (const instanceRelationshipName in this._instanceRelationships) {
+        const instanceRelationship = this._instanceRelationships[instanceRelationshipName]
+        let loaded = instanceRelationship._loaded
+
+        if (!loaded) continue
+        if (!Array.isArray(loaded)) loaded = [loaded]
+
+        for (const model of loaded) {
+          if (model.isChanged()) {
+            return true
+          }
+        }
+      }
+    }
+
+    return false
+  }
+
   _tableName() {
     if (this.__tableName) return this.__tableName
 
@@ -114,9 +544,15 @@ export default class VelociousDatabaseRecord {
   }
 
   readAttribute(attributeName) {
-    if (attributeName in this._changes) return this._changes[attributeName]
+    const attributeNameUnderscore = inflection.underscore(attributeName)
 
-    return this._attributes[attributeName]
+    if (attributeNameUnderscore in this._changes) return this._changes[attributeNameUnderscore]
+
+    if (!(attributeNameUnderscore in this._attributes) && this.isPersisted()) {
+      throw new Error(`No such attribute or not selected ${this.constructor.name}#${attributeName}`)
+    }
+
+    return this._attributes[attributeNameUnderscore]
   }
 
   async _createNewRecord() {
@@ -128,13 +564,16 @@ export default class VelociousDatabaseRecord {
       tableName: this._tableName(),
       data: this.attributes()
     })
-    const result = await this._connection().query(sql)
-    const id = result.insertId
+    await this._connection().query(sql)
+    const id = await this._connection().lastInsertID()
 
     await this._reloadWithId(id)
+    this.setIsNewRecord(false)
   }
 
   async _updateRecordWithChanges() {
+    if (!this._hasChanges()) return
+
     const conditions = {}
 
     conditions[this.constructor.primaryKey()] = this.id()
@@ -148,18 +587,12 @@ export default class VelociousDatabaseRecord {
     await this._reloadWithId(this.id())
   }
 
-  id() {
-    return this.readAttribute(this.constructor.primaryKey())
-  }
+  id = () => this.readAttribute(this.constructor.primaryKey())
+  isPersisted = () => !this._isNewRecord
+  isNewRecord = () => this._isNewRecord
 
-  isPersisted() {
-    if (this.id()) return true
-
-    return false
-  }
-
-  isNewRecord() {
-    return !this.isPersisted()
+  setIsNewRecord(newIsNewRecord) {
+    this._isNewRecord = newIsNewRecord
   }
 
   async _reloadWithId(id) {
@@ -171,6 +604,8 @@ export default class VelociousDatabaseRecord {
     const query = this.constructor.where(whereObject)
     const reloadedModel = await query.first()
 
+    if (!reloadedModel) throw new Error(`${this.constructor.name}#${this.id()} couldn't be reloaded - record didn't exist`)
+
     this._attributes = reloadedModel.attributes()
     this._changes = {}
   }

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

@@ -0,0 +1,28 @@
+export default class VelociousDatabaseRecordBaseInstanceRelationship {
+  constructor({model, relationship}) {
+    this.model = model
+    this.relationship = relationship
+  }
+
+  loaded() {
+    if (!this._preloaded && this.model.isPersisted()) {
+      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
+    }
+
+    return this._loaded
+  }
+
+  setLoaded(model) {
+    this._loaded = model
+  }
+
+  setPreloaded(preloadedValue) {
+    this._preloaded = preloadedValue
+  }
+
+  getForeignKey = () => this.getRelationship().getForeignKey()
+  getPrimaryKey = () => this.getRelationship().getPrimaryKey()
+  getRelationship = () => this.relationship
+  getTargetModelClass = () => this.getRelationship().getTargetModelClass()
+  getType = () => this.getRelationship().getType()
+}

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

@@ -0,0 +1,20 @@
+import BaseInstanceRelationship from "./base.mjs"
+
+export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
+  constructor(args) {
+    super(args)
+  }
+
+  build(data) {
+    const targetModelClass = this.getTargetModelClass()
+    const newInstance = new targetModelClass(data)
+
+    this._loaded = newInstance
+
+    return newInstance
+  }
+
+  setLoaded(models) {
+    this._loaded = models
+  }
+}

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

@@ -0,0 +1,47 @@
+import BaseInstanceRelationship from "./base.mjs"
+
+export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
+  constructor(args) {
+    super(args)
+    this._loaded = []
+  }
+
+  build(data) {
+    const targetModelClass = this.getTargetModelClass()
+    const newInstance = new targetModelClass(data)
+
+    this._loaded.push(newInstance)
+
+    return newInstance
+  }
+
+  loaded() {
+    if (!this._preloaded && this.model.isPersisted()) {
+      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
+    }
+
+    return this._loaded
+  }
+
+  addToLoaded(models) {
+    if (Array.isArray(models)) {
+      for (const model of models) {
+        this._loaded.push(model)
+      }
+    } else {
+      this._loaded.push(models)
+    }
+  }
+
+  setLoaded(models) {
+    if (!Array.isArray(models)) throw new Error(`Argument given to setLoaded wasn't an array: ${typeof models}`)
+
+    this._loaded = models
+  }
+
+  setPreloaded(preloadedValue) {
+    this._preloaded = preloadedValue
+  }
+
+  getTargetModelClass = () => this.relationship.getTargetModelClass()
+}