leoric 2.3.0 → 2.4.0

package/History.md

@@ -1,3 +1,43 @@
+2.4.0 / 2022-04-24
+==================
+
+## What's Changed
+* feat: support custom driver by @JimmyDaddy in https://github.com/cyjake/leoric/pull/304
+* chore: update build status badge by @snapre in https://github.com/cyjake/leoric/pull/305
+* feat: export more ts type definitions and  use deep-equal module by @JimmyDaddy in https://github.com/cyjake/leoric/pull/306
+
+## New Contributors
+* @snapre made their first contribution in https://github.com/cyjake/leoric/pull/305
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.3.2...v2.4.0
+
+2.3.2 / 2022-04-15
+==================
+
+## What's Changed
+* fix: order by raw with mix-type array in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/298
+* docs: monthly updates and example about egg-orm usage with TypeScript by @cyjake in https://github.com/cyjake/leoric/pull/299
+* docs: monthly updates in en & docmentation about typescript support by @cyjake in https://github.com/cyjake/leoric/pull/300
+* fix: raw query should format replacements with extra blank by @JimmyDaddy in https://github.com/cyjake/leoric/pull/301
+* docs: elaborate on querying by @cyjake in https://github.com/cyjake/leoric/pull/302
+* feat: transaction should return result by @JimmyDaddy in https://github.com/cyjake/leoric/pull/303
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.3.1...v2.3.2
+
+2.3.1 / 2022-03-22
+==================
+
+## What's Changed
+* fix: mysql2 Invalid Date compatible by @JimmyDaddy in https://github.com/cyjake/leoric/pull/291
+* fix: order by raw in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/292
+* fix: bulk update query conditions duplicated in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/293
+* fix: bulk destroy query conditions duplicated in sequelize mode by @JimmyDaddy in https://github.com/cyjake/leoric/pull/295
+* fix: drop column if not defined in attributes when alter table by @cyjake in https://github.com/cyjake/leoric/pull/296
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.3.0...v2.3.1
+
 2.3.0 / 2022-03-10
 ==================
 

package/Readme.md

