velocious 1.0.108 → 1.0.110

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

@@ -1,123 +0,0 @@
-// @ts-check
-
-import BaseTable from "../base-table.js"
-import Column from "./column.js"
-import ColumnsIndex from "./columns-index.js"
-import ForeignKey from "./foreign-key.js"
-
-export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
-  /**
-   * @param {import("../base.js").default} driver
-   * @param {Record<string, any>} data
-   */
-  constructor(driver, data) {
-    super()
-    this.data = data
-    this.driver = driver
-  }
-
-  async getColumns() {
-    const result = await this.driver.query(`
-      SELECT
-        columns.*,
-        CASE WHEN key_column_usage.column_name IS NOT NULL THEN 1 ELSE 0 END AS is_primary_key
-
-      FROM
-        information_schema.columns AS columns
-
-      LEFT JOIN information_schema.table_constraints AS table_constraints ON
-        table_constraints.table_name = columns.table_name AND
-        table_constraints.table_schema = columns.table_schema AND
-        table_constraints.constraint_type = 'PRIMARY KEY'
-
-      LEFT JOIN information_schema.key_column_usage AS key_column_usage ON
-        key_column_usage.constraint_name = table_constraints.constraint_name AND
-        key_column_usage.table_schema = table_constraints.table_schema AND
-        key_column_usage.table_name = columns.table_name AND
-        key_column_usage.column_name = columns.column_name
-
-      WHERE
-        columns.table_catalog = CURRENT_DATABASE() AND
-        columns.table_schema = 'public' AND
-        columns.table_name = '${this.getName()}'
-    `)
-    const columns = []
-
-    for (const data of result) {
-      const column = new Column(this, data)
-
-      columns.push(column)
-    }
-
-    return columns
-  }
-
-  async getForeignKeys() {
-    const sql = `
-      SELECT
-        tc.constraint_name,
-        tc.table_name,
-        kcu.column_name,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name
-
-      FROM
-        information_schema.table_constraints AS tc
-
-      JOIN information_schema.key_column_usage AS kcu ON
-        tc.constraint_name = kcu.constraint_name
-
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-
-      WHERE
-        constraint_type = 'FOREIGN KEY' AND
-        tc.table_catalog = CURRENT_DATABASE() AND
-        tc.table_name = ${this.getDriver().quote(this.getName())}
-    `
-
-    const foreignKeyRows = await this.getDriver().query(sql)
-    const foreignKeys = []
-
-    for (const foreignKeyRow of foreignKeyRows) {
-      const foreignKey = new ForeignKey(foreignKeyRow)
-
-      foreignKeys.push(foreignKey)
-    }
-
-    return foreignKeys
-  }
-
-  async getIndexes() {
-    const options = this.getOptions()
-
-    const indexesRows = await this.getDriver().query(`
-      SELECT
-        pg_attribute.attname AS column_name,
-        pg_index.indexrelid::regclass as index_name,
-        pg_class.relnamespace::regnamespace as schema_name,
-        pg_class.relname as table_name,
-        pg_index.indisprimary as is_primary_key,
-        pg_index.indisunique as is_unique
-      FROM pg_index
-      JOIN pg_class ON pg_class.oid = pg_index.indrelid
-      JOIN pg_attribute ON pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = ANY(pg_index.indkey)
-      WHERE
-        pg_class.relname = ${options.quote(this.getName())}
-    `)
-
-    const indexes = []
-
-    for (const indexRow of indexesRows) {
-      const columnsIndex = new ColumnsIndex(this, indexRow)
-
-      indexes.push(columnsIndex)
-    }
-
-    return indexes
-  }
-
-  getName() {
-    return this.data.table_name
-  }
-}

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

