velocious 1.0.430 → 1.0.432

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

@@ -0,0 +1,441 @@
+// @ts-check
+
+import AlterTable from "./sql/alter-table.js"
+import wait from "awaitery/build/wait.js"
+import Base from "../base.js"
+import {Client} from "pg"
+import CreateDatabase from "./sql/create-database.js"
+import CreateIndex from "./sql/create-index.js"
+import CreateTable from "./sql/create-table.js"
+import Delete from "./sql/delete.js"
+import {digg} from "diggerize"
+import DropDatabase from "./sql/drop-database.js"
+import DropTable from "./sql/drop-table.js"
+import Insert from "./sql/insert.js"
+import Options from "./options.js"
+import QueryParser from "./query-parser.js"
+import Table from "./table.js"
+import StructureSql from "./structure-sql.js"
+import Upsert from "./sql/upsert.js"
+import Update from "./sql/update.js"
+
+export default class VelociousDatabaseDriversPgsql extends Base{
+  async connect() {
+    const client = new Client(this.connectArgs())
+
+    try {
+      await client.connect()
+    } catch (error) {
+      // Re-throw to recover real stack trace
+      if (error instanceof Error) {
+        throw new Error(`Connect to Postgres server failed: ${error.message}`, {cause: error})
+      } else {
+        throw new Error(`Connect to Postgres server failed: ${error}`, {cause: error})
+      }
+    }
+
+    this.connection = client
+  }
+
+  connectArgs() {
+    const args = this.getArgs()
+    const forward = ["database", "host", "password", "port"]
+
+    /**
+     * Connect args.
+      @type {Record<string, ?>} */
+    const connectArgs = {}
+
+    for (const forwardValue of forward) {
+      if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)
+    }
+
+    if ("username" in args) connectArgs["user"] = args["username"]
+
+    return connectArgs
+  }
+
+  async close() {
+    await this.connection?.end()
+    this.connection = undefined
+    this._transactionsCount = 0
+  }
+
+  /**
+   * Runs set connection checkout name.
+   * @param {string | undefined} name - Human-readable name for this active checkout.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async setConnectionCheckoutName(name) {
+    if (name) {
+      await this.query(`SET application_name = ${this.quote(name)}`, {logName: "Set Connection Checkout Name", processListComment: false})
+    } else {
+      await this.query("RESET application_name", {logName: "Clear Connection Checkout Name", processListComment: false})
+    }
+
+    await super.setConnectionCheckoutName(name)
+  }
+
+  /**
+   * Runs clear connection checkout name.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async clearConnectionCheckoutName() {
+    await this.query("RESET application_name", {logName: "Clear Connection Checkout Name", processListComment: false})
+    await super.clearConnectionCheckoutName()
+  }
+
+  /**
+   * Runs alter table sqls.
+   * @param {import("../../table-data/index.js").default} tableData - Table data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async alterTableSQLs(tableData) {
+    const alterArgs = {tableData, driver: this}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSQLs()
+  }
+
+  /**
+   * Runs create database sql.
+   * @param {string} databaseName - Database name.
+   * @param {object} [args] - Options object.
+   * @param {boolean} [args.ifNotExists] - Whether if not exists.
+   * @returns {string[]} - SQL statements.
+   */
+  createDatabaseSql(databaseName, args) {
+    const createArgs = Object.assign({databaseName, driver: this}, args)
+    const createDatabase = new CreateDatabase(createArgs)
+
+    return createDatabase.toSql()
+  }
+
+  /**
+   * Runs drop database sql.
+   * @param {string} databaseName - Database name.
+   * @param {object} [args] - Options object.
+   * @param {boolean} [args.ifExists] - Whether if exists.
+   * @returns {string[]} - SQL statements.
+   */
+  dropDatabaseSql(databaseName, args) {
+    const dropArgs = Object.assign({databaseName, driver: this}, args)
+    const dropDatabase = new DropDatabase(dropArgs)
+
+    return dropDatabase.toSql()
+  }
+
+  /**
+   * Runs create index sqls.
+   * @param {import("../base.js").CreateIndexSqlArgs} indexData - Index data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async createIndexSQLs(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return await createIndex.toSQLs()
+  }
+
+  /**
+   * Runs create table sql.
+   * @param {import("../../table-data/index.js").default} tableData - Table data.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async createTableSql(tableData) {
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
+    const createTable = new CreateTable(createArgs)
+
+    return await createTable.toSql()
+  }
+
+  async currentDatabase() {
+    const rows = await this.query("SELECT CURRENT_DATABASE() AS db_name")
+
+    return digg(rows, 0, "db_name")
+  }
+
+  async disableForeignKeys() {
+    await this.query("SET session_replication_role = 'replica'")
+  }
+
+  async enableForeignKeys() {
+    await this.query("SET session_replication_role = 'origin'")
+  }
+
+  /**
+   * Runs drop table sqls.
+   * @param {string} tableName - Table name.
+   * @param {import("../base.js").DropTableSqlArgsType} [args] - Options object.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async dropTableSQLs(tableName, args = {}) {
+    const dropArgs = Object.assign({tableName, driver: this}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return await dropTable.toSQLs()
+  }
+
+  getType() { return "pgsql" }
+  primaryKeyType() { return "bigint" }
+
+  /**
+   * Runs query actual.
+   * @param {string} sql - SQL string.
+   * @returns {Promise<import("../base.js").QueryResultType>} - Resolves with the query actual.
+   */
+  async _queryActual(sql) {
+    let response
+
+    if (!this.connection) await this.connect()
+    if (!this.connection) throw new Error("PostgreSQL connection failed to initialize")
+
+    try {
+      response = await this.connection.query(sql)
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Query failed: ${error.message} with SQL: ${sql}`, {cause: error})
+      } else {
+        throw new Error(`Query failed: ${error} with SQL: ${sql}`, {cause: error})
+      }
+    }
+
+    return response.rows
+  }
+
+  /**
+   * Runs query to sql.
+   * @param {import("../../query/index.js").default} query - Query instance.
+   * @returns {string} - SQL string.
+   */
+  queryToSql(query) { return new QueryParser({query}).toSql() }
+  shouldSetAutoIncrementWhenPrimaryKey() { return true }
+  supportsDefaultPrimaryKeyUUID() { return true }
+
+  /**
+   * Runs convert value.
+   * @param {?} value - Value to use.
+   * @returns {?} - The converted value.
+   */
+  _convertValue(value) {
+    if (typeof value === "boolean") {
+      return value ? "true" : "false"
+    }
+
+    return super._convertValue(value)
+  }
+
+  /**
+   * Runs escape.
+   * @param {?} value - Value to use.
+   * @returns {?} - The escape.
+   */
+  escape(value) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+    if (typeof value === "number") return value
+
+    const escapedValueWithQuotes = this.connection.escapeLiteral(this._convertValue(value))
+
+    return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)
+  }
+
+  /**
+   * Runs quote.
+   * @param {?} value - Value to use.
+   * @returns {string | number} - The quoted value.
+   */
+  quote(value) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+    if (typeof value === "number") return value
+
+    return this.connection.escapeLiteral(this._convertValue(value))
+  }
+
+  /**
+   * Runs delete sql.
+   * @param {import("../base.js").DeleteSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  deleteSql({tableName, conditions}) {
+    const deleteInstruction = new Delete({conditions, driver: this, tableName})
+
+    return deleteInstruction.toSql()
+  }
+
+  /**
+   * Runs insert sql.
+   * @abstract
+   * @param {import("../base.js").InsertSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  insertSql(args) {
+    const insertArgs = Object.assign({driver: this}, args)
+    const insert = new Insert(insertArgs)
+
+    return insert.toSql()
+  }
+
+  async getTables() {
+    return await this._cachedSchemaMetadata("tables", async () => {
+      const result = await this.query("SELECT * FROM information_schema.tables WHERE table_catalog = CURRENT_DATABASE() AND table_schema = 'public'")
+      const tables = []
+
+      for (const row of result) {
+        const table = new Table(this, /**
+                                       * Narrows the runtime value to the documented type.
+                                        @type {Record<string, string>} */ (row))
+
+        tables.push(table)
+      }
+
+      return tables
+    })
+  }
+
+  async lastInsertID() {
+    const result = await this.query("SELECT LASTVAL() AS last_insert_id")
+
+    return digg(result, 0, "last_insert_id")
+  }
+
+  options() {
+    if (!this._options) this._options = new Options(this)
+
+    return this._options
+  }
+
+  async _startTransactionAction() {
+    await this.query("START TRANSACTION")
+  }
+
+  /**
+   * Runs update sql.
+   * @abstract
+   * @param {import("../base.js").UpdateSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  updateSql({conditions, data, tableName}) {
+    const update = new Update({conditions, data, driver: this, tableName})
+
+    return update.toSql()
+  }
+
+  /**
+   * Runs upsert sql.
+   * @param {import("../base.js").UpsertSqlArgsType} args - Options object.
+   * @returns {string} - SQL string.
+   */
+  upsertSql(args) {
+    const upsert = new Upsert({...args, driver: this})
+
+    return upsert.toSql()
+  }
+
+  /**
+   * Runs structure sql.
+   * @returns {Promise<string | null>} - Resolves with SQL string.
+   */
+  async structureSql() {
+    return await this._cachedSchemaMetadata("structureSql", async () => await new StructureSql({driver: this}).toSql())
+  }
+
+  /**
+   * Deterministically hashes a lock name into a signed 64-bit integer so it
+   * can be passed to `pg_advisory_lock(bigint)`. We use a fast 64-bit FNV-1a
+   * hash — the exact value does not matter, only that the same name always
+   * produces the same key within a process AND across processes that share
+   * the same implementation. Returns the value as a string so the caller
+   * can interpolate it into SQL without losing precision to JS number
+   * coercion.
+   * @param {string} name - Lock name.
+   * @returns {string} - Signed 64-bit integer as a decimal string.
+   */
+  advisoryLockKey(name) {
+    // FNV-1a 64-bit, computed with BigInt so we don't lose precision.
+    const fnvOffsetBasis = 0xcbf29ce484222325n
+    const fnvPrime = 0x00000100000001b3n
+    const mask64 = 0xffffffffffffffffn
+    let hash = fnvOffsetBasis
+
+    for (let index = 0; index < name.length; index += 1) {
+      hash = BigInt.asUintN(64, (hash ^ BigInt(name.charCodeAt(index))) * fnvPrime & mask64)
+    }
+
+    // Convert unsigned 64-bit into signed by reinterpreting the top bit.
+    const signed = hash >= 0x8000000000000000n ? hash - 0x10000000000000000n : hash
+
+    return signed.toString()
+  }
+
+  /**
+   * Blocks until a PostgreSQL session-level advisory lock is acquired on
+   * this connection. Implemented via `pg_advisory_lock(bigint)`, which has
+   * no native timeout — the `timeoutMs` argument is emulated by racing a
+   * `pg_try_advisory_lock` poll loop so callers on MySQL and Postgres see
+   * the same contract.
+   * @param {string} name - Lock name.
+   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.
+   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.
+   */
+  async acquireAdvisoryLock(name, {timeoutMs} = {}) {
+    const key = this.advisoryLockKey(name)
+
+    if (typeof timeoutMs !== "number" || timeoutMs < 0) {
+      await this.query(`SELECT pg_advisory_lock(${key})`)
+      return true
+    }
+
+    const deadline = Date.now() + timeoutMs
+    const pollIntervalMs = 50
+
+    while (true) {
+      if (await this.tryAcquireAdvisoryLock(name)) return true
+      if (Date.now() >= deadline) return false
+
+      const remaining = deadline - Date.now()
+
+      await wait(Math.min(pollIntervalMs, remaining))
+    }
+  }
+
+  /**
+   * Runs try acquire advisory lock.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.
+   */
+  async tryAcquireAdvisoryLock(name) {
+    const key = this.advisoryLockKey(name)
+    const rows = await this.query(`SELECT pg_try_advisory_lock(${key}) AS velocious_advisory_lock_result`)
+    const result = rows?.[0]?.velocious_advisory_lock_result
+
+    return result === true || result === "t" || result === 1 || result === "1"
+  }
+
+  /**
+   * Runs release advisory lock.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if the lock was held by this session and has now been released.
+   */
+  async releaseAdvisoryLock(name) {
+    const key = this.advisoryLockKey(name)
+    const rows = await this.query(`SELECT pg_advisory_unlock(${key}) AS velocious_advisory_lock_result`)
+    const result = rows?.[0]?.velocious_advisory_lock_result
+
+    return result === true || result === "t" || result === 1 || result === "1"
+  }
+
+  /**
+   * Runs is advisory lock held.
+   * @param {string} name - Lock name.
+   * @returns {Promise<boolean>} - True if any session currently holds the lock.
+   */
+  async isAdvisoryLockHeld(name) {
+    const key = this.advisoryLockKey(name)
+    const rows = await this.query(
+      `SELECT EXISTS (SELECT 1 FROM pg_locks WHERE locktype = 'advisory' AND ((classid::bigint << 32) | (objid::bigint & 4294967295)) = ${key}) AS velocious_advisory_lock_held`
+    )
+    const held = rows?.[0]?.velocious_advisory_lock_held
+
+    return held === true || held === "t" || held === 1 || held === "1"
+  }
+}

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

@@ -0,0 +1,32 @@
+// @ts-check
+
+import QueryParserOptions from "../../query-parser/options.js"
+
+export default class VelociousDatabaseDriversPgsqlOptions extends QueryParserOptions {
+  /**
+   * Runs constructor.
+   * @param {import("../base.js").default} driver - Database driver instance.
+   */
+  constructor(driver) {
+    const options = {
+      driver,
+      columnQuote: "\"",
+      indexQuote: "\"",
+      stringQuote: "'",
+      tableQuote: "\""
+    }
+
+    super(options)
+  }
+
+  /**
+   * Runs quote.
+   * @param {string} string - String.
+   * @returns {number | string} - The quote.
+   */
+  quote(string) {
+    if (!this.driver) throw new Error("Driver not set")
+
+    return this.driver.quote(string)
+  }
+}

package/src/database/drivers/pgsql/query-parser.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import BaseQueryParser from "../../query-parser/base-query-parser.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlQueryParser extends BaseQueryParser {
+}

package/src/database/drivers/pgsql/sql/alter-table.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import AlterTableBase from "../../../query/alter-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlAlterTable extends AlterTableBase {
+}

package/src/database/drivers/pgsql/sql/create-database.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+import CreateDatabaseBase from "../../../query/create-database-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlCreateDatabase extends CreateDatabaseBase {
+  toSql() {
+    const {databaseName} = this
+    const options = this.getOptions()
+    const sqls = []
+
+    if (this.ifNotExists) {
+      sqls.push("CREATE EXTENSION IF NOT EXISTS dblink")
+
+      const connectArgs = this._driver.getArgs()
+      const {password, username} = connectArgs
+      const port = connectArgs.port || 5432
+      const sql = `
+        DO
+        $do$
+        BEGIN
+          IF EXISTS (SELECT FROM ${options.quoteTableName("pg_database")} WHERE ${options.quoteColumnName("datname")} = ${options.quote(databaseName)}) THEN
+            RAISE NOTICE 'Database already exists';  -- optional
+          ELSE
+            PERFORM dblink_connect('host=localhost port=' || ${port} || ' user=' || ${options.quote(username)} || ' password=' || ${options.quote(password)} || ' dbname=' || current_database());
+            PERFORM dblink_exec('CREATE DATABASE ' || ${options.quote(databaseName)});
+          END IF;
+        END
+        $do$;
+      `
+
+      sqls.push(sql)
+    } else {
+      sqls.push(`CREATE DATABASE ${options.quoteDatabaseName(databaseName)}`)
+    }
+
+    return sqls
+  }
+}

package/src/database/drivers/pgsql/sql/create-index.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import CreateIndexBase from "../../../query/create-index-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlCreateIndex extends CreateIndexBase {
+}

package/src/database/drivers/pgsql/sql/create-table.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import CreateTableBase from "../../../query/create-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlCreateTable extends CreateTableBase {
+}

package/src/database/drivers/pgsql/sql/delete.js

@@ -0,0 +1,21 @@
+// @ts-check
+
+import DeleteBase from "../../../query/delete-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlDelete extends DeleteBase {
+  toSql() {
+    let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)} WHERE `
+    let count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.getOptions().quote(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/src/database/drivers/pgsql/sql/drop-database.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import DropDatabaseBase from "../../../query/drop-database-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlDropDatabase extends DropDatabaseBase {
+}

package/src/database/drivers/pgsql/sql/drop-table.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlDropTable extends DropTableBase {
+}

package/src/database/drivers/pgsql/sql/insert.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import InsertBase from "../../../query/insert-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlInsert extends InsertBase {
+}

package/src/database/drivers/pgsql/sql/update.js

@@ -0,0 +1,33 @@
+// @ts-check
+
+import UpdateBase from "../../../query/update-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlUpdate extends UpdateBase {
+  toSql() {
+    let sql = `UPDATE ${this.getOptions().quoteTableName(this.tableName)} SET `
+    let count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.data[columnName])
+      count++
+    }
+
+    sql += " WHERE "
+    count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/src/database/drivers/pgsql/sql/upsert.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+import UpsertBase from "../../../query/upsert-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlUpsert extends UpsertBase {
+  toSql() {
+    const conflictSql = this.conflictColumns.map((columnName) => this.quotedColumn(columnName)).join(", ")
+    const updateSql = this.updateColumns.map((columnName) => {
+      return `${this.quotedColumn(columnName)} = excluded.${this.quotedColumn(columnName)}`
+    }).join(", ")
+
+    return `INSERT INTO ${this.quotedTableName()} (${this.quotedInsertColumnsSql()}) VALUES (${this.quotedInsertValuesSql()}) ON CONFLICT (${conflictSql}) DO UPDATE SET ${updateSql}`
+  }
+}