@@ -3,7 +3,7 @@
 [![Package Quality](https://packagequality.com/shield/leoric.svg)](https://packagequality.com/#?package=leoric)
 [![NPM Downloads](https://img.shields.io/npm/dm/leoric.svg?style=flat)](https://www.npmjs.com/package/leoric)
 [![NPM Version](http://img.shields.io/npm/v/leoric.svg?style=flat)](https://www.npmjs.com/package/leoric)
-[![Build Status](https://travis-ci.org/cyjake/leoric.svg)](https://travis-ci.org/cyjake/leoric)
+[![Build Status](https://github.com/cyjake/leoric/actions/workflows/nodejs.yml/badge.svg)](https://github.com/cyjake/leoric/actions/workflows/nodejs.yml)
 [![codecov](https://codecov.io/gh/cyjake/leoric/branch/master/graph/badge.svg?token=OZZWTZTDS1)](https://codecov.io/gh/cyjake/leoric)
 
 Leoric is an object-relational mapping for Node.js, which is heavily influenced by Active Record of Ruby on Rails. See the [documentation](https://leoric.js.org) for detail.
@@ -74,6 +74,32 @@ await realm.sync();
 
 A more detailed syntax table may be found at the [documentation](https://leoric.js.org/#syntax-table) site.
 
+## TypeScript charged
+
+```ts
+import { Bone, BelongsTo, Column, DataTypes: { TEXT } } from 'leoric';
+import User from './user';
+
+export default class Post extends Bone {
+  @Column({ autoIncrement: true })
+  id: bigint;
+
+  @Column(TEXT)
+  content: string;
+
+  @Column()
+  description: string;
+
+  @Column()
+  userId: bigint;
+
+  @BelongsTo()
+  user: User;
+}
+```
+
+More about TypeScript integration examples can be found at [the TypeScript support documentation](https://leoric.js.org/types)
+
 ## Contributing
 
 There are many ways in which you can participate in the project, for example:
@@ -89,6 +115,6 @@ If you are interested in fixing issues and contributing directly to the code bas
 - Submitting pull requests
 - Contributing to translations
 
-## Related Projects
+## egg-orm
 
-If developing web applications with [egg framework](https://eggjs.org/), it's highly recommended using the [egg-orm](https://github.com/eggjs/egg-orm) plugin.
+If developing web applications with [egg framework](https://eggjs.org/), it's highly recommended using the [egg-orm](https://github.com/eggjs/egg-orm) plugin. More detailed examples about setting up egg-orm with egg framework in either JavaScript or TypeScript can be found at <https://github.com/eggjs/egg-orm/tree/master/examples>

package/index.js

@@ -12,6 +12,8 @@ const { heresql } = require('./src/utils/string');
 const Hint = require('./src/hint');
 const Realm = require('./src/realm');
 const Decorators = require('./src/decorators');
+const Raw = require('./src/raw');
+const { MysqlDriver, PostgresDriver, SqliteDriver, AbstractDriver } = require('./src/drivers');
 
 /**
  * @typedef {Object} RawSql
@@ -50,6 +52,11 @@ Object.assign(Realm, {
   heresql,
   ...Hint,
   ...Decorators,
+  MysqlDriver,
+  PostgresDriver,
+  SqliteDriver,
+  AbstractDriver,
+  Raw,
 });
 
 module.exports = Realm;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -21,6 +21,7 @@
     "test:mysql2": "./test/start.sh test/integration/mysql2.test.js",
     "test:postgres": "./test/start.sh test/integration/postgres.test.js",
     "test:sqlite": "./test/start.sh test/integration/sqlite.test.js",
+    "test:custom": "./test/start.sh test/integration/custom.test.js",
     "test:sqlcipher": "./test/start.sh test/integration/sqlcipher.test.js",
     "test:dts": "./test/start.sh dts",
     "test:coverage": "nyc ./test/start.sh && nyc report --reporter=lcov",
@@ -49,6 +50,7 @@
   },
   "dependencies": {
     "debug": "^3.1.0",
+    "deep-equal": "^2.0.5",
     "heredoc": "^1.3.1",
     "pluralize": "^7.0.0",
     "reflect-metadata": "^0.1.13",

package/src/adapters/sequelize.js

@@ -2,6 +2,7 @@
 
 const { setupSingleHook } = require('../setup_hooks');
 const { compose, isPlainObject } = require('../utils');
+const Raw = require('../raw');
 
 function translateOptions(spell, options) {
   const { attributes, where, group, order, offset, limit, include, having } = options;
@@ -18,7 +19,7 @@ function translateOptions(spell, options) {
   if (having) spell.$having(having);
 
   if (order) {
-    if (typeof order === 'string') {
+    if (typeof order === 'string' || order instanceof Raw) {
       spell.$order(order);
     } else if (Array.isArray(order) && order.length) {
       if (order.some(item => Array.isArray(item))) {
@@ -34,6 +35,8 @@ function translateOptions(spell, options) {
       } else if (order.length && order[0]) {
         // ['created_at', 'asc']
         spell.$order(order[0], order[1] || '');
+      } else if (order instanceof Raw) {
+        spell.$order(order);
       }
     }
   }
@@ -317,10 +320,12 @@ module.exports = Bone => {
     }
 
     // proxy to class.destroy({ individualHooks=false }) see https://github.com/sequelize/sequelize/blob/4063c2ab627ad57919d5b45cc7755f077a69fa5e/lib/model.js#L2895  before(after)BulkDestroy
-    static async bulkDestroy(options = {}) {
+    static bulkDestroy(options = {}) {
       const { where, force } = options;
       const spell = this._remove(where || {}, force, { ...options });
-      translateOptions(spell, options);
+      const transOptions = { ...options };
+      delete transOptions.where;
+      translateOptions(spell, transOptions);
       return spell;
     }
 
@@ -496,7 +501,9 @@ module.exports = Bone => {
       const { where, paranoid = false, validate } = options;
       const whereConditions = where || {};
       const spell = super.update(whereConditions, values, { validate, hooks: false, ...options });
-      translateOptions(spell, options);
+      const transOptions = { ...options };
+      delete transOptions.where;
+      translateOptions(spell, transOptions);
       if (!paranoid) return spell.unparanoid;
       return spell;
     }

package/src/bone.js

@@ -5,6 +5,7 @@
  * @module
  */
 const util = require('util');
+const deepEqual = require('deep-equal');
 const pluralize = require('pluralize');
 const { executeValidator, LeoricValidateError } = require('./validator');
 require('reflect-metadata');
@@ -37,10 +38,12 @@ function looseReadonly(props) {
 
 function compare(attributes, columnMap) {
   const diff = {};
+  const columnNames = new Set();
 
   for (const name in attributes) {
     const attribute = attributes[name];
     const { columnName } = attribute;
+    columnNames.add(columnName);
 
     if (!attribute.equals(columnMap[columnName])) {
       diff[name] = {
@@ -50,6 +53,12 @@ function compare(attributes, columnMap) {
     }
   }
 
+  for (const columnName in columnMap) {
+    if (!columnNames.has(columnName)) {
+      diff[columnName] = { remove: true };
+    }
+  }
+
   return diff;
 }
 
@@ -254,8 +263,8 @@ class Bone {
 
   /**
    * get actual update/insert columns to avoid empty insert or update
-   * @param {Object} data 
-   * @returns 
+   * @param {Object} data
+   * @returns
    */
   static _getColumns(data) {
     if (!Object.keys(data).length) return data;
@@ -372,7 +381,7 @@ class Bone {
     if (this.#rawUnset.has(name) || !this.hasAttribute(name)) return false;
     const value = this.attribute(name);
     const valueWas = this.attributeWas(name);
-    return !util.isDeepStrictEqual(value, valueWas);
+    return !deepEqual(value, valueWas);
   }
 
   /**
@@ -404,7 +413,7 @@ class Bone {
       if (this.#rawUnset.has(name) || this.#rawPrevious[name] === undefined || !this.hasAttribute(name)) return {};
       const value = this.attribute(name);
       const valueWas = this.#rawPrevious[name] == null ? null : this.#rawPrevious[name];
-      if (util.isDeepStrictEqual(value, valueWas)) return {};
+      if (deepEqual(value, valueWas)) return {};
       return { [name]: [ valueWas, value ] };
     }
     const result = {};
@@ -412,7 +421,7 @@ class Bone {
       if (this.#rawUnset.has(attrKey) || this.#rawPrevious[attrKey] === undefined) continue;
       const value = this.attribute(attrKey);
       const valueWas = this.#rawPrevious[attrKey] == null ? null : this.#rawPrevious[attrKey];
-      if (!util.isDeepStrictEqual(value, valueWas)) result[attrKey] = [ valueWas, value ];
+      if (!deepEqual(value, valueWas)) result[attrKey] = [ valueWas, value ];
     }
     return result;
   }
@@ -431,7 +440,7 @@ class Bone {
       if (this.#rawUnset.has(name) || !this.hasAttribute(name)) return {};
       const value = this.attribute(name);
       const valueWas = this.attributeWas(name);
-      if (util.isDeepStrictEqual(value, valueWas)) return {};
+      if (deepEqual(value, valueWas)) return {};
       return { [name]: [ valueWas, value ] };
     }
     const result = {};
@@ -440,7 +449,7 @@ class Bone {
       const value = this.attribute(attrKey);
       const valueWas = this.attributeWas(attrKey);
 
-      if (!util.isDeepStrictEqual(value, valueWas)) {
+      if (!deepEqual(value, valueWas)) {
         result[attrKey] = [ valueWas, value ];
       }
     }
@@ -573,7 +582,14 @@ class Bone {
     for (const name of Object.keys(attributes)) {
       const attribute = attributes[name];
       // Take advantage of uncast/cast to create new copy of value
-      const value = attribute.uncast(this.#raw[name]);
+      let value;
+      try {
+        value = attribute.uncast(this.#raw[name]);
+      } catch (error) {
+        console.error(error);
+        // do not interrupt sync raw
+        value = this.#raw[name];
+      }
       if (this.#rawSaved[name] !== undefined) {
         this.#rawPrevious[name] = this.#rawSaved[name];
       } else if (this.#rawPrevious[name] === undefined && this.#raw[name] != null) {
@@ -1545,18 +1561,17 @@ class Bone {
   }
 
   static query(spell) {
-    const { sql, values } = this.driver.format(spell);
-    const query = { sql, nestTables: spell.command === 'select' };
-    return this.driver.query(query, values, spell);
+    return this.driver.cast(spell);
   }
 
   static async transaction(callback) {
     const connection = await this.driver.getConnection();
+    let result;
     if (callback.constructor.name === 'AsyncFunction') {
       // if callback is an AsyncFunction
       await this.driver.query('BEGIN', [], { connection, Model: this, command: 'BEGIN'  });
       try {
-        await callback({ connection });
+        result = await callback({ connection });
         await this.driver.query('COMMIT', [], { connection, Model: this, command: 'COMMIT'  });
       } catch (err) {
         await this.driver.query('ROLLBACK', [], { connection, Model: this, command: 'ROLLBACK' });
@@ -1566,7 +1581,6 @@ class Bone {
       }
     } else if (callback.constructor.name === 'GeneratorFunction') {
       const gen = callback({ connection });
-      let result;
 
       try {
         await this.driver.query('BEGIN', [], {  connection, Model: this, command: 'BEGIN' });
@@ -1586,6 +1600,7 @@ class Bone {
     } else {
       throw new Error('unexpected transaction function, should be GeneratorFunction or AsyncFunction.');
     }
+    return result;
   }
 
   static init(attributes = {}, opts = {}, overrides = {}) {

package/src/data_types.js

@@ -17,17 +17,20 @@ class DataType {
     const {
       STRING, TEXT,
       DATE, DATEONLY,
-      TINYINT, SMALLINT, MEDIUMINT, INTEGER, BIGINT,
+      TINYINT, SMALLINT, MEDIUMINT, INTEGER, BIGINT, DECIMAL,
       BOOLEAN,
       BINARY, VARBINARY, BLOB,
     } = this;
-    const [ , dataType, appendix ] = columnType.match(/(\w+)(?:\((\d+)\))?/);
-    const length = appendix && parseInt(appendix, 10);
+    const [ , dataType, ...matches ] = columnType.match(/(\w+)(?:\((\d+)(?:,(\d+))?\))?/);
+    const params = [];
+    for (let i = 0; i < matches.length; i++) {
+      if (matches[i] != null) params[i] = parseInt(matches[i], 10);
+    }
 
     switch (dataType) {
       case 'varchar':
       case 'char':
-        return new STRING(length);
+        return new STRING(...params);
       // longtext is only for MySQL
       case 'longtext':
         return new TEXT('long');
@@ -40,30 +43,31 @@ class DataType {
       case 'datetime':
       case 'timestamp':
         // new DATE(precision)
-        return new DATE(length);
+        return new DATE(...params);
       case 'decimal':
+        return new DECIMAL(...params);
       case 'int':
       case 'integer':
       case 'numeric':
-        return new INTEGER(length);
+        return new INTEGER(...params);
       case 'mediumint':
-        return new MEDIUMINT(length);
+        return new MEDIUMINT(...params);
       case 'smallint':
-        return new SMALLINT(length);
+        return new SMALLINT(...params);
       case 'tinyint':
-        return new TINYINT(length);
+        return new TINYINT(...params);
       case 'bigint':
-        return new BIGINT(length);
+        return new BIGINT(...params);
       case 'boolean':
         return new BOOLEAN();
       // mysql only
       case 'binary':
       // postgres only
       case 'bytea':
-        return new BINARY(length);
+        return new BINARY(...params);
       // mysql only
       case 'varbinary':
-        return new VARBINARY(length);
+        return new VARBINARY(...params);
       case 'longblob':
         return new BLOB('long');
       case 'mediumblob':
@@ -273,6 +277,41 @@ class BIGINT extends INTEGER {
   }
 }
 
+/**
+ * fixed-point decimal types
+ * @example
+ * DECIMAL
+ * DECIMAL.UNSIGNED
+ * DECIMAL(5, 2)
+ * @param {number} precision
+ * @param {number} scale
+ * - https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html
+ */
+class DECIMAL extends INTEGER {
+  constructor(precision, scale) {
+    super();
+    this.dataType = 'decimal';
+    this.precision = precision;
+    this.scale = scale;
+  }
+
+  toSqlString() {
+    const { precision, scale, unsigned, zerofill } = this;
+    const dataType = this.dataType.toUpperCase();
+    const chunks = [];
+    if (precision > 0 && scale >= 0) {
+      chunks.push(`${dataType}(${precision},${scale})`);
+    } else if (precision > 0) {
+      chunks.push(`${dataType}(${precision})`);
+    } else {
+      chunks.push(dataType);
+    }
+    if (unsigned) chunks.push('UNSIGNED');
+    if (zerofill) chunks.push('ZEROFILL');
+    return chunks.join(' ');
+  }
+}
+
 const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6})$/;
 
 class DATE extends DataType {
@@ -494,6 +533,7 @@ const DataTypes = {
   MEDIUMINT,
   INTEGER,
   BIGINT,
+  DECIMAL,
   DATE,
   DATEONLY,
   BOOLEAN,

package/src/drivers/abstract/attribute.js

@@ -66,6 +66,8 @@ function createType(DataTypes, params) {
   switch (type.constructor.name) {
     case 'DATE':
       return new DataType(type.precision, type.timezone);
+    case 'DECIMAL':
+      return new DataType(type.precision, type.scale);
     case 'TINYINT':
     case 'SMALLINT':
     case 'MEDIUMINT':
@@ -73,6 +75,8 @@ function createType(DataTypes, params) {
     case 'BIGINT':
     case 'BINARY':
     case 'VARBINARY':
+    case 'CHAR':
+    case 'VARCHAR':
       return new DataType(type.length);
     default:
       return new DataType();

package/src/drivers/abstract/index.js

@@ -1,6 +1,12 @@
 'use strict';
 
+const SqlString = require('sqlstring');
+
 const Logger = require('./logger');
+const Attribute = require('./attribute');
+const DataTypes = require('../../data_types');
+const Spellbook = require('./spellbook');
+const { heresql, camelCase } = require('../../utils/string');
 
 /**
  * Migration methods
@@ -8,11 +14,196 @@ const Logger = require('./logger');
  * - https://dev.mysql.com/doc/refman/8.0/en/alter-table.html
  */
 
-module.exports = class AbstractDriver {
+class AbstractDriver {
+
+  // define static properties as this way IDE will prompt
+  static Spellbook = Spellbook;
+  static Attribute = Attribute;
+  static DataTypes = DataTypes;
+
   constructor(opts = {}) {
     const { logger } = opts;
     this.logger = logger instanceof Logger ? logger : new Logger(logger);
     this.idleTimeout = opts.idleTimeout || 60;
     this.options = opts;
+    this.Attribute = this.constructor.Attribute;
+    this.DataTypes = this.constructor.DataTypes;
+    this.spellbook = new this.constructor.Spellbook();
+    this.escape = SqlString.escape;
+    this.escapeId = SqlString.escapeId;
+  }
+
+  /**
+   * query with spell
+   * @param {Spell} spell 
+   * @returns 
+   */
+  async cast(spell) {
+    const { sql, values } = this.format(spell);
+    const query = { sql, nestTables: spell.command === 'select' };
+    return await this.query(query, values, spell);
+  }
+
+  /**
+   * raw query
+   * @param {object|string} query 
+   * @param {object | array} values 
+   * @param {object} opts 
+   */
+  async query(query, values, opts) {
+    throw new Error('unimplemented!');
+  }
+
+  get dialect() {
+    return camelCase(this.constructor.name.replace('Driver', ''));
+  }
+
+  /**
+   * use spellbook to format spell
+   * @param {Spell} spell 
+   * @returns 
+   */
+  format(spell) {
+    return this.spellbook.format(spell);
   }
+
+  async createTable(table, attributes) {
+    const { escapeId } = this;
+    const chunks = [ `CREATE TABLE ${escapeId(table)}` ];
+    const columns = Object.keys(attributes).map(name => {
+      const attribute = new this.Attribute(name, attributes[name]);
+      return attribute.toSqlString();
+    });
+    chunks.push(`(${columns.join(', ')})`);
+    await this.query(chunks.join(' '));
+  }
+
+  async alterTable(table, attributes) {
+    const { escapeId } = this;
+    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
+
+    const actions = Object.keys(attributes).map(name => {
+      const options = attributes[name];
+      // { [columnName]: { remove: true } }
+      if (options.remove) return `DROP COLUMN ${escapeId(name)}`;
+      const attribute = new this.Attribute(name, options);
+      return [
+        options.modify ? 'MODIFY COLUMN' : 'ADD COLUMN',
+        attribute.toSqlString(),
+      ].join(' ');
+    });
+    chunks.push(actions.join(', '));
+    await this.query(chunks.join(' '));
+  }
+
+  async describeTable(table) {
+    const { database } = this.options;
+    const schemaInfo = await this.querySchemaInfo(database, table);
+    return schemaInfo[table].reduce(function(result, column) {
+      result[column.columnName] = column;
+      return result;
+    }, {});
+  }
+
+  async addColumn(table, name, params) {
+    const { escapeId } = this;
+    const attribute = new this.Attribute(name, params);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)}
+      ADD COLUMN ${attribute.toSqlString()}
+    `);
+    await this.query(sql);
+  }
+
+  async changeColumn(table, name, params) {
+    const { escapeId } = this;
+    const attribute = new this.Attribute(name, params);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)}
+      MODIFY COLUMN ${attribute.toSqlString()}
+    `);
+    await this.query(sql);
+  }
+
+  async removeColumn(table, name) {
+    const { escapeId } = this;
+    const { columnName } = new this.Attribute(name);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)} DROP COLUMN ${escapeId(columnName)}
+    `);
+    await this.query(sql);
+  }
+
+  async renameColumn(table, name, newName) {
+    const { escapeId } = this;
+    const { columnName } = new this.Attribute(name);
+    const attribute = new this.Attribute(newName);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)}
+      RENAME COLUMN ${escapeId(columnName)} TO ${escapeId(attribute.columnName)}
+    `);
+    await this.query(sql);
+  }
+
+  async renameTable(table, newTable) {
+    const { escapeId } = this;
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)} RENAME TO ${escapeId(newTable)}
+    `);
+    await this.query(sql);
+  }
+
+  async dropTable(table) {
+    const { escapeId } = this;
+    await this.query(`DROP TABLE IF EXISTS ${escapeId(table)}`);
+  }
+
+  async truncateTable(table) {
+    const { escapeId } = this;
+    await this.query(`TRUNCATE TABLE ${escapeId(table)}`);
+  }
+
+  async addIndex(table, attributes, opts = {}) {
+    const { escapeId } = this;
+    const columns = attributes.map(name => new this.Attribute(name).columnName);
+    const type = opts.unique ? 'UNIQUE' : opts.type;
+    const prefix = type === 'UNIQUE' ? 'uk' : 'idx';
+    const { name } = {
+      name: [ prefix, table ].concat(columns).join('_'),
+      ...opts,
+    };
+
+    if (type != null && ![ 'UNIQUE', 'FULLTEXT', 'SPATIAL' ].includes(type)) {
+      throw new Error(`Unexpected index type: ${type}`);
+    }
+
+    const sql = heresql(`
+      CREATE ${type ? `${type} INDEX` : 'INDEX'} ${escapeId(name)}
+      ON ${escapeId(table)} (${columns.map(escapeId).join(', ')})
+    `);
+    await this.query(sql);
+  }
+
+  async removeIndex(table, attributes, opts = {}) {
+    const { escapeId } = this;
+    let name;
+    if (Array.isArray(attributes)) {
+      const columns = attributes.map(entry => new this.Attribute(entry).columnName);
+      const type = opts.unique ? 'UNIQUE' : opts.type;
+      const prefix = type === 'UNIQUE' ? 'uk' : 'idx';
+      name = [ prefix, table ].concat(columns).join('_');
+    } else if (typeof attributes === 'string') {
+      name = attributes;
+    } else {
+      throw new Error(`Unexpected index name: ${attributes}`);
+    }
+
+    const sql = this.type === 'mysql'
+      ? `DROP INDEX ${escapeId(name)} ON ${escapeId(table)}`
+      : `DROP INDEX IF EXISTS ${escapeId(name)}`;
+    await this.query(sql);
+  }
+
 };
+
+module.exports = AbstractDriver;