leoric 2.6.2 → 2.7.1

package/src/decorators.ts

@@ -1,17 +1,24 @@
 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;
+type BaseValidateArgs = boolean | RegExp | Function | Array<Array<Literal>> | string;
 
 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]: BaseValidateArgs | {
+      args: BaseValidateArgs;
+      msg: string;
+    };
+  }
 }
 
 function findType(tsType) {
@@ -20,7 +27,7 @@ function findType(tsType) {
     DATE,
     STRING,
     BOOLEAN,
-  } = DataType;
+  } = DataTypes;
 
   switch (tsType) {
     case BigInt:
@@ -38,9 +45,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 { 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);
@@ -50,10 +50,11 @@ class MysqlDriver extends AbstractDriver {
     const {
       host, port, user, password,
       connectTimeout, connectionLimit, charset, stringifyObjects = true,
+      decimalNumbers = true,
     } = 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({
@@ -66,6 +67,7 @@ class MysqlDriver extends AbstractDriver {
       database,
       charset,
       stringifyObjects,
+      decimalNumbers,
     });
   }
 

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

package/src/drivers/postgres/index.js

@@ -5,7 +5,7 @@ const { performance } = require('perf_hooks');
 const AbstractDriver = require('../abstract');
 const Attribute = require('./attribute');
 const DataTypes = require('./data_types');
-const { 
+const {
   escape, escapeId, formatAddColumn,
   formatAlterColumns, formatDropColumn,
   cast, nest, parameterize,
@@ -36,6 +36,9 @@ class PostgresDriver extends AbstractDriver {
 
   createPool(opts) {
     const { host, port, user, password, database } = opts;
+    // dynamic require pg type parse
+    // if not use pg, pg-types may not exits
+    require('./type_parser');
     return new (require('pg')).Pool({ host, port, user, password, database });
   }
 
@@ -124,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/postgres/type_parser.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const pgTypes = require('pg-types');
+
+pgTypes.setTypeParser(1700, 'text', function (val) {
+    return Number(val);
+});

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) {
@@ -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

@@ -6,6 +6,7 @@ const path = require('path');
 const Bone = require('./bone');
 const { findDriver, AbstractDriver } = require('./drivers');
 const { camelCase } = require('./utils/string');
+const { isBone } = require('./utils');
 const sequelize = require('./adapters/sequelize');
 const Raw = require('./raw');
 const { LEGACY_TIMESTAMP_MAP } = require('./constants');
@@ -33,7 +34,7 @@ async function findModels(dir) {
     const extname = path.extname(entry.name);
     if (entry.isFile() && ['.js', '.mjs'].includes(extname)) {
       const model = require(path.join(dir, entry.name));
-      if (model.prototype instanceof Bone) models.push(model);
+      if (isBone(model)) models.push(model);
     }
   }
 
@@ -101,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 = {};
 
@@ -213,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/spell.js

@@ -15,8 +15,8 @@ const { AGGREGATOR_MAP } = require('./constants');
 
 /**
  * check condition to avoid use virtual fields as where condtions
- * @param {Bone} Model 
- * @param {Array<Object>} conds 
+ * @param {Bone} Model
+ * @param {Array<Object>} conds
  */
 function checkCond(Model, conds) {
   if (Array.isArray(conds)) {

package/src/utils/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { performance } = require('perf_hooks');
+const { IS_LEORIC_BONE } = require('../constants');
 
 function isPlainObject(value) {
   return Object.prototype.toString.call(value) === '[object Object]';
@@ -43,10 +44,17 @@ const logger = {};
   };
 });
 
+function isBone(bone) {
+  if (!bone || (typeof bone !== 'object' && typeof bone !== 'function')) return false;
+  const metaValue = Reflect.getMetadata(IS_LEORIC_BONE, bone);
+  return metaValue === true;
+}
+
 module.exports = {
   isPlainObject,
   compose,
   getPropertyNames,
   calculateDuration,
   logger,
+  isBone,
 };

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 {
@@ -160,6 +156,8 @@ type OperatorCondition = {
 
 type WhereConditions<T extends typeof Bone> = {
   [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal | Literal[] | OperatorCondition;
+} | {
+  [key in '$and' | '$or']?: WhereConditions<T>[];
 }
 
 type Values<T extends typeof Bone> = {
@@ -186,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;
   }
 }
@@ -345,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
@@ -461,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
@@ -501,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.
@@ -579,6 +577,7 @@ export class Bone {
    */
   static find<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
   static find<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, primaryKey: number | number[]): Spell<T, Collection<InstanceType<T>>>;
   static find<T extends typeof Bone>(this: T, ): Spell<T, Collection<InstanceType<T>>>;
 
   /**
@@ -601,6 +600,7 @@ export class Bone {
    */
   static findOne<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, InstanceType<T> | null>;
   static findOne<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, primaryKey: number | number[]): Spell<T, InstanceType<T> | null>;
   static findOne<T extends typeof Bone>(this: T, ): Spell<T, InstanceType<T> | null>;
 
   /**
@@ -877,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;
@@ -894,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'
-}