velocious 1.0.35 → 1.0.37

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

@@ -0,0 +1,172 @@
+import Base from "../base.js"
+import {Client, escapeLiteral} 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 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 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
+      throw new Error(`Connect to Postgres server failed: ${error.message}`)
+    }
+
+    this.connection = client
+  }
+
+  disconnect() {
+    this.connection.end()
+  }
+
+  connectArgs() {
+    const args = this.getArgs()
+    const connectArgs = []
+    const forward = ["database", "host", "password", "port"]
+
+    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
+  }
+
+  createDatabaseSql(databaseName, args) {
+    const createArgs = Object.assign({databaseName, driver: this}, args)
+    const createDatabase = new CreateDatabase(createArgs)
+
+    return createDatabase.toSql()
+  }
+
+  createIndexSql(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return createIndex.toSql()
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  async disableForeignKeys() {
+    await this.query("SET FOREIGN_KEY_CHECKS = 0")
+  }
+
+  async enableForeignKeys() {
+    await this.query("SET FOREIGN_KEY_CHECKS = 1")
+  }
+
+  dropTableSql(tableName, args = {}) {
+    const dropArgs = Object.assign({tableName, driver: this}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return dropTable.toSql()
+  }
+
+  getType = () => "pgsql"
+  primaryKeyType = () => "bigint"
+
+  async query(sql) {
+    let response
+
+    try {
+      response = await this.connection.query(sql)
+    } catch (error) {
+      throw new Error(`Query failed: ${error.message} with SQL: ${sql}`)
+    }
+
+    return response.rows
+  }
+
+  queryToSql(query) {
+    return new QueryParser({query}).toSql()
+  }
+
+  shouldSetAutoIncrementWhenPrimaryKey = () => true
+
+  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)
+  }
+
+  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))
+  }
+
+  deleteSql({tableName, conditions}) {
+    const deleteInstruction = new Delete({conditions, driver: this, tableName})
+
+    return deleteInstruction.toSql()
+  }
+
+  insertSql(args) {
+    const insertArgs = Object.assign({driver: this}, args)
+    const insert = new Insert(insertArgs)
+
+    return insert.toSql()
+  }
+
+  async getTables() {
+    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, 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({driver: this})
+
+    return this._options
+  }
+
+  async startTransaction() {
+    return await this.query("START TRANSACTION")
+  }
+
+  updateSql({conditions, data, tableName}) {
+    const update = new Update({conditions, data, driver: this, tableName})
+
+    return update.toSql()
+  }
+}

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

@@ -0,0 +1,18 @@
+import QueryParserOptions from "../../query-parser/options.js"
+
+export default class VelociousDatabaseDriversPgsqlOptions extends QueryParserOptions {
+  constructor(options) {
+    options.columnQuote = "\""
+    options.indexQuote = "\""
+    options.stringQuote = "'"
+    options.tableQuote = "\""
+
+    super(options)
+  }
+
+  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,4 @@
+import BaseQueryParser from "../../query-parser/base-query-parser.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlQueryParser extends BaseQueryParser {
+}

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

@@ -0,0 +1,37 @@
+import CreateDatabaseBase from "../../../query/create-database-base.js"
+import {digs} from "diggerize"
+
+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.connectArgs()
+      const {password, user} = digs(connectArgs, "password", "user")
+      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(user)} || ' 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,4 @@
+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,4 @@
+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,19 @@
+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-table.js

@@ -0,0 +1,4 @@
+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,4 @@
+import InsertBase from "../../../query/insert-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlInsert extends InsertBase {
+}

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

