leoric 2.3.2 → 2.5.0

package/History.md

@@ -1,3 +1,34 @@
+2.5.0 / 2022-05-13
+==================
+
+## What's Changed
+* feat: support disconnect and fix timestamps init by @JimmyDaddy in https://github.com/cyjake/leoric/pull/313
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.4.1...v2.5.0
+
+2.4.1 / 2022-04-27
+==================
+
+## What's Changed
+* fix: realm.Bone.DataTypes should be invokable, Invokable.TYPE.toSqlString() get wrong default length(1), DataType definitions by @JimmyDaddy in https://github.com/cyjake/leoric/pull/307
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.4.0...v2.4.1
+
+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
 ==================
 

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.

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
@@ -37,10 +39,17 @@ const connect = async function connect(opts) {
   return realm;
 };
 
+const disconnect = async function disconnect(realm, ...args) {
+  if (realm instanceof Realm && realm.connected) {
+    return await realm.disconnect(...args);
+  }
+};
+
 Object.assign(Realm.prototype, migrations, { DataTypes });
 Object.assign(Realm, {
   default: Realm,
   connect,
+  disconnect,
   Bone,
   Collection,
   DataTypes,
@@ -50,6 +59,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.2",
+  "version": "2.5.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/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');
@@ -19,6 +20,7 @@ const {
   TIMESTAMP_NAMES,
   LEGACY_TIMESTAMP_COLUMN_MAP,
   ASSOCIATE_METADATA_MAP,
+  TIMESTAMP_ATTRIBUTE_NAMES,
 } = require('./constants');
 
 const columnAttributesKey = Symbol('leoric#columns');
@@ -137,6 +139,8 @@ function valuesValidate(values, attributes, ctx) {
  */
 class Bone {
 
+  static DataTypes = DataTypes.invokable;
+
   // private variables
   #raw = {};
   #rawSaved = {};
@@ -380,7 +384,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);
   }
 
   /**
@@ -412,7 +416,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 = {};
@@ -420,7 +424,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;
   }
@@ -439,7 +443,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 = {};
@@ -448,7 +452,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 ];
       }
     }
@@ -996,7 +1000,7 @@ class Bone {
       const attribute = new Attribute(name, attributes[name], options.define);
       attributeMap[attribute.columnName] = attribute;
       attributes[name] = attribute;
-      if (TIMESTAMP_NAMES.includes(name)) {
+      if (TIMESTAMP_ATTRIBUTE_NAMES.includes(name)) {
         const { columnName } = attribute;
         const legacyColumnName = LEGACY_TIMESTAMP_COLUMN_MAP[columnName];
         if (!columnMap[columnName] && legacyColumnName && columnMap[legacyColumnName]) {
@@ -1560,9 +1564,7 @@ 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) {
@@ -1713,6 +1715,4 @@ for (const getter of Spell_getters) {
   });
 }
 
-Object.assign(Bone, { DataTypes });
-
 module.exports = Bone;

package/src/constants.js

@@ -20,6 +20,12 @@ const LEGACY_TIMESTAMP_COLUMN_MAP = {
   deleted_at: 'gmt_deleted',
 };
 
+const TIMESTAMP_ATTRIBUTE_NAMES = [ 
+  'createdAt', 'updatedAt', 'deletedAt',
+  'gmtCreate', 'gmtModified', 'gmtDeleted',
+  'created_at', 'updated_at', 'deleted_at',
+  'gmt_create', 'gmt_modified', 'gmt_deleted',
+];
 const TIMESTAMP_NAMES = [ 'createdAt', 'updatedAt', 'deletedAt' ];
 
 const ASSOCIATE_METADATA_MAP = {
@@ -33,5 +39,6 @@ module.exports = {
   LEGACY_TIMESTAMP_MAP,
   TIMESTAMP_NAMES,
   LEGACY_TIMESTAMP_COLUMN_MAP,
-  ASSOCIATE_METADATA_MAP
+  ASSOCIATE_METADATA_MAP,
+  TIMESTAMP_ATTRIBUTE_NAMES
 };

package/src/data_types.js

@@ -110,20 +110,20 @@ class DataType {
  * STRING
  * STRING(127)
  * STRING.BINARY
- * @param {number} length
+ * @param {number} dataLength
  */
 class STRING extends DataType {
-  constructor(length = 255) {
+  constructor(dataLength = 255) {
     super();
     this.dataType = 'varchar';
-    this.length = length;
+    this.dataLength = dataLength;
   }
 
   toSqlString() {
-    const { length } = this;
+    const { dataLength } = this;
     const dataType = this.dataType.toUpperCase();
     const chunks = [];
-    chunks.push(length > 0 ? `${dataType}(${length})` : dataType);
+    chunks.push(dataLength > 0 ? `${dataType}(${dataLength})` : dataType);
     return chunks.join(' ');
   }
 
@@ -134,17 +134,17 @@ class STRING extends DataType {
 }
 
 class BINARY extends DataType {
-  constructor(length = 255) {
+  constructor(dataLength = 255) {
     super();
-    this.length = length;
+    this.dataLength = dataLength;
     this.dataType = 'binary';
   }
 
   toSqlString() {
-    const { length } = this;
+    const { dataLength } = this;
     const dataType = this.dataType.toUpperCase();
     const chunks = [];
-    chunks.push(length > 0 ? `${dataType}(${length})` : dataType);
+    chunks.push(dataLength > 0 ? `${dataType}(${dataLength})` : dataType);
     return chunks.join(' ');
   }
 
@@ -156,8 +156,8 @@ class BINARY extends DataType {
 }
 
 class VARBINARY extends BINARY {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'varbinary';
   }
 }
@@ -170,12 +170,12 @@ class VARBINARY extends BINARY {
  * INTEGER.UNSIGNED
  * INTEGER.UNSIGNED.ZEROFILL
  * INTEGER(10)
- * @param {number} length
+ * @param {number} dataLength
  */
 class INTEGER extends DataType {
-  constructor(length) {
+  constructor(dataLength) {
     super();
-    this.length = length;
+    this.dataLength = dataLength;
     this.dataType = 'integer';
   }
 
@@ -190,10 +190,10 @@ class INTEGER extends DataType {
   }
 
   toSqlString() {
-    const { length, unsigned, zerofill } = this;
+    const { dataLength, unsigned, zerofill } = this;
     const dataType = this.dataType.toUpperCase();
     const chunks = [];
-    chunks.push(length > 0 ? `${dataType}(${length})` : dataType);
+    chunks.push(dataLength > 0 ? `${dataType}(${dataLength})` : dataType);
     if (unsigned) chunks.push('UNSIGNED');
     if (zerofill) chunks.push('ZEROFILL');
     return chunks.join(' ');
@@ -222,11 +222,11 @@ class INTEGER extends DataType {
  * TINYINT
  * TINYINT.UNSIGNED
  * TINYINT(1)
- * @param {number} length
+ * @param {number} dataLength
  */
 class TINYINT extends INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'tinyint';
   }
 }
@@ -237,11 +237,11 @@ class TINYINT extends INTEGER {
  * SMALLINT
  * SMALLINT.UNSIGNED
  * SMALLINT(2)
- * @param {number} length
+ * @param {number} dataLength
  */
 class SMALLINT extends INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'smallint';
   }
 }
@@ -252,11 +252,11 @@ class SMALLINT extends INTEGER {
  * MEDIUMINT
  * MEDIUMINT.UNSIGNED
  * MEDIUMINT(3)
- * @param {number} length
+ * @param {number} dataLength
  */
 class MEDIUMINT extends INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'mediumint';
   }
 }
@@ -268,11 +268,11 @@ class MEDIUMINT extends INTEGER {
  * BIGINT
  * BIGINT.UNSIGNED
  * BIGINT(8)
- * @param {number} length
+ * @param {number} dataLength
  */
 class BIGINT extends INTEGER {
-  constructor(length) {
-    super(length);
+  constructor(dataLength) {
+    super(dataLength);
     this.dataType = 'bigint';
   }
 }
@@ -442,11 +442,11 @@ class TEXT extends DataType {
     }
     super();
     this.dataType = 'text';
-    this.length = length;
+    this.dataLength = length;
   }
 
   toSqlString() {
-    return [ this.length, this.dataType ].join('').toUpperCase();
+    return [ this.dataLength, this.dataType ].join('').toUpperCase();
   }
 }
 
@@ -457,11 +457,11 @@ class BLOB extends DataType {
     }
     super();
     this.dataType = 'blob';
-    this.length = length;
+    this.dataLength = length;
   }
 
   toSqlString() {
-    return [ this.length, this.dataType ].join('').toUpperCase();
+    return [ this.dataLength, this.dataType ].join('').toUpperCase();
   }
 
   cast(value) {

package/src/drivers/abstract/attribute.js

@@ -77,7 +77,7 @@ function createType(DataTypes, params) {
     case 'VARBINARY':
     case 'CHAR':
     case 'VARCHAR':
-      return new DataType(type.length);
+      return new DataType(type.dataLength);
     default:
       return new DataType();
   }

package/src/drivers/abstract/index.js

@@ -1,6 +1,13 @@
 'use strict';
 
+const SqlString = require('sqlstring');
+const debug = require('debug')('leoric');
+
 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 +15,204 @@ 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!');
+  }
+
+  /**
+   * disconnect manually
+   * @param {Function} callback 
+   */
+  async disconnect(callback) {
+    debug('[disconnect] called');
+  }
+
+  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;