leoric 2.6.3 → 2.7.0

package/src/decorators.ts

@@ -1,17 +1,20 @@
 import Bone from './bone';
-import DataType from './data_types';
+import DataTypes, { DataType, AbstractDataType } 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];
-}
+type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
 
 interface ColumnOption {
-  type?: DataTypes<DataType>;
+  type?: AbstractDataType<DataType>;
   name?: string;
-  defaultValue?: null | boolean | number | string | Date | JSON;
+  defaultValue?: Literal;
   allowNull?: boolean;
+  primaryKey?: boolean;
+  columnName?: string;
+  validate?: {
+    [key: string]: boolean | RegExp | Function | Array<Array<Literal>> | string;
+  }
 }
 
 function findType(tsType) {
@@ -20,7 +23,7 @@ function findType(tsType) {
     DATE,
     STRING,
     BOOLEAN,
-  } = DataType;
+  } = DataTypes;
 
   switch (tsType) {
     case BigInt:
@@ -38,9 +41,13 @@ function findType(tsType) {
   }
 }
 
-export function Column(options: ColumnOption | DataTypes<DataType> = {}) {
+export function Column(options?: ColumnOption | AbstractDataType<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 AbstractDataType<DataType> };
 
     if (!('type' in options)) {
       const tsType = Reflect.getMetadata('design:type', target, propertyKey);

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/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { 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/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { DataTypes } = require('../../data_types');
 const util = require('util');
 const Raw = require('../../raw');
 

package/src/drivers/sqlite/data_types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DataTypes = require('../../data_types');
+const { DataTypes } = require('../../data_types');
 
 class Sqlite_DATE extends DataTypes.DATE {
   constructor(precision, timezone) {

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/types/index.d.ts

@@ -1,7 +1,8 @@
-import DataType from './data_types';
+import DataTypes, { DataType, AbstractDataType, LENGTH_VARIANTS } from '../src/data_types';
 import { Hint, IndexHint } from './hint';
 
-export { DataType as DataTypes };
+export { DataTypes };
+export { LENGTH_VARIANTS as LENGTH_VARIANTS };
 export * from '../src/decorators';
 
 export type command = 'select' | 'insert' | 'bulkInsert' | 'update' | 'delete' | 'upsert';
@@ -12,11 +13,6 @@ export class Raw {
   type: 'raw';
 }
 
-
-type DataTypes<T> = {
-  [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property]
-}
-
 type RawQueryResult = typeof Bone | ResultSet | boolean | number;
 
 interface ExprIdentifier {
@@ -188,10 +184,10 @@ declare type validator = Literal | Function | Array<Literal | Literal[]>;
 
 export interface AttributeMeta extends ColumnMeta {
   jsType?: Literal;
-  type: DataType;
+  type: AbstractDataType<DataType>;
   virtual?: boolean,
-  toSqlString: () => string;
-  validate: {
+  toSqlString?: () => string;
+  validate?: {
     [key: string]: validator;
   }
 }
@@ -347,14 +343,14 @@ declare class AbstractDriver {
    * @param tabe table name
    * @param attributes attributes
    */
-  createTable(tabe: string, attributes: { [key: string]: DataTypes<DataType> | AttributeMeta }): Promise<void>;
+  createTable(tabe: string, attributes: { [key: string]: AbstractDataType<DataType> | AttributeMeta }): Promise<void>;
 
   /**
    * alter table
    * @param tabe table name
    * @param attributes alter attributes
    */
-  alterTable(tabe: string, attributes: { [key: string]: DataTypes<DataType> | AttributeMeta }): Promise<void>;
+  alterTable(tabe: string, attributes: { [key: string]: AbstractDataType<DataType> | AttributeMeta }): Promise<void>;
 
   /**
    * describe table
@@ -463,7 +459,7 @@ export class Collection<T extends Bone> extends Array<T> {
 }
 
 export class Bone {
-  static DataTypes: typeof DataType;
+  static DataTypes: typeof DataTypes;
 
   /**
    * get the connection pool of the driver
@@ -503,7 +499,7 @@ export class Bone {
   /**
    * The attribute definitions of the model.
    */
-  static attributes: { [key: string]: DataTypes<DataType> | AttributeMeta };
+  static attributes: { [key: string]: AbstractDataType<DataType> | AttributeMeta };
 
   /**
    * The schema info of current model.
@@ -881,7 +877,7 @@ interface RawQueryOptions {
 
 export default class Realm {
   Bone: typeof Bone;
-  DataTypes: typeof DataType;
+  DataTypes: typeof DataTypes;
   driver: AbstractDriver;
   models: Record<string, Bone>;
   connected?: boolean;
@@ -898,7 +894,7 @@ export default class Realm {
 
   define(
     name: string,
-    attributes: Record<string, DataTypes<DataType> | AttributeMeta>,
+    attributes: Record<string, AbstractDataType<DataType> | AttributeMeta>,
     options?: InitOptions,
     descriptors?: Record<string, Function>,
   ): typeof Bone;

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'
-}