velocious 1.0.107 → 1.0.109

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

@@ -1,103 +0,0 @@
-// @ts-check
-
-export default class VelociousDatabaseRecordBaseInstanceRelationship {
-  /** @type {boolean | undefined} */
-  _autoSave = undefined
-
-  /**
-   * @param {object} args
-   * @param {import("../index.js").default} args.model
-   * @param {import("../relationships/base.js").default} args.relationship
-   */
-  constructor({model, relationship}) {
-    this._dirty = false
-    this.model = model
-    this.relationship = relationship
-  }
-
-  /**
-   * @abstract
-   * @param {import("../index.js").default[] | import("../index.js").default} models
-   * @returns {void}
-   */
-  addToLoaded(models) { // eslint-disable-line no-unused-vars
-    throw new Error("addToLoaded not implemented")
-  }
-
-  /**
-   * @abstract
-   * @param {Record<string, any>} attributes
-   * @returns {import("../index.js").default}
-   */
-  build(attributes) { // eslint-disable-line no-unused-vars
-    throw new Error("'build' not implemented")
-  }
-
-  /** @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model */
-  getAutoSave() { return this._autoSave }
-
-  /**
-   * @param {boolean} newAutoSaveValue Whether the relationship should be auto-saved before saving the parent model
-   * @returns {void}
-   */
-  setAutoSave(newAutoSaveValue) { this._autoSave = newAutoSaveValue }
-
-  /**
-   * @param {boolean} newValue Whether the relationship is dirty (has been modified)
-   * @returns {void}
-   */
-  setDirty(newValue) { this._dirty = newValue }
-
-  /** @returns {boolean} Whether the relationship is dirty (has been modified) */
-  getDirty() { return this._dirty }
-
-  /**
-   * @abstract
-   * @returns {Promise<void>}
-   */
-  load() {
-    throw new Error("'load' not implemented")
-  }
-
-  /**  @returns {boolean} Whether the relationship has been preloaded */
-  isLoaded() { return Boolean(this._loaded) }
-
-  /** @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type) */
-  loaded() {
-    if (!this._preloaded && this.model.isPersisted()) {
-      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
-    }
-
-    return this._loaded
-  }
-
-  /** @param {import("../index.js").default|Array<import("../index.js").default>|undefined} model */
-  setLoaded(model) { this._loaded = model }
-
-  /** @returns {import("../index.js").default | import("../index.js").default[] | undefined} */
-  getLoadedOrUndefined() { return this._loaded }
-
-  /** @returns {boolean} The loaded model or models (depending on relationship type) */
-  getPreloaded() { return this._preloaded || false }
-
-  /** @param {boolean} isPreloaded */
-  setPreloaded(isPreloaded) { this._preloaded = isPreloaded }
-
-  /** @returns {string} The foreign key for this relationship */
-  getForeignKey() { return this.getRelationship().getForeignKey() }
-
-  /** @returns {import("../index.js").default} model */
-  getModel() { return this.model }
-
-  /** @returns {string} The primary key for this relationship's model */
-  getPrimaryKey() { return this.getRelationship().getPrimaryKey() }
-
-  /** @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on */
-  getRelationship() { return this.relationship }
-
-  /** @returns {typeof import("../index.js").default | undefined} The model class that this instance relationship */
-  getTargetModelClass() { return this.getRelationship().getTargetModelClass() }
-
-  /** @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.) */
-  getType() { return this.getRelationship().getType() }
-}

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

@@ -1,37 +0,0 @@
-// @ts-check
-
-import BaseInstanceRelationship from "./base.js"
-
-export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
-  /**
-   * @param {Record<string, any>} data
-   * @returns {import("../index.js").default}
-   */
-  build(data) {
-    const TargetModelClass = this.getTargetModelClass()
-
-    if (!TargetModelClass) throw new Error("Can't build a new record without a target model")
-
-    const newInstance = new TargetModelClass(data)
-
-    this._loaded = newInstance
-
-    return newInstance
-  }
-
-  getLoadedOrUndefined() { return this._loaded }
-
-  async load() {
-    const foreignKey = this.getForeignKey()
-    const foreignModelID = this.getModel().readColumn(foreignKey)
-    const TargetModelClass = this.getTargetModelClass()
-
-    if (!TargetModelClass) throw new Error("Can't load without a target model")
-
-    const foreignModel = await TargetModelClass.find(foreignModelID)
-
-    this.setLoaded(foreignModel)
-    this.setDirty(false)
-    this.setPreloaded(true)
-  }
-}

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

