leoric 2.3.2 → 2.5.0

package/src/drivers/sqlite/data_types.js

@@ -34,8 +34,8 @@ class Sqlite_DATEONLY extends DataTypes.DATEONLY {
 }
 
 class Sqlite_INTEGER extends DataTypes.INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
   }
 
   uncast(value) {
@@ -54,24 +54,24 @@ class Sqlite_BIGINT extends DataTypes.BIGINT {
   }
 }
 class Sqlite_BINARY extends DataTypes {
-  constructor(length = 255) {
-    super(length);
-    this.length = length;
+  constructor(dataLength = 255) {
+    super(dataLength);
+    this.dataLength = dataLength;
     this.dataType = 'binary';
   }
 
   toSqlString() {
-    const { length } = this;
+    const { dataLength } = this;
     const dataType = this.dataType.toUpperCase();
     const chunks = [];
     chunks.push('VARCHAR');
-    chunks.push(length > 0 ? `${dataType}(${length})` : dataType);
+    chunks.push(dataLength > 0 ? `${dataType}(${dataLength})` : dataType);
     return chunks.join(' ');
   }
 }
 class Sqlite_VARBINARY extends Sqlite_BINARY {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'varbinary';
   }
 }

package/src/drivers/sqlite/index.js

@@ -6,17 +6,29 @@ const { performance } = require('perf_hooks');
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
 const DataTypes = require('./data_types');
-const { escapeId, escape } = require('./sqlstring');
-const schema = require('./schema');
-const spellbook = require('./spellbook');
+const { escapeId, escape, alterTableWithChangeColumn, parseDefaultValue } = require('./sqlstring');
+const Spellbook = require('./spellbook');
 const Pool = require('./pool');
 const { calculateDuration } = require('../../utils');