@@ -0,0 +1,31 @@
+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.getOptions().quote(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.getOptions().quote(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

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

@@ -0,0 +1,62 @@
+import Column from "./column.js"
+import ForeignKey from "./foreign-key.js"
+
+export default class VelociousDatabaseDriversPgsqlTable {
+  constructor(driver, data) {
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    const result = await this.driver.query(`SELECT * FROM information_schema.columns WHERE table_catalog = CURRENT_DATABASE() AND table_schema = 'public' AND 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.driver.quote(this.getName())}
+    `
+
+    const foreignKeyRows = await this.driver.query(sql)
+    const foreignKeys = []
+
+    for (const foreignKeyRow of foreignKeyRows) {
+      const foreignKey = new ForeignKey(foreignKeyRow)
+
+      foreignKeys.push(foreignKey)
+    }
+
+    return foreignKeys
+  }
+
+  getName() {
+    return this.data.table_name
+  }
+}

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

@@ -164,6 +164,8 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   shouldSetAutoIncrementWhenPrimaryKey = () => false
 
   escape(value) {
+    value = this._convertValue(value)
+
     const type = typeof value
 
     if (type != "string") value = `${value}`
@@ -175,6 +177,8 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   quote(value) {
+    value = this._convertValue(value)
+
     const type = typeof value
 
     if (type == "number") return value

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

@@ -11,4 +11,14 @@ export default class VelociousDatabaseDriversSqliteColumn {
 
     return this.column.name
   }
+
+  getType() {
+    const match = this.column.type.match(/(.*)\((\d+)\)$/)
+
+    if (match) {
+      return match[1].toLowerCase()
+    }
+
+    return this.column.type.toLowerCase()
+  }
 }

package/src/database/migrator.js

@@ -214,7 +214,7 @@ export default class VelociousDatabaseMigrator {
       const dateString = digg(migration, "date")
       const existingSchemaMigrations = await db.newQuery()
         .from("schema_migrations")
-        .where({version: dateString})
+        .where({version: `${dateString}`})
         .results()
 
       if (existingSchemaMigrations.length == 0) {

package/src/database/query/create-database-base.js

@@ -15,6 +15,6 @@ export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase
 
     sql += ` ${this.getOptions().quoteDatabaseName(databaseName)}`
 
-    return sql
+    return [sql]
   }
 }

package/src/database/query/create-table-base.js

@@ -37,6 +37,10 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
       let maxlength = column.getMaxLength()
       let type = column.getType().toUpperCase()
 
+      if (type == "DATETIME" && databaseType == "pgsql") {
+        type = "TIMESTAMP"
+      }
+
       if (type == "STRING") {
         type = "VARCHAR"
         maxlength ||= 255
@@ -50,6 +54,10 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         type = "INTEGER"
       }
 
+      if (databaseType == "pgsql" && column.getAutoIncrement() && column.getPrimaryKey()) {
+        type = "SERIAL"
+      }
+
       if (columnCount > 1) sql += ", "
 
       sql += `${options.quoteColumnName(column.getName())} ${type}`
@@ -59,6 +67,12 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
       if (column.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
         if (databaseType == "mssql") {
           sql += " IDENTITY"
+        } else if (databaseType == "pgsql") {
+          if (column.getAutoIncrement() && column.getPrimaryKey()) {
+            // Do nothing
+          } else {
+            throw new Error("pgsql auto increment must be primary key")
+          }
         } else {
           sql += " AUTO_INCREMENT"
         }
@@ -83,7 +97,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           throw new Error(`Unknown foreign key type given: ${column.getForeignKey()} (${typeof column.getForeignKey()})`)
         }
 
-        sql += ` REFERENCES ${driver.quoteTable(foreignKeyTable)}(${driver.quoteColumn(foreignKeyColumn)})`
+        sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
       }
     }
 
@@ -98,7 +112,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         sql += " INDEX"
 
         if (index.getName()) {
-          sql += ` ${index.getName()}`
+          sql += ` ${options.quoteIndexName(index.getName())}`
         }
 
         sql += " ("

package/src/database/query/index.js

@@ -48,10 +48,19 @@ export default class VelociousDatabaseQuery {
   }
 
   async count() {
+    // Generate count SQL
+    let sql = "COUNT(id)"
+
+    if (this.driver.getType() == "pgsql") sql += "::int"
+
+    sql += " AS count"
+
+
+    // Clone query and execute count
     const countQuery = this.clone()
 
     countQuery._selects = []
-    countQuery.select("COUNT(id) AS count")
+    countQuery.select(sql)
 
     const results = await countQuery._executeQuery()
 

package/src/database/query/insert-base.js

@@ -34,7 +34,7 @@ export default class VelociousDatabaseQueryInsertBase {
         if (Object.keys(this.data).length <= 0) {
           sql += lastInsertedSQL
         }
-      } else if (driver.getType() == "mysql") {
+      } else if (driver.getType() == "mysql" || driver.getType() == "pgsql") {
         lastInsertedSQL = ` RETURNING ${driver.quoteColumn(this.returnLastInsertedColumnName)} AS lastInsertID`
       }
     }