@@ -1,116 +0,0 @@
-// @ts-check
-
-import BaseInstanceRelationship from "./base.js"
-
-export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
-  /**
-   * @param {Record<string, any>} data
-   * @returns {import("../index.js").default}
-   */
-  build(data) {
-    // Spawn new model of the targeted class
-    const targetModelClass = this.getTargetModelClass()
-
-    if (!targetModelClass) throw new Error("Can't build a new record without a taget model class")
-
-    const newInstance = new targetModelClass(data)
-
-
-    // Add it to the loaded models of this relationship
-    if (this._loaded === undefined) {
-      /** @type {import("../index.js").default[]} */
-      this._loaded = [newInstance]
-    } else if (Array.isArray(this._loaded)) {
-      this._loaded.push(newInstance)
-    } else {
-      throw new Error(`Loaded had an unexpected type: ${typeof this._loaded}`)
-    }
-
-
-    // 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
-  }
-
-  async load() {
-    const foreignKey = this.getForeignKey()
-    const primaryKey = this.getPrimaryKey()
-    const primaryModelID = this.getModel().readColumn(primaryKey)
-    const TargetModelClass = this.getTargetModelClass()
-
-    if (!TargetModelClass) throw new Error("Cannot load without a target model class")
-
-    /** @type {Record<string, any>} */
-    const whereArgs = {}
-
-    whereArgs[foreignKey] = primaryModelID
-
-    const foreignModels = await TargetModelClass.where(whereArgs).toArray()
-
-    this.setLoaded(foreignModels)
-    this.setDirty(false)
-    this.setPreloaded(true)
-  }
-
-  /**
-   * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
-   */
-  loaded() {
-    if (!this._preloaded && this.model.isPersisted()) {
-      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
-    }
-
-    if (this._loaded === undefined && this.model.isNewRecord()) {
-      return []
-    }
-
-    return this._loaded
-  }
-
-  /**
-   * @param {import("../index.js").default[] | import("../index.js").default} models
-   * @returns {void}
-   */
-  addToLoaded(models) {
-    if (!models) {
-      throw new Error("Need to give something")
-    } else if (Array.isArray(models)) {
-      for (const model of models) {
-        if (this._loaded === undefined) {
-          this._loaded = [model]
-        } else if (Array.isArray(this._loaded)) {
-          this._loaded.push(model)
-        } else {
-          throw new Error(`Unexpected loaded type: ${typeof this._loaded}`)
-        }
-      }
-    } else {
-      if (this._loaded === undefined) {
-        this._loaded = [models]
-      } else if (Array.isArray(this._loaded)) {
-        this._loaded.push(models)
-      } else {
-        throw new Error(`Unexpected loaded type: ${typeof this._loaded}`)
-      }
-    }
-  }
-
-  /**
-   * @param {import("../index.js").default[]} models
-   */
-  setLoaded(models) {
-    if (!Array.isArray(models)) throw new Error(`Argument given to setLoaded wasn't an array: ${typeof models}`)
-
-    this._loaded = models
-  }
-}

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

@@ -1,66 +0,0 @@
-// @ts-check
-
-import BaseInstanceRelationship from "./base.js"
-
-export default class VelociousDatabaseRecordHasOneInstanceRelationship extends BaseInstanceRelationship {
-  /** @type {import("../index.js").default | undefined} */
-  _loaded = undefined
-
-  /**
-   * @param {Record<string, any>} data
-   * @returns {import("../index.js").default}
-   */
-  build(data) {
-    const TargetModelClass = this.getTargetModelClass()
-
-    if (!TargetModelClass) throw new Error("Can't build a new record without a target model class")
-
-    const newInstance = new TargetModelClass(data)
-
-    this._loaded = newInstance
-
-    return newInstance
-  }
-
-  async load() {
-    const foreignKey = this.getForeignKey()
-    const primaryKey = this.getPrimaryKey()
-    const primaryModelID = this.getModel().readColumn(primaryKey)
-    const TargetModelClass = this.getTargetModelClass()
-
-    if (!TargetModelClass) throw new Error("Can't load without a target model class")
-
-    /** @type {Record<string, any>} */
-    const whereArgs = {}
-
-    whereArgs[foreignKey] = primaryModelID
-
-    const foreignModel = await TargetModelClass.where(whereArgs).first()
-
-    this.setLoaded(foreignModel)
-    this.setDirty(false)
-    this.setPreloaded(true)
-  }
-
-  /**
-   * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
-   */
-  loaded() {
-    if (!this._preloaded && this.model.isPersisted()) {
-      throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
-    }
-
-    return this._loaded
-  }
-
-  getLoadedOrUndefined() { return this._loaded }
-
-  /** @param {import("../index.js").default|Array<import("../index.js").default>} model */
-  setLoaded(model) {
-    if (Array.isArray(model)) throw new Error(`Argument given to setLoaded was an array: ${typeof model}`)
-
-    this._loaded = model
-  }
-
-  getTargetModelClass() { return this.relationship.getTargetModelClass() }
-}

