velocious 1.0.108 → 1.0.110

package/src/database/table-data/index.js

@@ -1,199 +0,0 @@
-// @ts-check
-
-import TableColumn from "./table-column.js"
-import TableIndex from "./table-index.js"
-import TableReference from "./table-reference.js"
-
-/**
- * @typedef {object} TableDataArgsType
- * @property {boolean} ifNotExists
- */
-
-export default class TableData {
-  /** @type {TableColumn[]} */
-  _columns = []
-
-  /** @type {import("./table-foreign-key.js").default[]} */
-  _foreignKeys = []
-
-  /** @type {TableIndex[]} */
-  _indexes = []
-
-  /** @type {TableReference[]} */
-  _references = []
-
-  /**
-   * @param {string} name
-   * @param {TableDataArgsType} [args]
-   */
-  constructor(name, args) {
-    if (!name) throw new Error(`Invalid table name: ${name}`)
-
-    this.args = args
-    this._name = name
-  }
-
-  /**
-   * @param {string|TableColumn} name
-   * @param {import("./table-column.js").TableColumnArgsType} [args]
-   */
-  addColumn(name, args) {
-    if (name instanceof TableColumn) {
-      this.getColumns().push(name)
-    } else {
-      const column = new TableColumn(name, args)
-
-      this.getColumns().push(column)
-    }
-  }
-
-  /**
-   * @returns {TableColumn[]}
-   */
-  getColumns() { return this._columns }
-
-  /**
-   * @param {import("./table-foreign-key.js").default} foreignKey
-   */
-  addForeignKey(foreignKey) { this._foreignKeys.push(foreignKey) }
-
-  /**
-   * @returns {import("./table-foreign-key.js").default[]}
-   */
-  getForeignKeys() { return this._foreignKeys }
-
-  /**
-   * @param {TableIndex} index
-   */
-  addIndex(index) { this._indexes.push(index) }
-
-  /**
-   * @returns {TableIndex[]}
-   */
-  getIndexes() { return this._indexes }
-
-  /**
-   * @returns {string}
-   */
-  getName() { return this._name }
-
-  /**
-   * @param {string} newName
-   * @returns {void}
-   */
-  setName(newName) { this._name = newName }
-
-  /**
-   * @returns {boolean}
-   */
-  getIfNotExists() { return this.args?.ifNotExists || false }
-
-  /**
-   * @returns {TableReference[]}
-   */
-  getReferences() { return this._references }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  bigint(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  blob(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "blob"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  boolean(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "boolean"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  datetime(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "datetime"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  integer(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "integer"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  json(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "json"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  tinyint(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "tinyint"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  references(name, args) {
-    const columnName = `${name}_id`
-    const reference = new TableReference(name, args)
-    const {polymorphic, ...restArgs} = args
-    const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, restArgs)
-    const column = new TableColumn(columnName, columnArgs)
-    const index = new TableIndex([column])
-
-    this.getColumns().push(column)
-    this.getIndexes().push(index)
-    this.getReferences().push(reference)
-
-    if (polymorphic) {
-      const typeColumnName = `${name}_type`
-      const typeColumn = new TableColumn(typeColumnName, {isNewColumn: true, type: "string"})
-
-      this.getColumns().push(typeColumn)
-    }
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  string(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "string"}, args)) }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  text(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "text"}, args)) }
-
-  /**
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  timestamps(args) {
-    this.datetime("created_at", args)
-    this.datetime("updated_at", args)
-  }
-
-  /**
-   * @param {string} name
-   * @param {import("./table-column.js").TableColumnArgsType} args
-   * @returns {void}
-   */
-  uuid(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "uuid"}, args)) }
-}

package/src/database/table-data/table-column.js

