leoric 2.3.2 → 2.5.0

package/src/drivers/index.js

@@ -1,18 +1,29 @@
 'use strict';
 
+const MysqlDriver = require('./mysql');
+const PostgresDriver = require('./postgres');
+const SqliteDriver = require('./sqlite');
+const AbstractDriver = require('./abstract');
+
 function findDriver(dialect) {
   switch (dialect) {
     case 'mysql':
-      return require('./mysql');
+      return MysqlDriver;
     case 'pg':
     case 'postgres':
-      return require('./postgres');
+      return PostgresDriver;
     case 'sqlite':
     case 'sqlite3':
-      return require('./sqlite');
+      return SqliteDriver;
     default:
       throw new Error(`Unsupported database ${dialect}`);
   }
 }
 
-module.exports = { findDriver };
+module.exports = {
+  findDriver,
+  MysqlDriver,
+  PostgresDriver,
+  SqliteDriver,
+  AbstractDriver,
+};

package/src/drivers/mysql/index.js

@@ -5,11 +5,17 @@ const { performance } = require('perf_hooks');
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
 const DataTypes = require('./data_types');
-const spellbook = require('./spellbook');
-const schema = require('./schema');
+const Spellbook = require('./spellbook');
 const { calculateDuration } = require('../../utils');
+const { heresql } = require('../../utils/string');
 
 class MysqlDriver extends AbstractDriver {
+
+  // define static properties as this way IDE will prompt
+  static Spellbook = Spellbook;
+  static Attribute = Attribute;
+  static DataTypes = DataTypes;
+
   /**
    * Create a connection pool
    * @param {string} clientName
@@ -29,11 +35,12 @@ class MysqlDriver extends AbstractDriver {
     super(opts);
     this.type = 'mysql';
     this.pool = this.createPool(opts);
-    this.escape = this.pool.escape.bind(this.pool);
-  }
+    this.Attribute = this.constructor.Attribute;
+    this.DataTypes = this.constructor.DataTypes;
+    this.spellbook = new this.constructor.Spellbook();
 
-  get escapeId() {
-    return this.pool.escapeId;
+    this.escape = this.pool.escape.bind(this.pool);
+    this.escapeId = this.pool.escapeId;
   }
 
   createPool(opts) {
@@ -105,11 +112,95 @@ class MysqlDriver extends AbstractDriver {
     return results;
   }
 
-  format(spell) {
-    return spellbook.format(spell);
+
+  /**
+ * Fetch columns of give tables from database
+ * - https://dev.mysql.com/doc/mysql-infoschema-excerpt/5.6/en/columns-table.html
+ * @param {string} database
+ * @param {string|string[]} tables
+ */
+  async querySchemaInfo(database, tables) {
+    tables = [].concat(tables);
+    const sql = heresql(`
+      SELECT table_name, column_name, column_type, data_type, is_nullable,
+            column_default, column_key, column_comment,
+            datetime_precision
+        FROM information_schema.columns
+      WHERE table_schema = ? AND table_name in (?)
+      ORDER BY table_name, column_name
+    `);
+
+    const { rows } = await this.query(sql, [ database, tables ]);
+    const schemaInfo = {};
+
+    for (const entry of rows) {
+      // make sure the column names are in lower case
+      const row = Object.keys(entry).reduce((obj, name) => {
+        obj[name.toLowerCase()] = entry[name];
+        return obj;
+      }, {});
+      const tabelName = row.table_name;
+      const columns = schemaInfo[tabelName] || (schemaInfo[tabelName] = []);
+      columns.push({
+        columnName: row.column_name,
+        columnType: row.column_type,
+        comment: row.column_comment,
+        defaultValue: row.column_default,
+        dataType: row.data_type,
+        allowNull: row.is_nullable === 'YES',
+        primaryKey: row.column_key == 'PRI',
+        unique: row.column_key == 'PRI' || row.column_key == 'UNI',
+        datetimePrecision: row.datetime_precision,
+      });
+    }
+
+    return schemaInfo;
+  }
+
+  /**
+   * Rename column with SQL that works on older versions of MySQL
+   * - https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
+   * - https://dev.mysql.com/doc/refman/8.0/en/alter-table.html
+   * @param {string} table
+   * @param {string} column the old column name
+   * @param {string} newColumn the new column name
+   */
+  async renameColumn(table, name, newName) {
+    const { escapeId } = this;
+    const { database } = this.options;
+    const { columnName } = new this.Attribute(name);
+    const schemaInfo = await this.querySchemaInfo(database, table);
+    const { columnName: _, ...columnInfo } = schemaInfo[table].find(entry => {
+      return entry.columnName == columnName;
+    });
+
+    if (!columnInfo) {
+      throw new Error(`Unable to find column ${table}.${columnName}`);
+    }
+
+    const attribute = new this.Attribute(newName, columnInfo);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)}
+      CHANGE COLUMN ${escapeId(columnName)} ${attribute.toSqlString()}
+    `);
+    await this.query(sql);
+  }
+
+  async describeTable(table) {
+    const { escapeId } = this;
+    const { rows } = await this.query(`DESCRIBE ${escapeId(table)}`);
+    const result = {};
+    for (const row of rows) {
+      result[row.Field] = {
+        columnName: row.Field,
+        columnType: row.Type,
+        allowNull: row.Null === 'YES',
+        defaultValue: row.Default,
+        autoIncrement: row.Extra === 'auto_increment',
+      };
+    }
+    return result;
   }
 }
 
-Object.assign(MysqlDriver.prototype, { ...schema, Attribute, DataTypes });
-
 module.exports = MysqlDriver;

package/src/drivers/mysql/spellbook.js

@@ -4,10 +4,9 @@
 
 const { Hint, IndexHint } = require('../../hint');
 
-const spellbook = require('../abstract/spellbook');
+const Spellbook = require('../abstract/spellbook');
 
-module.exports = {
-  ...spellbook,
+class MySQLSpellBook extends Spellbook {
 
   formatOptimizerHints(spell) {
     const optimizerHints = spell.hints.filter(hint => hint instanceof Hint);
@@ -16,7 +15,7 @@ module.exports = {
       return `/*+ ${hints} */`;
     }
     return '';
-  },
+  }
 
   formatIndexHints(spell) {
     const indexHints = spell.hints.filter(hint => hint instanceof IndexHint);
@@ -25,7 +24,7 @@ module.exports = {
       return hints.map(hint => hint.toSqlString()).join(' ');
     }
     return '';
-  },
+  }
 
   /**
    * INSERT ... ON DUPLICATE KEY UPDATE
@@ -56,11 +55,11 @@ module.exports = {
     sets.push(...columns.map(column => `${escapeId(column)}=VALUES(${escapeId(column)})`));
 
     return `ON DUPLICATE KEY UPDATE ${sets.join(', ')}`;
-  },
+  }
 
   formatReturning() {
     return '';
-  },
+  }
 
   /**
    * UPDATE ... ORDER BY ... LIMIT ${rowCount}
@@ -68,7 +67,7 @@ module.exports = {
    * @param {Spell} spell
    */
   formatUpdate(spell) {
-    const result = spellbook.formatUpdate.call(this, spell);
+    const result = super.formatUpdate(spell);
     const { rowCount, orders } = spell;
     const chunks = [];
 
@@ -77,13 +76,14 @@ module.exports = {
     if (chunks.length > 0) result.sql += ` ${chunks.join(' ')}`;
 
     return result;
-  },
+  }
+
   /**
    * DELETE ... ORDER BY ...LIMIT
    * @param {Spell} spell 
    */
   formatDelete(spell) {
-    const result = spellbook.formatDelete.call(this, spell);
+    const result = super.formatDelete(spell);
     const { rowCount, orders } = spell;
     const chunks = [];
 
@@ -93,4 +93,6 @@ module.exports = {
 
     return result;
   }
-};
+}
+
+module.exports = MySQLSpellBook;

package/src/drivers/postgres/data_types.js

@@ -41,8 +41,8 @@ class Postgres_BINARY extends DataTypes {
 }
 
 class Postgres_INTEGER extends DataTypes.INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
   }
 
   uncast(value) {

package/src/drivers/postgres/index.js

@@ -1,121 +1,42 @@
 'use strict';
 
-const { Pool } = require('pg');
 const { performance } = require('perf_hooks');
 
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
 const DataTypes = require('./data_types');
-const { escape, escapeId } = require('./sqlstring');
-const spellbook = require('./spellbook');
-const schema = require('./schema');
-const { calculateDuration } = require('../../utils');
-
-/**
- * The actual column type can be found by mapping the `oid` (which is called `dataTypeID`) in the `RowDescription`.
- * - https://stackoverflow.com/questions/11829368/how-can-i-see-the-postgresql-column-type-from-a-rowdescription-message
- * - https://www.postgresql.org/docs/8.4/static/catalog-pg-type.html
- * - https://www.postgresql.org/docs/9.1/static/protocol-message-formats.html
- * - https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
- */
-const pgType = {
-  20: { oid: 20, typname: 'int8', type: Number }
-};
+const { 
+  escape, escapeId, formatAddColumn,
+  formatAlterColumns, formatDropColumn,
+  cast, nest, parameterize,
+} = require('./sqlstring');
 
-/**
- * Postgres tend to keep the returned value as string, even if the column type specified is something like 8 byte int. Hence this function is necessary to find the actual column type, and cast the string to the correct type if possible.
- * @param {*} value
- * @param {Object} field
- */
-function cast(value, field) {
-  const opts = pgType[field.dataTypeID];
-
-  if (opts) {
-    try {
-      return value == null ? null : opts.type(value);
-    } catch (err) {
-      throw new Error('unable to cast %s to type %s', value, opts);
-    }
-  }
-  return value;
-}
-
-/**
- * Postgres returns a nested array when `rowMode` is `array`:
- *
- *     [ [ 1, 'New Post' ] ]
- *
- * the corresponding fields would be:
- *
- *     [ { tableID: 15629, dataTypeID: 20, name: 'id' },
- *       { tableID: 15629, dataTypeID: 20, name: 'title' } ]
- *
- * This function is to turn above rows into nested objects with qualifers as keys:
- *
- *     [ { articles: { id: 1, title: 'New Post' } } ]
- *
- * @param {Array} rows
- * @param {Array} fields
- * @param {Spell} spell
- */
-function nest(rows, fields, spell) {
-  const results = [];
-  const qualifiers = [ spell.Model.tableAlias, ...Object.keys(spell.joins) ];
-  let defaultTableIndex = 0;
-
-  if (spell.groups.length > 0 && Object.keys(spell.joins).length > 0) {
-    defaultTableIndex = Infinity;
-    for (const token of spell.columns) {
-      if (token.type !== 'id') continue;
-      const index = qualifiers.indexOf(token.qualifiers[0]);
-      if (index >= 0 && index < defaultTableIndex) defaultTableIndex = index;
-    }
-  }
+const Spellbook = require('./spellbook');
+const { calculateDuration } = require('../../utils');
+const { heresql } = require('../../utils/string');
 
-  for (const row of rows) {
-    const result = {};
-    let tableIndex = defaultTableIndex;
-    let tableIDWas;
-    let qualifier;
-
-    for (let i = 0; i < fields.length; i++) {
-      const { name, tableID } = fields[i];
-      if (tableID !== tableIDWas) {
-        qualifier = tableID === 0 ? '' : qualifiers[tableIndex++];
-        tableIDWas = tableID;
-      }
-      const obj = result[qualifier] || (result[qualifier] = {});
-      obj[name] = cast(row[i], fields[i]);
-    }
-    results.push(result);
-  }
+class PostgresDriver extends AbstractDriver {
 
-  return { rows: results, fields };
-}
-
-/**
- * Postgres supports parameterized queries with `$i` slots.
- * - https://node-postgres.com/features/queries#Parameterized%20query
- * @param {string} sql
- * @param {Array} values
- */
-function parameterize(sql, values) {
-  let i = 0;
-  // starts with 1
-  const text = sql.replace(/\?/g, () => `$${++i}`);
-  return { text, values };
-}
+  // define static properties as this way IDE will prompt
+  static Spellbook = Spellbook;
+  static Attribute = Attribute;
+  static DataTypes = DataTypes;
 
-class PostgresDriver extends AbstractDriver {
   constructor(opts = {}) {
     super(opts);
     this.type = 'postgres';
     this.pool = this.createPool(opts);
+    this.Attribute = this.constructor.Attribute;
+    this.DataTypes = this.constructor.DataTypes;
+    this.spellbook = new this.constructor.Spellbook();
+
+    this.escape = escape;
+    this.escapeId = escapeId;
   }
 
   createPool(opts) {
     const { host, port, user, password, database } = opts;
-    return new Pool({ host, port, user, password, database });
+    return new (require('pg')).Pool({ host, port, user, password, database });
   }
 
   async getConnection() {
@@ -180,17 +101,90 @@ class PostgresDriver extends AbstractDriver {
     }
   }
 
-  format(spell) {
-    return spellbook.format(spell);
+  async querySchemaInfo(database, tables) {
+    tables = [].concat(tables);
+    const text = heresql(`
+      SELECT columns.*,
+            constraints.constraint_type
+        FROM information_schema.columns AS columns
+    LEFT JOIN information_schema.key_column_usage AS usage
+          ON columns.table_catalog = usage.table_catalog
+          AND columns.table_name = usage.table_name
+          AND columns.column_name = usage.column_name
+    LEFT JOIN information_schema.table_constraints AS constraints
+          ON usage.constraint_name = constraints.constraint_name
+        WHERE columns.table_catalog = $1 AND columns.table_name = ANY($2)
+    `);
+
+    const { pool } = this;
+    const { rows } = await pool.query(text, [database, tables]);
+    const schemaInfo = {};
+
+    for (const row of rows) {
+      const tableName = row.table_name;
+      const columns = schemaInfo[tableName] || (schemaInfo[tableName] = []);
+      let { data_type: dataType, character_maximum_length: length } = row;
+
+      if (dataType === 'character varying') dataType = 'varchar';
+      if (dataType === 'timestamp without time zone') dataType = 'timestamp';
+
+      let columnDefault = row.column_default;
+      if (/^NULL::/i.test(columnDefault)) columnDefault = null;
+      if (dataType === 'boolean') columnDefault = columnDefault === 'true';
+
+      const primaryKey = row.constraint_type === 'PRIMARY KEY';
+      const precision = row.datetime_precision;
+
+      columns.push({
+        columnName: row.column_name,
+        columnType: length > 0 ? `${dataType}(${length})` : dataType,
+        defaultValue: primaryKey ? null : columnDefault,
+        dataType,
+        allowNull: row.is_nullable !== 'NO',
+        // https://www.postgresql.org/docs/9.5/infoschema-table-constraints.html
+        primaryKey,
+        unique: row.constraint_type === 'UNIQUE',
+        datetimePrecision: precision === 6 ? null : precision,
+      });
+    }
+
+    return schemaInfo;
   }
-};
 
-Object.assign(PostgresDriver.prototype, {
-  ...schema,
-  Attribute,
-  DataTypes,
-  escape,
-  escapeId,
-});
+  async alterTable(table, changes) {
+    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
+    const actions = Object.keys(changes).map(name => {
+      const options = changes[name];
+      if (options.remove) return formatDropColumn(this, name);
+      const attribute = new this.Attribute(name, options);
+      const { columnName } = attribute;;
+      return attribute.modify
+        ? formatAlterColumns(this, columnName, attribute).join(', ')
+        : formatAddColumn(this, columnName, attribute);
+    });
+    chunks.push(actions.join(', '));
+    await this.query(chunks.join(' '));
+  }
+
+  async changeColumn(table, column, params) {
+    const attribute = new this.Attribute(column, params);
+    const { columnName } = attribute;
+    const alterColumns = formatAlterColumns(this, columnName, attribute);
+    const sql = heresql(`ALTER TABLE ${escapeId(table)} ${alterColumns.join(', ')}`);
+    await this.query(sql);
+  }
+
+  /**
+   * Truncate table
+   * @param {string} table the name of the table to truncate
+   * @param {Object} [opts={}] extra truncation options
+   * @param {object} [opts.restartIdentity] restart sequences owned by the table
+   */
+  async truncateTable(table, opts = {}) {
+    const chunks = [ `TRUNCATE TABLE ${escapeId(table)}` ];
+    if (opts.restartIdentity) chunks.push('RESTART IDENTITY');
+    await this.query(chunks.join(' '));
+  }
+};
 
 module.exports = PostgresDriver;

package/src/drivers/postgres/spellbook.js

@@ -1,25 +1,25 @@
 'use strict';
 
-const spellbook = require('../abstract/spellbook');
-
-module.exports = {
-  ...spellbook,
+const Spellbook = require('../abstract/spellbook');
 
+class PostgresSpellBook extends Spellbook {
   formatInsert(spell) {
     if (!spell.returning) spell.returning = true;
-    const { sql, values } = spellbook.formatInsert(spell);
+    const { sql, values } = super.formatInsert(spell);
     return {
       sql,
       values,
     };
-  },
+  };
 
   formatUpsert(spell) {
     if (!spell.returning) spell.returning = true;
-    const { sql, values } = spellbook.formatUpsert(spell);
+    const { sql, values } = super.formatUpsert(spell);
     return {
       sql,
       values,
     };
-  },
-};
+  };
+}
+
+module.exports = PostgresSpellBook;

package/src/drivers/postgres/sqlstring.js

@@ -10,3 +10,127 @@ exports.escapeId = function escapeId(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 };
 
+/**
+ * - https://www.postgresql.org/docs/9.1/sql-altertable.html
+ * @param {string} columnName
+ * @param {Object} attribute
+ */
+exports.formatAlterColumns = function formatAlterColumns(driver, columnName, attribute) {
+  const { allowNull, type, defaultValue } = attribute;
+  const sets = [
+    `TYPE ${type.toSqlString()}`,
+    allowNull ? 'DROP NOT NULL' : 'SET NOT NULL',
+    defaultValue == null
+      ? 'DROP DEFAULT'
+      : `SET DEFAULT ${SqlString.escape(defaultValue)}`,
+  ];
+
+  return sets.map(entry => `ALTER COLUMN ${driver.escapeId(columnName)} ${entry}`);
+};
+
+exports.formatAddColumn = function formatAddColumn(driver, columnName, attribute) {
+  return `ADD COLUMN ${attribute.toSqlString()}`;
+};
+
+exports.formatDropColumn = function formatDropColumn(driver, columnName) {
+  return `DROP COLUMN ${driver.escapeId(columnName)}`;
+};
+
+/**
+ * The actual column type can be found by mapping the `oid` (which is called `dataTypeID`) in the `RowDescription`.
+ * - https://stackoverflow.com/questions/11829368/how-can-i-see-the-postgresql-column-type-from-a-rowdescription-message
+ * - https://www.postgresql.org/docs/8.4/static/catalog-pg-type.html
+ * - https://www.postgresql.org/docs/9.1/static/protocol-message-formats.html
+ * - https://github.com/postgres/postgres/blob/master/src/include/catalog/pg_type.dat
+ */
+const pgType = {
+  20: { oid: 20, typname: 'int8', type: Number }
+};
+
+/**
+ * Postgres tend to keep the returned value as string, even if the column type specified is something like 8 byte int. Hence this function is necessary to find the actual column type, and cast the string to the correct type if possible.
+ * @param {*} value
+ * @param {Object} field
+ */
+
+function cast(value, field) {
+  const opts = pgType[field.dataTypeID];
+
+  if (opts) {
+    try {
+      return value == null ? null : opts.type(value);
+    } catch (err) {
+      throw new Error('unable to cast %s to type %s', value, opts);
+    }
+  }
+  return value;
+};
+
+exports.cast = cast;
+
+/**
+ * Postgres returns a nested array when `rowMode` is `array`:
+ *
+ *     [ [ 1, 'New Post' ] ]
+ *
+ * the corresponding fields would be:
+ *
+ *     [ { tableID: 15629, dataTypeID: 20, name: 'id' }
+ *       { tableID: 15629, dataTypeID: 20, name: 'title' } ]
+ *
+ * This function is to turn above rows into nested objects with qualifers as keys:
+ *
+ *     [ { articles: { id: 1, title: 'New Post' } } ]
+ *
+ * @param {Array} rows
+ * @param {Array} fields
+ * @param {Spell} spell
+ */
+exports.nest = function nest(rows, fields, spell) {
+  const results = [];
+  const qualifiers = [ spell.Model.tableAlias, ...Object.keys(spell.joins) ];
+  let defaultTableIndex = 0;
+
+  if (spell.groups.length > 0 && Object.keys(spell.joins).length > 0) {
+    defaultTableIndex = Infinity;
+    for (const token of spell.columns) {
+      if (token.type !== 'id') continue;
+      const index = qualifiers.indexOf(token.qualifiers[0]);
+      if (index >= 0 && index < defaultTableIndex) defaultTableIndex = index;
+    }
+  }
+
+  for (const row of rows) {
+    const result = {};
+    let tableIndex = defaultTableIndex;
+    let tableIDWas;
+    let qualifier;
+
+    for (let i = 0; i < fields.length; i++) {
+      const { name, tableID } = fields[i];
+      if (tableID !== tableIDWas) {
+        qualifier = tableID === 0 ? '' : qualifiers[tableIndex++];
+        tableIDWas = tableID;
+      }
+      const obj = result[qualifier] || (result[qualifier] = {});
+      obj[name] = cast(row[i], fields[i]);
+    }
+    results.push(result);
+  }
+
+  return { rows: results, fields };
+};
+
+/**
+ * Postgres supports parameterized queries with `$i` slots.
+ * - https://node-postgres.com/features/queries#Parameterized%20query
+ * @param {string} sql
+ * @param {Array} values
+ */
+exports.parameterize = function parameterize(sql, values) {
+  let i = 0;
+  // starts with 1
+  const text = sql.replace(/\?/g, () => `$${++i}`);
+  return { text, values };
+};
+