+const { heresql } = require('../../utils/string');
 
 class SqliteDriver extends AbstractDriver {
+
+  // define static properties as this way IDE will prompt
+  static Spellbook = Spellbook;
+  static Attribute = Attribute;
+  static DataTypes = DataTypes;
+
   constructor(opts = {}) {
     super(opts);
     this.type = 'sqlite';
     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) {
@@ -58,17 +70,116 @@ class SqliteDriver extends AbstractDriver {
     return result;
   }
 
-  format(spell) {
-    return spellbook.format(spell);
+  async querySchemaInfo(database, tables) {
+    tables = [].concat(tables);
+
+    const queries = tables.map(table => {
+      return this.query(`PRAGMA table_info(${this.escapeId(table)})`);
+    });
+    const results = await Promise.all(queries);
+    const schemaInfo = {};
+    const rColumnType = /^(\w+)(?:\(([^)]+)\))?/i;
+    const rDateType = /(?:date|datetime|timestamp)/i;
+
+    for (let i = 0; i < tables.length; i++) {
+      const table = tables[i];
+      const { rows } = results[i];
+      const columns = rows.map(row => {
+        const { name, type, notnull, dflt_value, pk } = row;
+        const columnType = type.toLowerCase();
+        const [, dataType, precision ] = columnType.match(rColumnType);
+        const primaryKey = pk === 1;
+
+        const result = {
+          columnName: name,
+          columnType,
+          defaultValue: parseDefaultValue(dflt_value, type),
+          dataType: dataType,
+          allowNull: primaryKey ? false : notnull == 0,
+          primaryKey,
+          datetimePrecision: rDateType.test(dataType) ? parseInt(precision, 10) : null,
+        };
+        return result;
+      });
+      if (columns.length > 0) schemaInfo[table] = columns;
+    }
+
+    return schemaInfo;
   }
-};
 
-Object.assign(SqliteDriver.prototype, {
-  ...schema,
-  Attribute,
-  DataTypes,
-  escape,
-  escapeId,
-});
+  async createTable(table, attributes, opts = {}) {
+    const chunks = [ `CREATE TABLE ${escapeId(table)}` ];
+    const columns = Object.keys(attributes).map(name => {
+      const attribute = new this.constructor.Attribute(name, attributes[name]);
+      return attribute.toSqlString();
+    });
+    chunks.push(`(${columns.join(', ')})`);
+    await this.query(chunks.join(' '), [], opts);
+  }
+
+  async alterTable(table, changes) {
+    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
+    const attributes = Object.keys(changes).map(name => {
+      const options = changes[name];
+      if (options.remove) return { columnName: name, remove: true };
+      return new this.constructor.Attribute(name, changes[name]);
+    });
+
+    // SQLite doesn't support altering column attributes with MODIFY COLUMN and adding a PRIMARY KEY column
+    if (attributes.some(entry => entry.modify || entry.primaryKey)) {
+      await alterTableWithChangeColumn(this, table, attributes);
+      return;
+    }
+
+    // SQLite can only add one column a time
+    // - https://www.sqlite.org/lang_altertable.html
+    for (const attribute of attributes) {
+      if (attribute.remove) {
+        const { columnName } = attribute;
+        await this.query(chunks.concat(`DROP COLUMN ${this.escapeId(columnName)}`).join(' '));
+      } else {
+        await this.query(chunks.concat(`ADD COLUMN ${attribute.toSqlString()}`).join(' '));
+      }
+    }
+  }
+
+  async addColumn(table, name, params) {
+    const attribute = new this.constructor.Attribute(name, params);
+    const sql = heresql(`
+      ALTER TABLE ${escapeId(table)}
+      ADD COLUMN ${attribute.toSqlString()}
+    `);
+    await this.query(sql);
+  }
+
+  async changeColumn(table, name, params) {
+    const attribute = new this.Attribute(name, params);
+    const schemaInfo = await this.querySchemaInfo(null, table);
+    const columns = schemaInfo[table];
+
+    for (const entry of columns) {
+      if (entry.columnName === attribute.columnName) {
+        Object.assign(entry, attribute, { modify: true });
+      }
+    }
+
+    await this.alterTable(table, columns);
+  }
+
+  async removeColumn(table, name) {
+    const attribute = new this.Attribute(name);
+    attribute.remove = true;
+    const changes = [ attribute ];
+    await alterTableWithChangeColumn(this, table, changes);
+  }
+
+  /**
+   * SQLite has only got implicit table truncation.
+   * - https://sqlite.org/lang_delete.html#the_truncate_optimization
+   */
+  async truncateTable(table) {
+    await this.query(`DELETE FROM ${escapeId(table)}`);
+  }
+};
 
 module.exports = SqliteDriver;

package/src/drivers/sqlite/spellbook.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const spellbook = require('../abstract/spellbook');
+const Spellbook = require('../abstract/spellbook');
 
 function renameSelectExpr(spell) {
   const { Model, columns, joins, groups } = spell;
@@ -40,14 +40,14 @@ function renameSelectExpr(spell) {
   }
 }
 
-module.exports = {
-  ...spellbook,
-
+class SQLiteSpellBook extends Spellbook {
   formatSelect(spell) {
     if (Object.keys(spell.joins).length > 0) {
       spell = spell.dup;
       renameSelectExpr(spell);
     }
-    return spellbook.formatSelect(spell);
+    return super.formatSelect(spell);
   }
-};
+}
+
+module.exports = SQLiteSpellBook;

package/src/drivers/sqlite/sqlstring.js

@@ -1,6 +1,10 @@
 'use strict';
 
 const SqlString = require('sqlstring');
