leoric 2.4.0 → 2.6.0

package/index.js

@@ -39,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",

package/src/bone.js

@@ -20,6 +20,7 @@ const {
   TIMESTAMP_NAMES,
   LEGACY_TIMESTAMP_COLUMN_MAP,
   ASSOCIATE_METADATA_MAP,
+  TIMESTAMP_ATTRIBUTE_NAMES,
 } = require('./constants');
 
 const columnAttributesKey = Symbol('leoric#columns');
@@ -138,6 +139,8 @@ function valuesValidate(values, attributes, ctx) {
  */
 class Bone {
 
+  static DataTypes = DataTypes.invokable;
+
   // private variables
   #raw = {};
   #rawSaved = {};
@@ -997,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]) {
@@ -1712,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';
   }
 }
@@ -312,8 +312,7 @@ class DECIMAL extends INTEGER {
   }
 }
 
-const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6})$/;
-
+const rDateFormat = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:[,.]\d{3,6}){0,1}$/;
 class DATE extends DataType {
   constructor(precision, timezone = true) {
     super();
@@ -359,7 +358,8 @@ class DATE extends DataType {
     // @deprecated
     // vaguely standard date formats such as 2021-10-15 15:50:02,548
     if (typeof value === 'string' && rDateFormat.test(value)) {
-      value = new Date(`${value.replace(' ', 'T').replace(',', '.')}Z`);
+      // 2021-10-15 15:50:02,548 => 2021-10-15T15:50:02,548,  2021-10-15 15:50:02 => 2021-10-15T15:50:02.000
+      value = new Date(`${value.replace(' ', 'T').replace(',', '.')}`);
     }
 
     // 1634611135776
@@ -371,10 +371,12 @@ class DATE extends DataType {
   }
 }
 
-class DATEONLY extends DataType {
+class DATEONLY extends DATE {
   constructor() {
     super();
     this.dataType = 'date';
+    this.precision = null;
+    this.timezone = false;
   }
 
   toSqlString() {
@@ -387,34 +389,6 @@ class DATEONLY extends DataType {
     }
     return value;
   }
-
-  cast(value) {
-    const original = value;
-    if (value == null) return value;
-    if (!(value instanceof Date)) value = new Date(value);
-    if (isNaN(value.getTime())) return original;
-    return this._round(value);
-  }
-
-  uncast(value) {
-    const originValue = value;
-
-    if (value == null || value instanceof Raw) return value;
-    if (typeof value.toDate === 'function') {
-      value = value.toDate();
-    }
-
-    // @deprecated
-    // vaguely standard date formats such as 2021-10-15 15:50:02,548
-    if (typeof value === 'string' && rDateFormat.test(value)) {
-      value = new Date(`${value.replace(' ', 'T').replace(',', '.')}Z`);
-    }
-
-    if (!(value instanceof Date)) value = new Date(value);
-    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));
-
-    return this._round(value);
-  }
 }
 
 class BOOLEAN extends DataType {
@@ -442,11 +416,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 +431,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,7 @@
 'use strict';
 
 const SqlString = require('sqlstring');
+const debug = require('debug')('leoric');
 
 const Logger = require('./logger');
 const Attribute = require('./attribute');
@@ -54,6 +55,14 @@ class AbstractDriver {
     throw new Error('unimplemented!');
   }
 
+  /**
+   * disconnect manually
+   * @param {Function} callback 
+   */
+  async disconnect(callback) {
+    debug('[disconnect] called');
+  }
+
   get dialect() {
     return camelCase(this.constructor.name.replace('Driver', ''));
   }

package/src/drivers/mysql/index.js

@@ -94,20 +94,21 @@ class MysqlDriver extends AbstractDriver {
       });
     });
     const sql = logger.format(query, values, opts);
+    const logOpts = { ...opts, query };
     const start = performance.now();
     let result;
 
     try {
       result = await promise;
     } catch (err) {
-      logger.logQueryError(err, sql, calculateDuration(start), opts);
+      logger.logQueryError(err, sql, calculateDuration(start), logOpts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();
     }
 
     const [ results, fields ] = result;
-    logger.tryLogQuery(sql, calculateDuration(start), opts, results);
+    logger.tryLogQuery(sql, calculateDuration(start), logOpts, results);
     if (fields) return { rows: results, fields };
     return results;
   }

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

@@ -51,6 +51,7 @@ class PostgresDriver extends AbstractDriver {
     const command = sql.slice(0, sql.indexOf(' ')).toLowerCase();
 
     async function tryQuery(...args) {
+      const logOpts = { ...spell, query: sql };
       const formatted = logger.format(sql, values, spell);
       const start = performance.now();
       let result;
@@ -58,13 +59,13 @@ class PostgresDriver extends AbstractDriver {
       try {
         result = await connection.query(...args);
       } catch (err) {
-        logger.logQueryError(err, formatted, calculateDuration(start), spell);
+        logger.logQueryError(err, formatted, calculateDuration(start), logOpts);
         throw err;
       } finally {
         if (!spell.connection) connection.release();
       }
 
-      logger.tryLogQuery(formatted, calculateDuration(start), spell, result);
+      logger.tryLogQuery(formatted, calculateDuration(start), logOpts, result);
       return result;
     }
 

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

@@ -53,6 +53,7 @@ class SqliteDriver extends AbstractDriver {
     }
 
     const { logger } = this;
+    const logOpts = { ...opts, query };
     const sql = logger.format(query, values, opts);
     const start = performance.now();
     let result;
@@ -60,13 +61,13 @@ class SqliteDriver extends AbstractDriver {
     try {
       result = await connection.query(query, values, opts);
     } catch (err) {
-      logger.logQueryError(err, sql, calculateDuration(start), opts);
+      logger.logQueryError(err, sql, calculateDuration(start), logOpts);
       throw err;
     } finally {
       if (!opts.connection) connection.release();
     }
 
-    logger.tryLogQuery(sql, calculateDuration(start), opts, result);
+    logger.tryLogQuery(sql, calculateDuration(start), logOpts, result);
     return result;
   }
 

package/src/realm.js

@@ -160,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/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 {