leoric 2.6.3 → 2.7.2

package/src/decorators.ts

@@ -1,17 +1,16 @@
-import Bone from './bone';
-import DataType from './data_types';
-import { ASSOCIATE_METADATA_MAP } from './constants';
 import 'reflect-metadata';
 
-type DataTypes<T> = {
-  [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property];
-}
+import Bone from './bone';
+import DataTypes, { DataType, DATA_TYPE } from './data_types';
+import { ASSOCIATE_METADATA_MAP } from './constants';
+import { ColumnBase, Validator, AssociateOptions } from './types/common';
 
-interface ColumnOption {
-  type?: DataTypes<DataType>;
+interface ColumnOption extends Omit<ColumnBase, 'columnName'| 'columnType'> {
+  type?: DataType;
   name?: string;
-  defaultValue?: null | boolean | number | string | Date | JSON;
-  allowNull?: boolean;
+  validate?: {
+    [key: string]: Validator;
+  }
 }
 
 function findType(tsType) {
@@ -20,7 +19,7 @@ function findType(tsType) {
     DATE,
     STRING,
     BOOLEAN,
-  } = DataType;
+  } = DataTypes;
 
   switch (tsType) {
     case BigInt:
@@ -38,9 +37,13 @@ function findType(tsType) {
   }
 }
 
-export function Column(options: ColumnOption | DataTypes<DataType> = {}) {
+export function Column(options?: ColumnOption | DATA_TYPE<DataType>) {
   return function(target: Bone, propertyKey: string) {
-    if (options['prototype'] instanceof DataType) options = { type: options };
+    if (options == null) {
+      options = {};
+    }
+    // target refers to model prototype, an internal instance of `Bone {}`
+    if (options['prototype'] instanceof DataType) options = { type: options as DATA_TYPE<DataType> };
 
     if (!('type' in options)) {
       const tsType = Reflect.getMetadata('design:type', target, propertyKey);
@@ -58,11 +61,6 @@ export function Column(options: ColumnOption | DataTypes<DataType> = {}) {
   };
 }
 
-interface AssociateOptions {
-  className?: string;
-  foreignKey?: string;
-}
-
 const { hasMany, hasOne, belongsTo } = ASSOCIATE_METADATA_MAP;
 
 export function HasMany(options?: AssociateOptions) {

package/src/drivers/abstract/attribute.js

@@ -73,10 +73,12 @@ function createType(DataTypes, params) {
     case 'MEDIUMINT':
     case 'INTEGER':
     case 'BIGINT':
+      return new DataType(type.dataLength, type.unsigned, type.zerofill);
     case 'BINARY':
     case 'VARBINARY':
     case 'CHAR':
     case 'VARCHAR':
+    case 'STRING':
       return new DataType(type.dataLength);
     default:
       return new DataType();

package/src/drivers/abstract/index.js

@@ -36,8 +36,8 @@ class AbstractDriver {
 
   /**
    * query with spell
-   * @param {Spell} spell 
-   * @returns 
+   * @param {Spell} spell
+   * @returns
    */
   async cast(spell) {
     const { sql, values } = this.format(spell);
@@ -47,9 +47,9 @@ class AbstractDriver {
 
   /**
    * raw query
-   * @param {object|string} query 
-   * @param {object | array} values 
-   * @param {object} opts 
+   * @param {object|string} query
+   * @param {object | array} values
+   * @param {object} opts
    */
   async query(query, values, opts) {
     throw new Error('unimplemented!');
@@ -57,7 +57,7 @@ class AbstractDriver {
 
   /**
    * disconnect manually
-   * @param {Function} callback 
+   * @param {Function} callback
    */
   async disconnect(callback) {
     debug('[disconnect] called');
@@ -69,8 +69,8 @@ class AbstractDriver {
 
   /**
    * use spellbook to format spell
-   * @param {Spell} spell 
-   * @returns 
+   * @param {Spell} spell
+   * @returns
    */
   format(spell) {
     return this.spellbook.format(spell);

package/src/drivers/abstract/spellbook.js

@@ -163,11 +163,11 @@ class SpellBook {
     const { shardingKey } = Model;
     const { createdAt } = Model.timestamps;
     const { escapeId } = Model.driver;
-    let columns = [];
-    let updateOnDuplicateColumns = [];
+    const columns = [];
+    const updateOnDuplicateColumns = [];
 
-    let values = [];
-    let placeholders = [];
+    const values = [];
+    const placeholders = [];
     if (Array.isArray(sets)) {
       // merge records to get the big picture of involved columnAttributes
       const involved = sets.reduce((result, entry) => {
@@ -318,7 +318,7 @@ class SpellBook {
       spell.updateOnDuplicate = true;
     }
 
-    let { sql, values } = this.formatInsert(spell);
+    const { sql, values } = this.formatInsert(spell);
     return {
       sql,
       values,
@@ -347,7 +347,7 @@ class SpellBook {
    * @param {Array} columns columns for value set
    */
   formatUpdateOnDuplicate(spell, columns) {
-    const { updateOnDuplicate, uniqueKeys, Model } = spell;
+    const { updateOnDuplicate, uniqueKeys, Model, sets } = spell;
     if (!updateOnDuplicate) return '';
     const { columnAttributes, primaryColumn } = Model;
     const { escapeId } = Model.driver;
@@ -358,25 +358,27 @@ class SpellBook {
         actualUniqueKeys.push(escapeId(field));
       }
     } else {
+      const setFields = Object.keys(sets);
       // conflict_target must be unique
       // get all unique keys
       if (columnAttributes) {
         for (const key in columnAttributes) {
           const att = columnAttributes[key];
           // use the first unique key
-          if (att.unique) {
+          if (att.unique || (att.primaryKey && setFields.includes(att.name))) {
             actualUniqueKeys.push(escapeId(att.columnName));
             break;
           }
         }
       }
+
       if (!actualUniqueKeys.length) actualUniqueKeys.push(escapeId(primaryColumn));
       // default use id as primary key
       if (!actualUniqueKeys.length) actualUniqueKeys.push(escapeId('id'));
     }
 
     if (Array.isArray(updateOnDuplicate) && updateOnDuplicate.length) {
-      columns = updateOnDuplicate.map(column => (columnAttributes[column] && columnAttributes[column].columnName )|| column);
+      columns = updateOnDuplicate.map(column => (columnAttributes[column] && columnAttributes[column].columnName)|| column);
     } else if (!columns.length) {
       columns = Object.values(columnAttributes).map(({ columnName }) => columnName);
     }

package/src/drivers/mysql/attribute.js

@@ -21,6 +21,7 @@ class MysqlAttribute extends Attribute {
       allowNull, defaultValue,
       primaryKey,
       comment,
+      unique,
     } = this;
 
     const chunks = [
@@ -34,6 +35,10 @@ class MysqlAttribute extends Attribute {
 
     if (!primaryKey && !allowNull) chunks.push('NOT NULL');
 
+    if (unique === true) {
+      chunks.push('UNIQUE');
+    }
+
     if (defaultValue != null) {
       chunks.push(`DEFAULT ${escape(defaultValue)}`);
     }

package/src/drivers/mysql/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { default: DataTypes } = require('../../data_types');
 
 class Mysql_BOOLEAN extends DataTypes.BOOLEAN {
   constructor() {

package/src/drivers/mysql/index.js

@@ -18,7 +18,6 @@ class MysqlDriver extends AbstractDriver {
 
   /**
    * Create a connection pool
-   * @param {string} clientName
    * @param {Object} opts
    * @param {string} opts.host
    * @param {string} opts.port
@@ -30,6 +29,7 @@ class MysqlDriver extends AbstractDriver {
    * @param {number} opts.connectTimeout  - The milliseconds before a timeout occurs during the initial connection to the MySQL server. (Default: `10000`)
    * @param {string} opts.charset
    * @param {boolean} opts.stringifyObjects  - stringify object value in dataValues
+   * @param {string} opts.client
    */
   constructor(opts = {}) {
     super(opts);
@@ -54,7 +54,7 @@ class MysqlDriver extends AbstractDriver {
     } = opts;
 
     if (client !== 'mysql' && client !== 'mysql2') {
-      throw new Error(`Unsupported mysql client ${client}`);
+      console.warn(`[leoric] mysql client "${client}" not tested`);
     }
 
     return require(client).createPool({

package/src/drivers/postgres/attribute.js

@@ -15,7 +15,7 @@ class PostgresAttribute extends Attribute {
 
   toSqlString() {
     const {
-      columnName, type, columnType, allowNull, defaultValue, primaryKey,
+      columnName, type, columnType, allowNull, defaultValue, primaryKey, unique,
     } = this;
     const chunks = [
       escapeId(columnName),
@@ -29,6 +29,10 @@ class PostgresAttribute extends Attribute {
 
     if (!primaryKey && !allowNull) chunks.push('NOT NULL');
 
+    if (unique === true) {
+      chunks.push('UNIQUE');
+    }
+
     if (defaultValue != null) {
       chunks.push(`DEFAULT ${escape(defaultValue)}`);
     }

package/src/drivers/postgres/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { default: DataTypes } = require('../../data_types');
 const util = require('util');
 const Raw = require('../../raw');
 
@@ -29,7 +29,7 @@ class Postgres_JSONB extends DataTypes.JSONB {
   }
 }
 
-class Postgres_BINARY extends DataTypes {
+class Postgres_BINARY extends DataTypes.BINARY {
   constructor() {
     super();
     this.dataType = 'bytea';
@@ -41,8 +41,8 @@ class Postgres_BINARY extends DataTypes {
 }
 
 class Postgres_INTEGER extends DataTypes.INTEGER {
-  constructor(dataLength) {
-    super(dataLength);
+  constructor(dataLength, unsigned, zerofill) {
+    super(dataLength, unsigned, zerofill);
   }
 
   uncast(value) {
@@ -55,8 +55,8 @@ class Postgres_INTEGER extends DataTypes.INTEGER {
 }
 
 class Postgres_BIGINT extends Postgres_INTEGER {
-  constructor() {
-    super();
+  constructor(dataLength, unsigned, zerofill) {
+    super(dataLength, unsigned, zerofill);
     this.dataType = 'bigint';
   }
 }

package/src/drivers/postgres/index.js

@@ -127,7 +127,8 @@ class PostgresDriver extends AbstractDriver {
     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;
+      const { character_maximum_length: length } = row;
+      let { data_type: dataType } = row;
 
       if (dataType === 'character varying') dataType = 'varchar';
       if (dataType === 'timestamp without time zone') dataType = 'timestamp';

package/src/drivers/sqlite/attribute.js

@@ -14,8 +14,7 @@ class SqliteAttribute extends Attribute {
   }
 
   toSqlString() {
-    const { allowNull, defaultValue, primaryKey } = this;
-    const { columnName, columnType, type } = this;
+    const { columnName, columnType, type, allowNull, defaultValue, primaryKey, unique } = this;
     const chunks = [
       escapeId(columnName),
       columnType.toUpperCase() || type.toSqlString(),
@@ -28,6 +27,10 @@ class SqliteAttribute extends Attribute {
 
     if (!primaryKey && !allowNull) chunks.push('NOT NULL');
 
+    if (unique === true) {
+      chunks.push('UNIQUE');
+    }
+
     if (defaultValue != null) {
       chunks.push(`DEFAULT ${escape(defaultValue)}`);
     }

package/src/drivers/sqlite/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { default: DataTypes } = require('../../data_types');
 
 class Sqlite_DATE extends DataTypes.DATE {
   constructor(precision, timezone) {
@@ -34,8 +34,8 @@ class Sqlite_DATEONLY extends DataTypes.DATEONLY {
 }
 
 class Sqlite_INTEGER extends DataTypes.INTEGER {
-  constructor(dataLength) {
-    super(dataLength);
+  constructor(dataLength, unsigned, zerofill) {
+    super(dataLength, unsigned, zerofill);
   }
 
   uncast(value) {
@@ -44,8 +44,8 @@ class Sqlite_INTEGER extends DataTypes.INTEGER {
 
 }
 class Sqlite_BIGINT extends DataTypes.BIGINT {
-  constructor() {
-    super();
+  constructor(dataLength, unsigned, zerofill) {
+    super(dataLength, unsigned, zerofill);
     this.dataType = 'integer';
   }
 
@@ -53,7 +53,7 @@ class Sqlite_BIGINT extends DataTypes.BIGINT {
     return this.dataType.toUpperCase();
   }
 }
-class Sqlite_BINARY extends DataTypes {
+class Sqlite_BINARY extends DataTypes.BINARY {
   constructor(dataLength = 255) {
     super(dataLength);
     this.dataLength = dataLength;

package/src/realm.js

@@ -102,11 +102,14 @@ const rReplacementKey = /\s:(\w+)\b/g;
 
 class Realm {
   constructor(opts = {}) {
-    let { client, dialect, database, driver: CustomDriver, ...restOpts } = {
-      dialect: 'mysql',
-      database: opts.db || opts.storage,
-      ...opts
-    };
+    const {
+      dialect = 'mysql',
+      dialectModulePath,
+      client = dialectModulePath,
+      database = opts.db || opts.storage,
+      driver: CustomDriver,
+      ...restOpts
+    } = opts;
     const Spine = createSpine(opts);
     const models = {};
 
@@ -214,7 +217,7 @@ class Realm {
     const { rows, ...restRes } = await this.driver.query(query, values, opts);
     const results = [];
 
-    if (rows && rows.length && opts.model && opts.model.prototype instanceof this.Bone) {
+    if (rows && rows.length && opts.model && isBone(opts.model)) {
       const { attributeMap } = opts.model;
 
       for (const data of rows) {

package/src/types/common.d.ts

@@ -0,0 +1,57 @@
+
+export type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
+
+type BaseValidateArgs = boolean | RegExp | Function | Array<Array<Literal>> | string;
+
+export type Validator = BaseValidateArgs | {
+  args: BaseValidateArgs,
+  msg?: string;
+};
+
+export interface ColumnBase {
+  allowNull?: boolean;
+  defaultValue?: Literal;
+  primaryKey?: boolean;
+  comment?: string;
+  unique?: boolean;
+  columnName?: string;
+  columnType?: string;
+  autoIncrement?: boolean;
+}
+
+export interface QueryResult {
+  insertId?: number;
+  affectedRows?: number;
+  rows?: Array<Record<string, Literal>>,
+  fields?: Array<{ table: string, name: string }>,
+}
+
+export interface Connection {
+  /**
+   * MySQL
+   */
+  query(
+    query: string,
+    values: Array<Literal | Literal[]>,
+  ): Promise<QueryResult>;
+}
+
+export interface QueryOptions {
+  validate?: boolean;
+  individualHooks?: boolean;
+  hooks?: boolean;
+  paranoid?: boolean;
+  silent?: boolean;
+  connection?: Connection;
+}
+
+export interface AssociateOptions {
+  className?: string;
+  foreignKey?: string;
+}
+
+export type command = 'select' | 'insert' | 'bulkInsert' | 'update' | 'delete' | 'upsert';
+
+export type ResultSet = {
+  [key: string]: Literal
+};

package/types/data_types.d.ts

@@ -1,105 +0,0 @@
-type LENGTH_VARIANTS = 'tiny' | '' | 'medium' | 'long';
-
-interface INVOKABLE<T> extends DataType {
-  (dataLength?: LENGTH_VARIANTS): T;
-  (dataLength?: number): T;
-}
-
-export default class DataType {
-  toSqlString(): string;
-
-  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';
-  dataLength: number;
-  constructor(dataLength: number);
-}
-
-declare class INTEGER extends DataType {
-  dataType: 'integer' | 'bigint' | 'decimal';
-  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_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';
-  dataLength: LENGTH_VARIANTS;
-  constructor(dataLength: LENGTH_VARIANTS);
-}
-
-declare class BLOB extends DataType {
-  dataType: 'blob';
-  dataLength: LENGTH_VARIANTS;
-  constructor(dataLength: LENGTH_VARIANTS)
-}
-
-declare class JSON extends DataType {
-  dataType: 'text' | 'json';
-}
-
-declare class JSONB extends JSON {
-  dataType: 'json';
-}
-
-declare class BINARY extends DataType {
-  dataType: 'binary';
-  dataLength: number;
-  constructor(dataLength: number);
-}
-
-declare class VARBINARY extends DataType {
-  dataType: 'varbinary';
-  dataLength: number;
-  constructor(dataLength: number);
-}
-
-declare class DATE extends DataType {
-  dataType: 'date';
-  precision: number;
-  timezone: boolean;
-  constructor(precision: number, timezone?: boolean)
-}
-
-declare class DATEONLY extends DataType {
-  dataType: 'dateonly';
-}
-
-declare class BOOLEAN extends DataType {
-  dataType: 'boolean'
-}
-
-declare class VIRTUAL extends DataType {
-  dataType: 'virtual'
-}