+const debug = require('debug')('leoric');
+
+const { parseExpr } = require('../../expr');
+const { heresql } = require('../../utils/string');
 
 exports.escape = function escape(value) {
   if (typeof value === 'boolean') return +value;
@@ -10,3 +14,87 @@ exports.escape = function escape(value) {
 exports.escapeId = function escapeId(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 };
+
+/**
+ * Schema altering commands other than RENAME COLUMN or ADD COLUMN
+ * - https://www.sqlite.org/lang_altertable.html
+ * @param {string} table
+ * @param {Object} attributes the changed attributes
+ */
+exports.alterTableWithChangeColumn = async function alterTableWithChangeColumn(driver, table, changes) {
+  const { escapeId } = driver;
+  const schemaInfo = await driver.querySchemaInfo(null, table);
+  const columns = schemaInfo[table];
+
+  const changeMap = changes.reduce((result, entry) => {
+    result[entry.columnName] = entry;
+    return result;
+  }, {});
+
+  const newAttributes = [];
+  for (const column of columns) {
+    const { columnName } = column;
+    const change = changeMap[columnName];
+    if (!change || !change.remove) {
+      newAttributes.push(Object.assign(column, change));
+    }
+  }
+
+  for (const attribute of changes) {
+    if (!attribute.modify && !attribute.remove) {
+      newAttributes.push(attribute);
+    }
+  }
+
+  const newColumns = [];
+  for (const attribute of newAttributes) {
+    const { columnName, defaultValue } = attribute;
+    const change = changeMap[columnName];
+    if (!change || change.modify) {
+      newColumns.push(escapeId(columnName));
+    } else {
+      newColumns.push(SqlString.escape(defaultValue));
+    }
+  }
+
+  const connection = await driver.getConnection();
+  await connection.query('BEGIN');
+  try {
+    const newTable = `new_${table}`;
+    await driver.createTable(newTable, newAttributes, { connection });
+    await connection.query(heresql(`
+      INSERT INTO ${escapeId(newTable)}
+      SELECT ${newColumns.join(', ')}
+      FROM ${escapeId(table)}
+    `));
+    await connection.query(`DROP TABLE ${escapeId(table)}`);
+    await connection.query(heresql(`
+      ALTER TABLE ${escapeId(newTable)}
+      RENAME TO ${escapeId(table)}
+    `));
+    await connection.query('COMMIT');
+  } catch (err) {
+    await connection.query('ROLLBACK');
+    throw err;
+  } finally {
+    await connection.release();
+  }
+};
+
+// eslint-disable-next-line no-unused-vars
+exports.parseDefaultValue = function parseDefaultValue(text, type) {
+  if (typeof text !== 'string') return text;
+  if (type === 'boolean') return text === 'true';
+
+  try {
+    const ast = parseExpr(text);
+    if (ast.type === 'literal') {
+      return ast.value;
+    }
+  } catch (err) {
+    debug('[parseDefaultValue] [%s] %s', text, err);
+  }
+
+  return text;
+};
+

package/src/hint.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { isDeepStrictEqual, format } = require('util');
+const { format } = require('util');
+const isDeepStrictEqual = require('deep-equal');
 const { isPlainObject } = require('./utils');
 
 /**

package/src/realm.js

@@ -4,7 +4,7 @@ const fs = require('fs').promises;
 const path = require('path');
 
 const Bone = require('./bone');
-const { findDriver } = require('./drivers');
+const { findDriver, AbstractDriver } = require('./drivers');
 const { camelCase } = require('./utils/string');
 const sequelize = require('./adapters/sequelize');
 const Raw = require('./raw');
@@ -97,7 +97,7 @@ const rReplacementKey = /\s:(\w+)\b/g;
 
 class Realm {
   constructor(opts = {}) {
-    const { client, dialect, database, ...restOpts } = {
+    let { client, dialect, database, driver: CustomDriver, ...restOpts } = {
       dialect: 'mysql',
       database: opts.db || opts.storage,
       ...opts
@@ -109,16 +109,18 @@ class Realm {
       for (const model of opts.models) models[model.name] = model;
     }
 
-    const driver = new (findDriver(dialect))({
+    const DriverClass = CustomDriver && CustomDriver.prototype instanceof AbstractDriver? CustomDriver : findDriver(dialect);
+    const driver = new DriverClass({
       client,
       database,
-      ...restOpts
+      ...restOpts,
     });
 
     const options = {
       client,
-      dialect,
+      dialect: driver.dialect,
       database,
+      driver: CustomDriver,
       ...restOpts,
       define: { underscored: true, ...opts.define },
     };
@@ -158,6 +160,12 @@ class Realm {
     return this.Bone;
   }
 
+  async disconnect(callback) {
+    if (this.connected && this.driver) {
+      return await this.driver.disconnect(callback);
+    }
+  }
+
   async sync(options) {
     if (!this.connected) await this.connect();
     const { models } = this;

package/src/spell.js

@@ -450,10 +450,8 @@ class Spell {
   }
 
   async ignite() {
-    const { Model, command, laters } = this;
-    const { sql, values } = Model.driver.format(this);
-    const query = { sql, nestTables: command === 'select' };
-    let result = await Model.driver.query(query, values, this);
+    const { Model, laters } = this;
+    let result = await Model.driver.cast(this);
     result = { ...result, spell: this };
     for (const later of laters) {
       result = await later(result);

package/src/utils/invokable.js

@@ -18,6 +18,9 @@ function invokable(DataType) {
 
     // INTEGER.UNSIGNED
     get(target, p) {
+      // ref: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/length
+      // The length property indicates the number of parameters expected by the function.
+      // invokable INTEGER.toSqlString() will default to return "INTEGER(1)"
       return target.hasOwnProperty(p) ? target[p] : new target()[p];
     }
   });

package/types/data_types.d.ts

@@ -1,65 +1,68 @@
 type LENGTH_VARIANTS = 'tiny' | '' | 'medium' | 'long';
 
-interface INVOKABLE<T> {
-  (length: LENGTH_VARIANTS): T;
-  (length: number): T;
+interface INVOKABLE<T> extends DataType {
+  (dataLength?: LENGTH_VARIANTS): T;
+  (dataLength?: number): T;
 }
 
 export default class DataType {
   toSqlString(): string;
 
-  static STRING: typeof STRING & INVOKABLE<STRING>;
-  static INTEGER: typeof INTEGER & INVOKABLE<INTEGER>;
-  static BIGINT: typeof BIGINT & INVOKABLE<BIGINT>;
-  static DECIMAL: typeof DECIMAL & INVOKABLE<DECIMAL>;
-  static TEXT: typeof TEXT & INVOKABLE<TEXT>;
-  static BLOB: typeof BLOB & INVOKABLE<BLOB>;
-  static JSON: typeof JSON & INVOKABLE<JSON>;
-  static JSONB: typeof JSONB & INVOKABLE<JSONB>;
-  static BINARY: typeof BINARY & INVOKABLE<BINARY>;
-  static VARBINARY: typeof VARBINARY & INVOKABLE<VARBINARY>;
-  static DATE: typeof DATE & INVOKABLE<DATE>;
-  static DATEONLY: typeof DATEONLY & INVOKABLE<DATEONLY>;
-  static BOOLEAN: typeof BOOLEAN & INVOKABLE<BOOLEAN>;
-  static VIRTUAL: typeof VIRTUAL & INVOKABLE<VIRTUAL>;
+  static STRING: INVOKABLE<STRING>;
+  static INTEGER: INTEGER & INVOKABLE<INTEGER>;
+  static BIGINT: BIGINT & INVOKABLE<BIGINT>;
+  static DECIMAL: DECIMAL & INVOKABLE<DECIMAL>;
+  static TEXT: INVOKABLE<TEXT>;
+  static BLOB: INVOKABLE<BLOB>;
+  static JSON: JSON;
+  static JSONB: JSONB;
+  static BINARY: BINARY & INVOKABLE<BINARY>;
+  static VARBINARY: VARBINARY & INVOKABLE<VARBINARY>;
+  static DATE: DATE & INVOKABLE<DATE>;
+  static DATEONLY: DATEONLY;
+  static BOOLEAN: BOOLEAN;
+  static VIRTUAL: VIRTUAL;
 
 }
 
 declare class STRING extends DataType {
   dataType: 'varchar';
-  length: number;
-  constructor(length: number);
+  dataLength: number;
+  constructor(dataLength: number);
 }
 
 declare class INTEGER extends DataType {
   dataType: 'integer' | 'bigint' | 'decimal';
-  length: number;
-  constructor(length: number);
-  get UNSIGNED(): this;
-  get ZEROFILL(): this;
+  dataLength: number;
+  constructor(dataLength: number);
+  // avoid INTEGER.UNSIGNED.ZEROFILL.UNSIGNED.UNSIGNED
+  get UNSIGNED(): Omit<this, 'UNSIGNED' | 'ZEROFILL'>;
+  get ZEROFILL(): Omit<this, 'UNSIGNED' | 'ZEROFILL'>;
 }
 
 declare class BIGINT extends INTEGER {
   dataType: 'bigint';
 }
 
-declare class DECIMAL extends INTEGER {
+declare class DECIMAL_INNER extends INTEGER {
   dataType: 'decimal';
   precision: number;
   scale: number;
   constructor(precision: number, scale: number);
 }
 
+declare type DECIMAL = Omit<DECIMAL_INNER, 'dataLength'>;
+
 declare class TEXT extends DataType {
   dataType: 'text';
-  length: LENGTH_VARIANTS;
-  constructor(length: LENGTH_VARIANTS);
+  dataLength: LENGTH_VARIANTS;
+  constructor(dataLength: LENGTH_VARIANTS);
 }
 
 declare class BLOB extends DataType {
   dataType: 'blob';
-  length: LENGTH_VARIANTS;
-  constructor(length: LENGTH_VARIANTS)
+  dataLength: LENGTH_VARIANTS;
+  constructor(dataLength: LENGTH_VARIANTS)
 }
 
 declare class JSON extends DataType {
@@ -72,14 +75,14 @@ declare class JSONB extends JSON {
 
 declare class BINARY extends DataType {
   dataType: 'binary';
-  length: number;
-  constructor(length: number);
+  dataLength: number;
+  constructor(dataLength: number);
 }
 
 declare class VARBINARY extends DataType {
   dataType: 'varbinary';
-  length: number;
-  constructor(length: number);
+  dataLength: number;
+  constructor(dataLength: number);
 }
 
 declare class DATE extends DataType {

package/types/hint.d.ts

@@ -0,0 +1,96 @@
+export class Hint {
+  static build(hint: Hint | { index: string } | string): typeof Hint;
+
+  constructor(text: string);
+
+  set text(value: string);
+
+  get text(): string;
+
+  /**
+   *
+   * @param {Hint} hint
+   * @returns {boolean}
+   * @memberof Hint
+   */
+  isEqual(hint: Hint): boolean;
+
+  toSqlString(): string;
+}
+
+/**
+ * @enum
+ */
+export enum INDEX_HINT_TYPE {
+  use = 'use',
+  force = 'force',
+  ignore = 'ignore'
+}
+
+/**
+ * @enum
+ */
+export enum INDEX_HINT_SCOPE {
+  join = 'join',
+  orderBy = 'order by',
+  groupBy = 'group by',
+}
+
+export class IndexHint {
+  /**
+   * build index hint
+   *
+   * @static
+   * @param {object | string} obj
+   * @param {string} indexHintType
+   * @returns {IndexHint}
+   * @example
+   * build('idx_title')
+   * build('idx_title', INDEX_HINT_TYPE.force, INDEX_HINT_SCOPE.groupBy)
+   * build({
+   *   index: 'idx_title',
+   *   type: INDEX_HINT_TYPE.ignore,
+   *   scope: INDEX_HINT_SCOPE.groupBy,
+   * })
+   */
+  static build(hint: string | Array<string> | { index: string, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE }, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE): IndexHint;
+  
+  /**
+   * Creates an instance of IndexHint.
+   * @param {Array<string> | string} index
+   * @param {INDEX_HINT_TYPE} type
+   * @param {INDEX_HINT_SCOPE?} scope
+   * @memberof IndexHint
+   */
+  constructor(index: string, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE);
+  
+    set index(values: string | Array<string>);
+  
+    get index(): Array<string>;
+  
+    set type(value: string);
+  
+    get type(): string;
+  
+    set scope(value: string);
+  
+    get scope(): string;
+  
+    toSqlString(): string;
+  
+    /**
+     *
+     * @param {IndexHint} hint
+     * @returns {boolean}
+     * @memberof IndexHint
+     */
+    isEqual(hint: IndexHint): boolean;
+  
+    /**
+     * @static
+     * @param {IndexHint} hints
+     * @returns {Array<IndexHint>}
+     * @memberof IndexHint
+     */
+    static merge(hints: Array<IndexHint>): Array<IndexHint>;
+}