package/src/database/record/record-not-found-error.js

@@ -1,3 +0,0 @@
-// @ts-check
-
-export default class RecordNotFoundError extends Error {}

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

@@ -1,91 +0,0 @@
-// @ts-check
-
-import restArgsError from "../../../utils/rest-args-error.js"
-
-/**
- * @typedef {object} RelationshipBaseArgsType
- * @property {string} [className]
- * @property {string} [dependent]
- * @property {string | undefined} [foreignKey]
- * @property {string} [inverseOf]
- * @property {typeof import("../index.js").default} [klass]
- * @property {typeof import("../index.js").default} modelClass
- * @property {string} [primaryKey]
- * @property {boolean} [polymorphic]
- * @property {string} relationshipName
- * @property {string} [through]
- * @property {string} type
- */
-
-export default class VelociousDatabaseRecordBaseRelationship {
-  /** @param {RelationshipBaseArgsType} args */
-  constructor({className, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", polymorphic, relationshipName, through, type, ...restArgs}) {
-    restArgsError(restArgs)
-
-    if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
-    if (!className && !klass) throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`)
-
-    this.className = className
-    this._dependent = dependent
-    this.foreignKey = foreignKey
-    this._inverseOf = inverseOf
-    this.klass = klass
-    this.modelClass = modelClass
-    this._polymorphic = polymorphic
-    this._primaryKey = primaryKey
-    this.relationshipName = relationshipName
-    this.through = through
-    this.type = type
-  }
-
-  getConfiguration() { return this.modelClass._getConfiguration() }
-
-  /** @returns {string | undefined} What will be done when the parent record is destroyed. E.g. "destroy", "nullify", "restrict" etc. */
-  getDependent() { return this._dependent }
-
-  /**
-   * @abstract
-   * @returns {string} The name of the foreign key, e.g. "user_id", "post_id" etc.
-   */
-  getForeignKey() {
-    throw new Error("getForeignKey not implemented")
-  }
-
-  /**
-   * @abstract
-   * @returns {string | undefined} The name of the inverse relationship, e.g. "posts", "comments" etc.
-   */
-  getInverseOf() {
-    throw new Error("getInverseOf not implemented")
-  }
-
-  /** @returns {typeof import("../index.js").default} */
-  getModelClass() { return this.modelClass }
-
-  /** @returns {string} The name of the relationship, e.g. "posts", "user", "comments" etc. */
-  getRelationshipName() { return this.relationshipName }
-
-  /** @returns {boolean} */
-  getPolymorphic() {
-    return this._polymorphic || false
-  }
-
-  /** @returns {string} The name of the foreign key, e.g. "id" etc. */
-  getPrimaryKey() { return this._primaryKey }
-
-  /** @returns {string} The type of the relationship, e.g. "has_many", "belongs_to", "has_one", "has_and_belongs_to_many" etc. */
-  getType() { return this.type }
-
-  /** @returns {typeof import("../index.js").default | undefined} The target model class for this relationship, e.g. if the relationship is "posts" then the target model class is the Post class. */
-  getTargetModelClass() {
-    if (this.getPolymorphic()) {
-      return undefined
-    } else if (this.className) {
-      return this.getConfiguration().getModelClass(this.className)
-    } else if (this.klass) {
-      return this.klass
-    }
-
-    throw new Error("Couldn't figure out the target model class")
-  }
-}

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

@@ -1,46 +0,0 @@
-// @ts-check
-
-import BaseRelationship from "./base.js"
-import * as inflection from "inflection"
-
-export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRelationship {
-  /** @returns {string} */
-  getForeignKey() {
-    if (!this.foreignKey) {
-      const targetModelClass = this.getTargetModelClass()
-
-      if (!targetModelClass) throw new Error("Can't calculate foreign key without a target model class")
-
-      this.foreignKey = `${inflection.underscore(targetModelClass.name)}_id`
-    }
-
-    return this.foreignKey
-  }
-
-  /** @returns {string | undefined} */
-  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)}`
-
-      const targetModelClass = this.getTargetModelClass()
-
-      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
-        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = targetModelClass.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

@@ -1,39 +0,0 @@
-// @ts-check
-
-import BaseRelationship from "./base.js"
-import * as inflection from "inflection"
-
-export default class VelociousDatabaseRecordHasManyRelationship extends BaseRelationship {
-  /** @returns {string} */
-  getForeignKey() {
-    if (!this.foreignKey) {
-      this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`
-    }
-
-    return this.foreignKey
-  }
-
-  /** @returns {string | undefined} */
-  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)}`)
-
-      const targetModelClass = this.getTargetModelClass()
-
-      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
-        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = targetModelClass.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

@@ -1,39 +0,0 @@
-// @ts-check
-
-import BaseRelationship from "./base.js"
-import * as inflection from "inflection"
-
-export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelationship {
-  /** @returns {string} */
-  getForeignKey() {
-    if (!this.foreignKey) {
-      this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`
-    }
-
-    return this.foreignKey
-  }
-
-  /** @returns {string | undefined} */
-  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)}`
-
-      const targetModelClass = this.getTargetModelClass()
-
-      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
-        // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = targetModelClass.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/user-module.js

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

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

@@ -1,24 +0,0 @@
-// @ts-check
-
-export default class VelociousDatabaseRecordValidatorsBase {
-  /**
-   * @param {object} args
-   * @param {string} args.attributeName
-   * @param {Record<string, any>} args.args
-   */
-  constructor({attributeName, args}) {
-    this.attributeName = attributeName
-    this.args = args
-  }
-
-  /**
-   * @abstract
-   * @param {object} args
-   * @param {import("../index.js").default} args.model
-   * @param {string} args.attributeName
-   * @returns {Promise<void>}
-   */
-  async validate({model, attributeName}) { // eslint-disable-line no-unused-vars
-    throw new Error("validate not implemented")
-  }
-}

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

@@ -1,20 +0,0 @@
-// @ts-check
-
-import Base from "./base.js"
-
-export default class VelociousDatabaseRecordValidatorsPresence extends Base {
-  /**
-   * @param {object} args
-   * @param {import("../index.js").default} args.model
-   * @param {string} args.attributeName
-   */
-  async validate({model, attributeName}) {
-    const attributeValue = model.readAttribute(attributeName)?.trim()
-
-    if (!attributeValue) {
-      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []
-
-      model._validationErrors[attributeName].push({type: "presence", message: "can't be blank"})
-    }
-  }
-}

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

@@ -1,42 +0,0 @@
-// @ts-check
-
-import Base from "./base.js"
-import * as inflection from "inflection"
-
-export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
-  /**
-   * @param {object} args
-   * @param {import("../index.js").default} args.model
-   * @param {string} args.attributeName
-   * @returns {Promise<void>}
-   */
-  async validate({model, attributeName}) {
-    const modelClass = /** @type {typeof import("../index.js").default} */ (model.constructor)
-
-    const connection = modelClass.connection()
-    const tableName = modelClass._getTable().getName()
-    const attributeValue = model.readAttribute(attributeName)
-    const attributeNameUnderscore = inflection.underscore(attributeName)
-
-    /** @type {Record<string, any>} */
-    const whereArgs = {}
-
-    whereArgs[attributeNameUnderscore] = attributeValue
-
-    let existingRecordQuery = modelClass
-      .select(modelClass.primaryKey())
-      .where(whereArgs)
-
-    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] = []
-
-      model._validationErrors[attributeName].push({type: "uniqueness", message: "has already been taken"})
-    }
-  }
-}