@@ -1,303 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-
-import AlterTable from "./sql/alter-table.js"
-import Base from "../base.js"
-import CreateIndex from "./sql/create-index.js"
-import CreateTable from "./sql/create-table.js"
-import Delete from "./sql/delete.js"
-import DropTable from "./sql/drop-table.js"
-import escapeString from "sql-escape-string"
-import Insert from "./sql/insert.js"
-import Options from "./options.js"
-import QueryParser from "./query-parser.js"
-import Table from "./table.js"
-import Update from "./sql/update.js"
-
-export default class VelociousDatabaseDriversSqliteBase extends Base {
-  /**
-   * @param {import("../../table-data/index.js").default} tableData
-   * @returns {Promise<string[]>}
-   */
-  async alterTableSQLs(tableData) {
-    const alterArgs = {driver: this, tableData}
-    const alterTable = new AlterTable(alterArgs)
-
-    return await alterTable.toSQLs()
-  }
-
-  /**
-   * @param {import("../base.js").CreateIndexSqlArgs} indexData
-   * @returns {Promise<string[]>}
-   */
-  async createIndexSQLs(indexData) {
-    const createArgs = Object.assign({driver: this}, indexData)
-    const createIndex = new CreateIndex(createArgs)
-
-    return await createIndex.toSQLs()
-  }
-
-  /**
-   * @abstract
-   * @param {import("../../table-data/index.js").default} tableData
-   * @returns {Promise<string[]>}
-   */
-  async createTableSql(tableData) {
-    const createArgs = {tableData, driver: this, indexInCreateTable: false}
-    const createTable = new CreateTable(createArgs)
-
-    return await createTable.toSql()
-  }
-
-  currentDatabase() {
-    return null
-  }
-
-  async disableForeignKeys() {
-    await this.query("PRAGMA foreign_keys = 0")
-  }
-
-  async enableForeignKeys() {
-    await this.query("PRAGMA foreign_keys = 1")
-  }
-
-  /**
-   * @param {string} tableName
-   * @param {import("../base.js").DropTableSqlArgsType} [args]
-   * @returns {Promise<string[]>}
-   */
-  async dropTableSQLs(tableName, args = {}) {
-    const driver = /** @type {import("../base.js").default} */ (this)
-    const dropArgs = Object.assign({tableName, driver}, args)
-    const dropTable = new DropTable(dropArgs)
-
-    return await dropTable.toSQLs()
-  }
-
-  /**
-   * @param {import("../base.js").DeleteSqlArgsType} args
-   * @returns {string}
-   */
-  deleteSql(args) { return new Delete(Object.assign({driver: this}, args)).toSql() }
-
-  /**
-   * @returns {string}
-   */
-  getType() { return "sqlite" }
-
-  /**
-   * @param {import("../base.js").InsertSqlArgsType} args
-   * @returns {string}
-   */
-  insertSql(args) { return new Insert(Object.assign({driver: this}, args)).toSql() }
-
-  /**
-   * @param {string} name
-   * @param {object} [args]
-   * @param {boolean} args.throwError
-   * @returns {Promise<import("../base-table.js").default | undefined>}
-   */
-  async getTableByName(name, args) {
-    const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(name)} LIMIT 1`)
-    const row = result[0]
-
-    if (row) {
-      return new Table({driver: this, row})
-    }
-
-    if (args?.throwError !== false) {
-      const tables = await this.getTables()
-      const tableNames = tables.map((table) => table.getName())
-
-      throw new Error(`No table by that name: ${name} in ${tableNames.join(", ")}`)
-    }
-  }
-
-  /** @returns {Promise<Array<import("../base-table.js").default>>} */
-  async getTables() {
-    const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
-    const tables = []
-
-    for (const row of result) {
-      const table = new Table({driver: this, row})
-
-      tables.push(table)
-    }
-
-    return tables
-  }
-
-  /**
-   * @param {string} tableName
-   * @param {Array<string>} columns
-   * @param {Array<Array<string>>} rows
-   * @returns {Promise<void>}
-   */
-  async insertMultiple(tableName, columns, rows) {
-    await this.registerVersion()
-
-    if (this.supportsMultipleInsertValues()) {
-      await this.insertMultipleWithSingleInsert(tableName, columns, rows)
-    } else {
-      await this.insertMultipleWithTransaction(tableName, columns, rows)
-    }
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  supportsMultipleInsertValues() {
-    if (this.versionMajor >= 4) return true
-    if (this.versionMajor == 3 && this.versionMinor >= 8) return true
-    if (this.versionMajor == 3 && this.versionMinor == 7 && this.versionPatch >= 11) return true
-
-    return false
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  supportsInsertIntoReturning() {
-    if (this.versionMajor >= 4) return true
-    if (this.versionMajor == 3 && this.versionMinor >= 35) return true
-
-    return false
-  }
-
-  /**
-   * @param {string} tableName
-   * @param {Array<string>} columns
-   * @param {Array<Array<string>>} rows
-   * @returns {Promise<void>}
-   */
-  async insertMultipleWithSingleInsert(tableName, columns, rows) {
-    const sql = new Insert({columns, driver: this, rows, tableName}).toSql()
-
-    await this.query(sql)
-  }
-
-  /**
-   * @param {string} tableName
-   * @param {Array<string>} columns
-   * @param {Array<Array<string>>} rows
-   * @returns {Promise<void>}
-   */
-  async insertMultipleWithTransaction(tableName, columns, rows) {
-    /** @type {string[]} */
-    const sqls = []
-
-    for (const row of rows) {
-      /** @type {Record<string, any>} */
-      const data = []
-
-      for (const columnIndex in columns) {
-        const columnName = columns[columnIndex]
-        const value = row[columnIndex]
-
-        data[columnName] = value
-      }
-
-      const insertSql = this.insertSql({tableName, data})
-
-      sqls.push(insertSql)
-    }
-
-    await this.transaction(async () => {
-      for (const sql of sqls) {
-        await this.query(sql)
-      }
-    })
-  }
-
-  async lastInsertID() {
-    const result = await this.query("SELECT LAST_INSERT_ROWID() AS last_insert_id")
-
-    return digg(result, 0, "last_insert_id")
-  }
-
-  options() {
-    if (!this._options) this._options = new Options(this)
-
-    return this._options
-  }
-
-  /**
-   * @returns {string} - The type of the primary key for this driver.
-   */
-  primaryKeyType() { return "integer" } // Because bigint on SQLite doesn't support auto increment
-
-  /**
-   * @param {import("../../query/index.js").default} query
-   * @returns {string}
-   */
-  queryToSql(query) { return 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
-
-    const versionParts = this.version.split(".")
-
-    this.versionMajor = versionParts[0]
-    this.versionMinor = versionParts[1]
-    this.versionPatch = versionParts[2]
-  }
-
-  shouldSetAutoIncrementWhenPrimaryKey() { return false }
-
-  /**
-   * @param {any} value
-   * @returns {any}
-   */
-  escape(value) {
-    value = this._convertValue(value)
-
-    const type = typeof value
-
-    if (type != "string") value = `${value}`
-
-    const resultWithQuotes = escapeString(value, null)
-    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)
-
-    return result
-  }
-
-  /**
-   * @param {Error} error
-   * @returns {boolean}
-   */
-  retryableDatabaseError(error) {
-    if (error.message?.startsWith("attempt to write a readonly database")) return true
-    if (error.message?.startsWith("database is locked")) return true
-    if (error.message?.includes("→ Caused by: Error code : database is locked")) return true
-
-    return false
-  }
-
-  /**
-   * @param {string} value
-   * @returns {string}
-   */
-  quote(value) {
-    value = this._convertValue(value)
-
-    const type = typeof value
-
-    if (type == "number") return value
-    if (type != "string") value = `${value}`
-
-    return escapeString(value, null)
-  }
-
-  /**
-   * @param {import("../base.js").UpdateSqlArgsType} args
-   * @returns {string}
-   */
-  updateSql({conditions, data, tableName}) { return new Update({conditions, data, driver: this, tableName}).toSql() }
-}

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

@@ -1,70 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-import BaseColumn from "../base-column.js"
-
-export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.column
-   * @param {import("../base.js").default} args.driver
-   * @param {import("../base-table.js").default} args.table
-   */
-  constructor({column, driver, table}) {
-    super()
-    this.column = column
-    this.driver = driver
-    this.table = table
-  }
-
-  getAutoIncrement() { return this.getPrimaryKey() }
-
-  async getIndexes() {
-    const indexes = await this.getTable().getIndexes()
-    const indexesForColumn = indexes.filter((index) => index.getColumnNames().includes(this.getName()))
-
-    return indexesForColumn
-  }
-
-  getDefault() { return digg(this, "column", "dflt_value") }
-
-  getName() {
-    const name = digg(this, "column", "name")
-
-    if (!name) throw new Error("No name given for SQLite column")
-
-    return name
-  }
-
-  getMaxLength() {
-    const columnType = digg(this, "column", "type")
-    const match = columnType.match(/(.*)\((\d+)\)$/)
-
-    if (match) {
-      return parseInt(match[2])
-    }
-  }
-
-  getNull() {
-    const notNullValue = digg(this, "column", "notnull")
-
-    if (notNullValue === 1) {
-      return false
-    } else {
-      return true
-    }
-  }
-
-  getPrimaryKey() { return digg(this, "column", "pk") == 1 }
-
-  getType() {
-    const columnType = digg(this, "column", "type")
-    const match = columnType.match(/(.*)\((\d+)\)$/)
-
-    if (match) {
-      return match[1].toLowerCase()
-    }
-
-    return columnType.toLowerCase()
-  }
-}

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

@@ -1,30 +0,0 @@
-// @ts-check
-
-import BaseColumnsIndex from "../base-columns-index.js"
-import {digg} from "diggerize"
-import TableIndex from "../../table-data/table-index.js"
-
-export default class VelociousDatabaseDriversSqliteColumnsIndex extends BaseColumnsIndex {
-  getColumnNames() {
-    return digg(this, "data", "columnNames")
-  }
-
-  getName() {
-    return digg(this, "data", "name")
-  }
-
-  getTableDataIndex() {
-    return new TableIndex(this.getColumnNames(), {
-      name: this.getName(),
-      unique: this.isUnique()
-    })
-  }
-
-  isPrimaryKey() {
-    return false
-  }
-
-  isUnique() {
-    return digg(this, "data", "unique") == 1
-  }
-}

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

@@ -1,12 +0,0 @@
-// @ts-check
-
-export default class VelociousDatabaseDriversSqliteConnectionRemote {
-  /**
-   * @abstract
-   * @param {string} sql
-   * @returns {Promise<any[]>}
-   */
-  async query(sql) { // eslint-disable-line no-unused-vars
-    throw new Error("stub")
-  }
-}

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

@@ -1,49 +0,0 @@
-// @ts-check
-
-import debounce from "debounce"
-
-// @ts-expect-error
-import query from "./query"
-
-export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
-  /**
-   * @param {import("../base.js").default} driver
-   * @param {import("sql.js").Database} connection
-   */
-  constructor(driver, connection) {
-    this.connection = connection
-    this.driver = driver
-  }
-
-  async close() {
-    await this.saveDatabase()
-    await this.connection.close()
-  }
-
-  async disconnect() { await this.saveDatabase() }
-
-  /**
-   * @param {string} sql
-   * @returns {Promise<Record<string, any>[]>}
-   */
-  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()
-
-    // @ts-expect-error
-    await this.driver.betterLocalStorage.set(this.driver.localStorageName(), localStorageContent)
-  }
-
-  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
-}

package/src/database/drivers/sqlite/foreign-key.js

@@ -1,22 +0,0 @@
-// @ts-check
-
-import BaseForeignKey from "../base-foreign-key.js"
-import {digg} from "diggerize"
-
-export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
-  /**
-   * @param {Record<string, any>} data
-   * @param {object} args
-   * @param {string} args.tableName
-   */
-  constructor(data, {tableName}) {
-    super(data)
-    this.tableName = tableName
-  }
-
-  getColumnName() { return digg(this, "data", "from") }
-  getName() { return `${this.getTableName()}_${this.getColumnName()}_${this.data.id}` }
-  getTableName() { return digg(this, "tableName") }
-  getReferencedColumnName() { return digg(this, "data", "to") }
-  getReferencedTableName() { return digg(this, "data", "table") }
-}

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

@@ -1,52 +0,0 @@
-// @ts-check
-
-import fs from "fs/promises"
-import query from "./query.js"
-import sqlite3 from "sqlite3"
-import {open} from "sqlite"
-
-import Base from "./base.js"
-
-export default class VelociousDatabaseDriversSqliteNode extends Base {
-  /** @type {import("sqlite3").Database | undefined} */
-  connection = undefined
-
-  async connect() {
-    const args = this.getArgs()
-    const databasePath = `${this.getConfiguration().getDirectory()}/db/${this.localStorageName()}.sqlite`
-
-    if (args.reset) {
-      await fs.unlink(databasePath)
-    }
-
-    // @ts-expect-error
-    this.connection = /** @type {import("sqlite3").Database} */ (await open({
-      filename: databasePath,
-      driver: sqlite3.Database
-    }))
-    await this.registerVersion()
-  }
-
-  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()
-    this.connection = undefined
-  }
-
-  /**
-   * @param {string} sql
-   * @returns {Promise<Record<string, any>[]>}
-   */
-  async _queryActual(sql) {
-    if (!this.connection) throw new Error("No connection")
-
-    return await query(this.connection, sql)
-  }
-}