@@ -1,283 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {{unique: boolean}} IndexArgType
- */
-
-import * as inflection from "inflection"
-import restArgsError from "../../utils/rest-args-error.js"
-import TableForeignKey from "./table-foreign-key.js"
-
-/**
- * @typedef {object} TableColumnArgsType
- * @property {boolean} [autoIncrement]
- * @property {any} [default]
- * @property {boolean} [dropColumn]
- * @property {boolean|object} [foreignKey]
- * @property {boolean|IndexArgType} [index]
- * @property {boolean} [isNewColumn]
- * @property {number} [maxLength]
- * @property {boolean} [null]
- * @property {boolean} [polymorphic]
- * @property {boolean} [primaryKey]
- * @property {string} [type]
- */
-
-export default class TableColumn {
-  /**
-   * @param {string} name
-   * @param {TableColumnArgsType} [args]
-   */
-  constructor(name, args) {
-    if (args) {
-      const {autoIncrement, default: columnDefault, dropColumn, foreignKey, index, isNewColumn, maxLength, null: argsNull, polymorphic, primaryKey, type, ...restArgs} = args // eslint-disable-line no-unused-vars
-
-      if (Object.keys(args).length == 0) {
-        throw new Error("Empty args given")
-      }
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args || {}
-    this.name = name
-  }
-
-  /**
-   * @returns {string} name
-   */
-  getName() { return this.name }
-
-  /**
-   * @returns {string | undefined}
-   */
-  getNewName() { return this._newName }
-
-  /**
-   * @param {string} newName
-   * @returns {void}
-   */
-  setNewName(newName) { this._newName = newName }
-
-  /**
-   * @returns {string}
-   */
-  getActualName() { return this.getNewName() || this.getName() }
-
-  /**
-   * @returns {boolean}
-   */
-  getAutoIncrement() { return this.args?.autoIncrement || false }
-
-  /**
-   * @param {boolean} newAutoIncrement
-   * @returns {void}
-   */
-  setAutoIncrement(newAutoIncrement) { this.args.autoIncrement = newAutoIncrement }
-
-  /**
-   * @returns {any}
-   */
-  getDefault() { return this.args?.default }
-
-  /**
-   * @param {any} newDefault
-   * @returns {void}
-   */
-  setDefault(newDefault) { this.args.default = newDefault }
-
-  /**
-   * @returns {boolean}
-   */
-  getDropColumn() { return this.args?.dropColumn || false }
-
-  /**
-   * @returns {boolean | object | undefined}
-   */
-  getForeignKey() { return this.args?.foreignKey }
-
-  /**
-   * @param {boolean | object | undefined} newForeignKey
-   * @returns {void}
-   */
-  setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
-
-  /**
-   * @returns {boolean|IndexArgType}
-   */
-  getIndex() { return this.args?.index || false }
-
-  /**
-   * @returns {IndexArgType}
-   */
-  getIndexArgs() {
-    if (typeof this.args?.index == "object") {
-      return this.args.index
-    } else {
-      return {unique: false}
-    }
-  }
-
-  getIndexUnique() {
-    const index = this.args?.index
-
-    if (typeof index == "object" && index.unique === true) return true
-
-    return false
-  }
-
-  /**
-   * @param {boolean|IndexArgType} newIndex
-   * @returns {void}
-   */
-  setIndex(newIndex) { this.args.index = newIndex }
-
-  /**
-   * @returns {number | undefined}
-   */
-  getMaxLength() { return this.args?.maxLength }
-
-  /**
-   * @param {number | undefined} newMaxLength
-   * @returns {void}
-   */
-  setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
-
-  /**
-   * @returns {boolean | undefined}
-   */
-  getNull() { return this.args?.null }
-
-  /**
-   * @param {boolean} nullable
-   * @returns {void}
-   */
-  setNull(nullable) { this.args.null = nullable }
-
-  /**
-   * @returns {boolean}
-   */
-  getPrimaryKey() { return this.args?.primaryKey || false }
-
-  /**
-   * @param {boolean} newPrimaryKey
-   * @returns {void}
-   */
-  setPrimaryKey(newPrimaryKey) { this.args.primaryKey = newPrimaryKey }
-
-  /**
-   * @returns {string | undefined}
-   */
-  getType() { return this.args?.type }
-
-  /**
-   * @param {string | undefined} newType
-   * @returns {void}
-   */
-  setType(newType) { this.args.type = newType }
-
-  /**
-   * @returns {boolean}
-   */
-  isNewColumn() { return this.args?.isNewColumn || false }
-
-  /**
-   * @param {object} args
-   * @param {boolean} args.forAlterTable
-   * @param {import("../drivers/base.js").default} args.driver
-   * @returns {string}
-   */
-  getSQL({forAlterTable, driver, ...restArgs}) {
-    restArgsError(restArgs)
-
-    const databaseType = driver.getType()
-    const options = driver.options()
-    let maxlength = this.getMaxLength()
-    let type = this.getType()?.toUpperCase()
-
-    if (type == "DATETIME" && databaseType == "pgsql") {
-      type = "TIMESTAMP"
-    }
-
-    if (type == "STRING") {
-      type = "VARCHAR"
-      maxlength ||= 255
-    }
-
-    if (databaseType == "mssql" && type == "BOOLEAN") {
-      type = "BIT"
-    } else if (databaseType == "mssql" && type == "UUID") {
-      type = "VARCHAR"
-      maxlength ||= 36
-    }
-
-    if (databaseType == "sqlite" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "INTEGER"
-    }
-
-    if (databaseType == "pgsql" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "SERIAL"
-    }
-
-    let sql = `${options.quoteColumnName(this.getActualName())} `
-
-    if (databaseType == "pgsql" && forAlterTable) sql += "TYPE "
-    if (type) sql += type
-    if (type && maxlength !== undefined && maxlength !== null) sql += `(${maxlength})`
-
-    if (this.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
-      if (databaseType == "mssql") {
-        sql += " IDENTITY"
-      } else if (databaseType == "pgsql") {
-        if (this.getAutoIncrement() && this.getPrimaryKey()) {
-          // Do nothing
-        } else {
-          throw new Error("pgsql auto increment must be primary key")
-        }
-      } else {
-        sql += " AUTO_INCREMENT"
-      }
-    }
-
-    if (typeof this.getDefault() == "function") {
-      const defaultValue = this.getDefault()()
-
-      sql += ` DEFAULT (`
-
-      if (databaseType == "pgsql" && defaultValue == "UUID()") {
-        sql += "gen_random_uuid()"
-      } else if (databaseType == "mssql" && defaultValue == "UUID()") {
-        sql += "NEWID()"
-      } else {
-        sql += defaultValue
-      }
-
-      sql += ")"
-    } else if (this.getDefault()) {
-      sql += ` DEFAULT ${options.quote(this.getDefault())}`
-    }
-
-    if (this.getPrimaryKey()) sql += " PRIMARY KEY"
-    if (this.getNull() === false) sql += " NOT NULL"
-
-    const foreignKey = this.getForeignKey()
-
-    if (foreignKey) {
-      let foreignKeyTable, foreignKeyColumn
-
-      if (foreignKey === true) {
-        foreignKeyColumn = "id"
-        foreignKeyTable = inflection.pluralize(this.getActualName().replace(/_id$/, ""))
-      } else if (foreignKey instanceof TableForeignKey) {
-        foreignKeyColumn = foreignKey.getReferencedColumnName()
-        foreignKeyTable = foreignKey.getReferencedTableName()
-      } else {
-        throw new Error(`Unknown foreign key type given: ${foreignKey} (${typeof foreignKey})`)
-      }
-
-      sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
-    }
-
-    return sql
-  }
-}

package/src/database/table-data/table-foreign-key.js

@@ -1,61 +0,0 @@
-// @ts-check
-
-import restArgsError from "../../utils/rest-args-error.js"
-
-export default class TableForeignKey {
-  /**
-   * @param {object} args
-   * @param {string} args.columnName
-   * @param {boolean} [args.isNewForeignKey]
-   * @param {string} [args.name]
-   * @param {string} args.tableName
-   * @param {string} args.referencedColumnName
-   * @param {string} args.referencedTableName
-   */
-  constructor({columnName, isNewForeignKey, name, tableName, referencedColumnName, referencedTableName, ...restArgs}) {
-    restArgsError(restArgs)
-
-    this._columnName = columnName
-    this._isNewForeignKey = isNewForeignKey
-    this._name = name
-    this._tableName = tableName
-    this._referencedColumnName = referencedColumnName
-    this._referencedTableName = referencedTableName
-  }
-
-  /**
-   * @returns {string}
-   */
-  getColumnName() { return this._columnName }
-
-  /**
-   * @returns {boolean}
-   */
-  getIsNewForeignKey() { return this._isNewForeignKey || false }
-
-  /**
-   * @returns {string}
-   */
-  getTableName() { return this._tableName }
-
-  /**
-   * @returns {string}
-   */
-  getReferencedColumnName() { return this._referencedColumnName }
-
-  /**
-   * @returns {string}
-   */
-  getReferencedTableName() { return this._referencedTableName }
-
-  /**
-   * @returns {string}
-   */
-  getName() { return this._name }
-
-  /**
-   * @param {string} newName
-   * @returns {void}
-   */
-  setName(newName) { this._name = newName }
-}

package/src/database/table-data/table-index.js

@@ -1,41 +0,0 @@
-// @ts-check
-
-import restArgsError from "../../utils/rest-args-error.js"
-
-/**
- * @typedef {object} TableIndexArgsType
- * @property {string} name
- * @property {boolean} unique
- */
-
-export default class TableIndex {
-  /**
-   * @param {Array<string | import("./table-column.js").default>} columns
-   * @param {TableIndexArgsType} [args]
-   */
-  constructor(columns, args) {
-    if (args) {
-      const {name, unique, ...restArgs} = args // eslint-disable-line no-unused-vars
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.columns = columns
-  }
-
-  /**
-   * @returns {Array<string | import("./table-column.js").default>}
-   */
-  getColumns() { return this.columns }
-
-  /**
-   * @returns {string | undefined}
-   */
-  getName() { return this.args?.name }
-
-  /**
-   * @returns {boolean}
-   */
-  getUnique() { return Boolean(this.args?.unique) }
-}

package/src/database/table-data/table-reference.js

@@ -1,12 +0,0 @@
-// @ts-check
-
-export default class TableReference {
-  /**
-   * @param {string} name
-   * @param {object} args
-   */
-  constructor(name, args) {
-    this.args = args
-    this.name = name
-  }
-}

package/src/database/use-database.js

@@ -1,48 +0,0 @@
-// @ts-check
-
-// @ts-expect-error
-import React from "react"
-import useEnvSense from "env-sense/src/use-env-sense.js"
-
-import Configuration from "../configuration.js"
-import Migrator from "./migrator.js"
-import restArgsError from "../utils/rest-args-error.js"
-
-/**
- * @param {object} args
- * @param {() => Promise<import("./migrator/types.js").RequireMigrationContextType>} args.migrationsRequireContextCallback
- * @returns {{loaded: boolean}}
- */
-export default function loadMigrations({migrationsRequireContextCallback, ...restArgs}) {
-  const instance = React.useMemo(() => ({running: false}), [])
-  const {isServer} = useEnvSense()
-  const [loaded, setLoaded] = React.useState(false)
-
-  const loadDatabase = React.useCallback(async () => {
-    instance.running = true
-
-    try {
-      await Configuration.current().ensureConnections(async () => {
-        const migrator = new Migrator({configuration: Configuration.current()})
-
-        await migrator.prepare()
-        await migrator.migrateFilesFromRequireContext(await migrationsRequireContextCallback())
-      })
-
-      await Configuration.current().initialize()
-      setLoaded(true)
-    } finally {
-      instance.running = false
-    }
-  }, [])
-
-  React.useMemo(() => {
-    if (!loaded && !isServer && !instance.running) {
-      loadDatabase()
-    }
-  }, [loaded])
-
-  restArgsError(restArgs)
-
-  return {loaded}
-}