mythix-orm-postgresql 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Wyatt Greenway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# mythix-orm-postgresql
+
+PostgreSQL driver for Mythix ORM
+
+Mythix ORM aims to replace Sequelize and the few other terrible solutions that the poor destitute Node community has to work with. Mythix ORM is not yet quite ready for prime time however, so please check back soon!

package/lib/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const PostgreSQLConnection      = require('./postgresql-connection');
+const PostgreSQLQueryGenerator  = require('./postgresql-query-generator');
+
+module.exports = {
+  PostgreSQLConnection,
+  PostgreSQLQueryGenerator,
+};

package/lib/postgresql-connection.js

@@ -0,0 +1,336 @@
+/* eslint-disable no-magic-numbers */
+/* eslint-disable camelcase */
+
+'use strict';
+
+const Nife                      = require('nife');
+const moment                    = require('mythix-orm/node_modules/moment');
+const PG                        = require('pg');
+const PGFormat                  = require('pg-format');
+const { Literals }              = require('mythix-orm');
+const { SQLConnectionBase }     = require('mythix-orm-sql-base');
+const PostgreSQLQueryGenerator  = require('./postgresql-query-generator');
+
+class PostgreSQLConnection extends SQLConnectionBase {
+  static dialect = 'postgresql';
+
+  constructor(_options) {
+    super(_options);
+
+    this.setQueryGenerator(new PostgreSQLQueryGenerator(this));
+
+    Object.defineProperties(this, {
+      'pool': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+    });
+  }
+
+  isStarted() {
+    return !!this.pool;
+  }
+
+  async start() {
+    let options = this.getOptions();
+
+    if (options.foreignConstraints != null && options.logger)
+      options.logger.warn('"foreignConstraints" option is not supported by the PostgreSQL driver.');
+
+    let opts = Object.assign(
+      {
+        allowExitOnIdle: true,
+      },
+      options,
+      {
+        statement_timeout:                    options.statementTimeout,
+        query_timeout:                        options.queryTimeout,
+        connectionTimeoutMillis:              options.connectionTimeout,
+        idle_in_transaction_session_timeout:  options.idleTransactionTimeout,
+        idleTimeoutMillis:                    options.idleConnectionTimeout,
+        max:                                  options.maxPoolConnections,
+      },
+    );
+
+    const PGScope = (opts.native === true && PG.native) ? PG.native : PG;
+
+    let pool = this.pool = new PGScope.Pool(opts);
+
+    pool.on('connect', (client) => {
+      this.emit('connect', client);
+    });
+
+    pool.on('acquire', (client) => {
+      this.emit('acquire', client);
+    });
+
+    pool.on('error', (error, client) => {
+      this.emit('error', error, client);
+    });
+
+    pool.on('remove', (client) => {
+      this.emit('disconnect', client);
+    });
+  }
+
+  async stop() {
+    if (!this.pool)
+      return;
+
+    await this.pool.end();
+    this.pool = null;
+
+    await super.stop();
+  }
+
+  _escape(value) {
+    return PGFormat.literal(value);
+  }
+
+  _escapeID(value) {
+    return PGFormat.ident(value);
+  }
+
+  getDefaultFieldValue(type) {
+    switch (type) {
+      case 'AUTO_INCREMENT':
+        // This will get discarded by createTable...
+        // but we need the value later to select the
+        // proper column data type
+        return new Literals.Literal('@@@AUTOINCREMENT@@@', { noDefaultStatementOnCreateTable: true, remote: true });
+      case 'DATETIME_NOW':
+        return new Literals.Literal('(NOW() AT TIME ZONE(\'UTC\'))', { escape: false, remote: true });
+      case 'DATE_NOW':
+        return new Literals.Literal('(NOW() AT TIME ZONE(\'UTC\'))', { escape: false, remote: true });
+      case 'DATETIME_NOW_LOCAL':
+        return moment().toDate();
+      case 'DATE_NOW_LOCAL':
+        return moment().startOf('day').toDate();
+      default:
+        return type;
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async enableForeignKeyConstraints(enable) {
+    // Not supported in PostgreSQL
+    return;
+  }
+
+  async exec(...args) {
+    return await this.query(...args);
+  }
+
+  async query(_sql, _options) {
+    let sql = _sql;
+    if (!sql)
+      return;
+
+    if (Nife.instanceOf(sql, 'string'))
+      sql = { text: sql, rowMode: 'array' };
+    else if (Nife.instanceOf(sql, 'object'))
+      sql = Object.assign({ text: sql, rowMode: 'array' }, sql);
+
+    let options       = _options || {};
+    let logger        = options.logger || (this.getOptions().logger);
+    let inTransaction = false;
+    let client;
+
+    try {
+      client = options.connection || this.inTransaction;
+      if (!client)
+        client = await this.pool.connect();
+      else
+        inTransaction = true;
+
+      if (logger && sql.text)
+        console.log('QUERY: ', sql.text);
+
+      let result;
+
+      if (Nife.isNotEmpty(options.parameters))
+        result = await client.query(sql, options.parameters);
+      else
+        result = await client.query(sql);
+
+      return this.formatResultsResponse(sql, result);
+    } catch (error) {
+      if (logger) {
+        logger.error(error);
+        logger.error('QUERY: ', sql);
+      }
+
+      error.query = sql;
+
+      throw error;
+    } finally {
+      if (client && !inTransaction)
+        await client.release();
+    }
+  }
+
+  async transaction(callback, _options) {
+    let options       = _options || {};
+    let inheritedThis = Object.create(options.connection || this);
+    let savePointName;
+    let client;
+
+    if (!inheritedThis.inTransaction) {
+      client = options.connection;
+      if (!client)
+        client = await this.pool.connect();
+
+      inheritedThis.inTransaction = client;
+
+      try {
+        await inheritedThis.query(`BEGIN${(options.mode) ? ` ${options.mode}` : ''}`);
+      } catch (error) {
+        if (!options.connection)
+          await client.release();
+
+        throw error;
+      }
+    } else {
+      savePointName = this.generateSavePointName();
+      inheritedThis.savePointName = savePointName;
+      inheritedThis.isSavePoint = true;
+
+      await inheritedThis.query(`SAVEPOINT ${savePointName}`);
+    }
+
+    try {
+      let result = await callback.call(inheritedThis, inheritedThis);
+
+      if (savePointName)
+        await inheritedThis.query(`RELEASE SAVEPOINT ${savePointName}`);
+      else
+        await inheritedThis.query('COMMIT');
+
+      return result;
+    } catch (error) {
+      if (savePointName)
+        await inheritedThis.query(`ROLLBACK TO SAVEPOINT ${savePointName}`);
+      else if (inheritedThis.inTransaction)
+        await inheritedThis.query('ROLLBACK');
+
+      throw error;
+    } finally {
+      if (!savePointName && client)
+        await client.release();
+    }
+  }
+
+  formatResultsResponse(sqlStatement, result) {
+    if (!result.rows || !result.fields)
+      return result;
+
+    return {
+      rows:     result.rows,
+      columns:  result.fields.map((field) => field.name),
+    };
+  }
+
+  async truncate(Model, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStatement    = queryGenerator.generateTruncateTableStatement(Model, options);
+
+    return await this.query(sqlStatement);
+  }
+
+  _intTypeToSerial(type) {
+    let size = type.length;
+    if (size == null)
+      size = 4;
+
+    if (size <= 2)
+      return 'SMALLSERIAL';
+    else if (size <= 4)
+      return 'SERIAL';
+    else
+      return 'BIGSERIAL';
+  }
+
+  _bigintTypeToString(type, _options) {
+    let options = _options || {};
+
+    if (options.createTable && options.defaultValue === '@@@AUTOINCREMENT@@@')
+      return this._intTypeToSerial(type);
+
+    return 'BIGINT';
+  }
+
+  _integerTypeToString(type, _options) {
+    let options = _options || {};
+
+    if (options.createTable && options.defaultValue === '@@@AUTOINCREMENT@@@')
+      return this._intTypeToSerial(type);
+
+    return 'INTEGER';
+  }
+
+  _blobTypeToString(type) {
+    return 'BYTEA';
+  }
+
+  _datetimeTypeToString(type) {
+    return 'TIMESTAMP';
+  }
+
+  async average(_queryEngine, _field, options) {
+    let result = await super.average(_queryEngine, _field, options);
+
+    if (typeof result === 'string')
+      result = parseFloat(result);
+
+    return result;
+  }
+
+  async count(_queryEngine, _field, options) {
+    let result = await super.count(_queryEngine, _field, options);
+
+    if (typeof result === 'string')
+      result = parseInt(result, 10);
+
+    return result;
+  }
+
+  async min(_queryEngine, _field, options) {
+    let result = await super.min(_queryEngine, _field, options);
+
+    if (typeof result === 'string')
+      result = parseFloat(result);
+
+    return result;
+  }
+
+  async max(_queryEngine, _field, options) {
+    let result = await super.max(_queryEngine, _field, options);
+
+    if (typeof result === 'string')
+      result = parseFloat(result);
+
+    return result;
+  }
+
+  async sum(_queryEngine, _field, options) {
+    let result = await super.sum(_queryEngine, _field, options);
+
+    if (typeof result === 'string')
+      result = parseFloat(result);
+
+    return result;
+  }
+
+  convertDateToDBTime(value) {
+    if (value instanceof Date || (value && value.constructor && value.constructor.name === 'Date'))
+      return moment(value).utc(true).toDate();
+    else if (moment.isMoment(value))
+      return value.utc(true).toDate();
+
+    return value;
+  }
+}
+
+module.exports = PostgreSQLConnection;

package/lib/postgresql-query-generator.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const Nife                      = require('nife');
+const { Literals }              = require('mythix-orm');
+const { SQLQueryGeneratorBase } = require('mythix-orm-sql-base');
+
+const LiteralBase = Literals.LiteralBase;
+
+class PostgreSQLQueryGenerator extends SQLQueryGeneratorBase {
+  // eslint-disable-next-line no-unused-vars
+  generateSQLJoinTypeFromQueryEngineJoinType(joinType, outer, options) {
+    if (!joinType || joinType === 'inner')
+      return 'INNER JOIN';
+    else if (joinType === 'left')
+      return 'LEFT JOIN';
+    else if (joinType === 'cross')
+      return 'CROSS JOIN';
+
+    return joinType;
+  }
+
+  generateForeignKeyConstraint(field, type) {
+    let options     = type.getOptions();
+    let targetModel = type.getTargetModel();
+    let targetField = type.getTargetField();
+
+    let sqlParts  = [
+      'FOREIGN KEY(',
+      this.escapeID(field.columnName),
+      ') REFERENCES ',
+      this.escapeID(targetModel.getTableName(this.connection)),
+      '(',
+      this.escapeID(targetField.columnName),
+      ')',
+    ];
+
+    if (options.deferred === true) {
+      sqlParts.push(' ');
+      sqlParts.push('DEFERRABLE INITIALLY DEFERRED');
+    }
+
+    if (options.onDelete) {
+      sqlParts.push(' ');
+      sqlParts.push(`ON DELETE ${options.onDelete.toUpperCase()}`);
+    }
+
+    if (options.onUpdate) {
+      sqlParts.push(' ');
+      sqlParts.push(`ON UPDATE ${options.onUpdate.toUpperCase()}`);
+    }
+
+    return sqlParts.join('');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  generateCreateTableStatementInnerTail(Model, options) {
+    let fieldParts = [];
+
+    Model.iterateFields(({ field }) => {
+      if (field.type.isVirtual())
+        return;
+
+      if (field.type.isForeignKey()) {
+        let result = this.generateForeignKeyConstraint(field, field.type);
+        if (result)
+          fieldParts.push(result);
+
+        return;
+      }
+    });
+
+    return fieldParts;
+  }
+
+  generateInsertStatementTail(Model, model, options, context) {
+    return this._collectReturningFields(Model, model, options, context);
+  }
+
+  generateUpdateStatementTail(Model, model, options, context) {
+    return this._collectReturningFields(Model, model, options, context);
+  }
+
+  generateCreateTableStatement(Model, _options) {
+    let options = _options || {};
+    let fieldParts = [];
+
+    Model.iterateFields(({ field, fieldName }) => {
+      if (field.type.isVirtual())
+        return;
+
+      let columnName      = field.columnName || fieldName;
+      let constraintParts = [];
+
+      let defaultValue = this.getFieldDefaultValue(field, fieldName, { remoteOnly: true });
+
+      if (field.primaryKey) {
+        if (field.primaryKey instanceof LiteralBase)
+          constraintParts.push(field.primaryKey.toString(this.connection));
+        else
+          constraintParts.push('PRIMARY KEY');
+
+        if (defaultValue !== '@@@AUTOINCREMENT@@@')
+          constraintParts.push('NOT NULL');
+      } else {
+        if (field.unique) {
+          if (field.unique instanceof LiteralBase)
+            constraintParts.push(field.unique.toString(this.connection));
+          else
+            constraintParts.push('UNIQUE');
+        }
+
+        if (field.allowNull === false)
+          constraintParts.push('NOT NULL');
+      }
+
+      if (defaultValue !== undefined && defaultValue !== '@@@AUTOINCREMENT@@@')
+        constraintParts.push(defaultValue);
+
+      constraintParts = constraintParts.join(' ');
+      if (Nife.isNotEmpty(constraintParts))
+        constraintParts = ` ${constraintParts}`;
+
+      fieldParts.push(`  ${this.escapeID(columnName)} ${field.type.toConnectionType(this.connection, { createTable: true, defaultValue })}${constraintParts}`);
+    });
+
+    let ifNotExists = 'IF NOT EXISTS ';
+    if (options.ifNotExists === false)
+      ifNotExists = '';
+
+    let trailingParts = Nife.toArray(this.generateCreateTableStatementInnerTail(Model, options)).filter(Boolean);
+    if (Nife.isNotEmpty(trailingParts))
+      fieldParts = fieldParts.concat(trailingParts.map((part) => `  ${part.trim()}`));
+
+    let finalStatement = `CREATE TABLE ${ifNotExists}${this.escapeID(Model.getTableName(this.connection))} (${fieldParts.join(',\n')}\n);`;
+    return finalStatement;
+  }
+
+  generateTruncateTableStatement(Model, _options) {
+    let options           = _options || {};
+    let escapedTableName  = this.escapeID(Model.getTableName(this.connection));
+
+    return `TRUNCATE TABLE${(options.onlySpecifiedTable === true) ? ' ONLY' : ''} ${escapedTableName}${(options.continueIdentity === true) ? ' CONTINUE IDENTITY' : ' RESTART IDENTITY'}${(options.cascade === false) ? ' RESTRICT' : ' CASCADE'}`;
+  }
+}
+
+module.exports = PostgreSQLQueryGenerator;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "mythix-orm-postgresql",
+  "version": "1.0.1",
+  "description": "PostgreSQL driver for Mythix ORM",
+  "main": "lib/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "coverage": "clear ; node ./node_modules/.bin/nyc ./node_modules/.bin/jasmine",
+    "test": "node ./node_modules/.bin/jasmine",
+    "test-debug": "node --inspect-brk ./node_modules/.bin/jasmine",
+    "test-watch": "watch 'clear ; node ./node_modules/.bin/jasmine' . --wait=2 --interval=1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/th317erd/mythix-orm-postgresql.git"
+  },
+  "keywords": [
+    "orm",
+    "mysql",
+    "postgres",
+    "postgresql",
+    "mssql",
+    "mongo",
+    "snowflake",
+    "database",
+    "sql",
+    "no-sql"
+  ],
+  "author": "Wyatt Greenway",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/th317erd/mythix-orm-postgresql/issues"
+  },
+  "homepage": "https://github.com/th317erd/mythix-orm-postgresql#readme",
+  "dependencies": {
+    "nife": "^1.11.2",
+    "pg": "^8.7.3",
+    "pg-format": "^1.0.4",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
+    "eslint": "^8.13.0",
+    "jasmine": "^4.3.0",
+    "moment": "^2.29.4",
+    "nyc": "^15.1.0"
+  },
+  "nyc": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "spec/**",
+      "lib/proxy-class/proxy-class.js"
+    ]
+  }
+}