leoric 2.6.3 → 2.7.2

package/History.md

@@ -1,3 +1,40 @@
+2.7.2 / 2022-08-24
+==================
+
+## What's Changed
+* Update associations.md by @dxhuii in https://github.com/cyjake/leoric/pull/331
+* refactor: refactor type definitions and fix unique not work in columnOptions by @JimmyDaddy in https://github.com/cyjake/leoric/pull/332
+* fix: declare more exported functions such as isBone and heresql by @cyjake in https://github.com/cyjake/leoric/pull/333
+* fix: INTEGER like data type and STRING extra options didn't work in polymorphism, fix decorators ColumnOptions.type to support invokable by @JimmyDaddy in https://github.com/cyjake/leoric/pull/334
+
+## New Contributors
+* @dxhuii made their first contribution in https://github.com/cyjake/leoric/pull/331
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.7.1...v2.7.2
+
+2.7.1 / 2022-08-24
+==================
+
+## What's Changed
+* fix: projects might have strictPropertyInitialization set to true by @cyjake in https://github.com/cyjake/leoric/pull/329
+* fix: types for validate in `Column` decorator by @vagusX in https://github.com/cyjake/leoric/pull/330
+
+## New Contributors
+* @vagusX made their first contribution in https://github.com/cyjake/leoric/pull/330
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.7.0...v2.7.1
+
+2.7.0 / 2022-08-24
+==================
+
+## What's Changed
+* fix: glue code for opts.dialectModulePath by @cyjake in https://github.com/cyjake/leoric/pull/326
+* fix: primaryKey in upsert values should be validate in sqlite and postgres by @JimmyDaddy in https://github.com/cyjake/leoric/pull/328
+* feat: change DataTypes to ts and complete decorators type definitions by @JimmyDaddy in https://github.com/cyjake/leoric/pull/319
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.6.3...v2.7.0
+
 2.6.3 / 2022-08-04
 ==================
 

package/{types/index.d.ts → index.d.ts}

@@ -1,22 +1,23 @@
-import DataType from './data_types';
-import { Hint, IndexHint } from './hint';
-
-export { DataType as DataTypes };
-export * from '../src/decorators';
-
-export type command = 'select' | 'insert' | 'bulkInsert' | 'update' | 'delete' | 'upsert';
-export type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
+import DataTypes, { DataType, AbstractDataType, LENGTH_VARIANTS } from './src/data_types';
+import { Hint, IndexHint } from './src/types/hint';
+import { 
+  Literal, Validator, ColumnBase,
+  QueryResult, Connection, QueryOptions, 
+  AssociateOptions, command, ResultSet
+} from './src/types/common';
+
+export { 
+  LENGTH_VARIANTS as LENGTH_VARIANTS,
+  DataTypes, Literal, Validator, Connection,
+  Hint, IndexHint,
+};
+export * from './src/decorators';
 
 export class Raw {
   value: string;
   type: 'raw';
 }
 
-
-type DataTypes<T> = {
-  [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property]
-}
-
 type RawQueryResult = typeof Bone | ResultSet | boolean | number;
 
 interface ExprIdentifier {
@@ -145,7 +146,6 @@ export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Insta
   toString(): string;
 }
 
-
 type OperatorCondition = {
   [key in '$eq' | '$ne']?: Literal;
 } & {
@@ -172,65 +172,25 @@ type InstanceValues<T> = {
   [Property in keyof Extract<T, Literal>]?: Extract<T, Literal>[Property]
 }
 
-export interface ColumnMeta {
-  columnName?: string;
-  columnType?: string;
-  allowNull?: boolean;
-  defaultValue?: Literal;
-  primaryKey?: boolean;
-  unique?: boolean;
+export interface ColumnMeta extends ColumnBase {
   dataType?: string;
-  comment?: string;
   datetimePrecision?: string;
 }
 
-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: {
-    [key: string]: validator;
+  toSqlString?: () => string;
+  validate?: {
+    [key: string]: Validator;
   }
 }
 
-interface RelateOptions {
-  className?: string;
-  foreignKey?: string;
-}
-
-interface QueryOptions {
-  validate?: boolean;
-  individualHooks?: boolean;
-  hooks?: boolean;
-  paranoid?: boolean;
-  silent?: boolean;
-  connection?: Connection;
-}
-
 interface TransactionOptions {
   connection: Connection;
 }
 
-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>;
-}
-
 declare class Pool {
   getConnection(): Connection;
 }
@@ -347,14 +307,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
@@ -452,10 +412,6 @@ export class SqliteDriver extends AbstractDriver {
   dialect: 'sqlite';
 }
 
-type ResultSet = {
-  [key: string]: Literal
-};
-
 export class Collection<T extends Bone> extends Array<T> {
   save(): Promise<void>;
   toJSON(): Object[];
@@ -463,7 +419,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 +459,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.
@@ -548,9 +504,9 @@ export class Bone {
   static alias(data: Record<string, Literal>): Record<string, Literal>;
   static unalias(name: string): string;
 
-  static hasOne(name: string, opts?: RelateOptions): void;
-  static hasMany(name: string, opts?: RelateOptions): void;
-  static belongsTo(name: string, opts?: RelateOptions): void;
+  static hasOne(name: string, opts?: AssociateOptions): void;
+  static hasMany(name: string, opts?: AssociateOptions): void;
+  static belongsTo(name: string, opts?: AssociateOptions): void;
 
   /**
    * INSERT rows
@@ -881,7 +837,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 +854,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;
@@ -927,7 +883,21 @@ export default class Realm {
  */
 export function connect(opts: ConnectOptions): Promise<Realm>;
 export function disconnect(realm: Realm, callback?: Function): Promise<boolean | void>;
-export {
-  Hint,
-  IndexHint,
-}
+
+/**
+ * Check if cls is subclass of Bone
+ * @param cls 
+ */
+export function isBone(cls: any): boolean;
+
+/**
+ * Concatenate multiline SQL into oneline
+ * @example
+ * heresql(`
+ *   SELECT *
+ *     FROM users
+ *    WHERE age >= 35
+ * `)
+ * @param text 
+ */
+export function heresql(text): string;

package/index.js

@@ -5,7 +5,7 @@ const Logger = require('./src/drivers/abstract/logger');
 const Spell = require('./src/spell');
 const Bone = require('./src/bone');
 const Collection = require('./src/collection');
-const { invokable: DataTypes } = require('./src/data_types');
+const { invokable: DataTypes, LENGTH_VARIANTS } = require('./src/data_types');
 const migrations = require('./src/migrations');
 const sequelize = require('./src/adapters/sequelize');
 const { heresql } = require('./src/utils/string');
@@ -65,6 +65,7 @@ Object.assign(Realm, {
   SqliteDriver,
   AbstractDriver,
   Raw,
+  LENGTH_VARIANTS,
   isBone,
 });
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "leoric",
-  "version": "2.6.3",
+  "version": "2.7.2",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
-  "types": "types/index.d.ts",
+  "types": "index.d.ts",
   "files": [
-    "index.js",
     "src",
-    "types"
+    "index.js",
+    "index.d.ts"
   ],
   "scripts": {
     "jsdoc": "rm -rf docs/api && jsdoc -c .jsdoc.json -d docs/api -t node_modules/@cara/minami",
@@ -67,6 +67,7 @@
     "@types/node": "^16.10.1",
     "dayjs": "^1.10.3",
     "eslint": "^7.20.0",
+    "eslint-plugin-no-only-tests": "^3.0.0",
     "expect.js": "^0.3.1",
     "jsdoc": "^3.6.3",
     "mocha": "^8.2.1",

package/src/adapters/sequelize.js

@@ -65,7 +65,7 @@ const setScopeToSpell = (scope) => (spell) => {
  * @returns {Object}
  */
 function mergeScope(scopes) {
-  let merged = {};
+  const merged = {};
   for (const scope of scopes) {
     if (scope.where) {
       merged.where = Object.assign({}, merged.where, scope.where);
@@ -227,7 +227,7 @@ module.exports = Bone => {
       }
 
       const { where } = options;
-      let spell = this._find(where, options)[`$${func}`](name);
+      const spell = this._find(where, options)[`$${func}`](name);
       if (options.paranoid === false) return spell.unparanoid;
       return spell;
     }
@@ -262,9 +262,9 @@ module.exports = Bone => {
 
     /**
      * see https://github.com/sequelize/sequelize/blob/a729c4df41fa3a58fbecaf879265d2fb73d80e5f/src/model.js#L2299
-     * @param {Array<Object>} valueSets 
-     * @param {Object} options 
-     * @returns 
+     * @param {Array<Object>} valueSets
+     * @param {Object} options
+     * @returns
      */
     static bulkBuild(valueSets, options = {}) {
       if (!valueSets.length) return [];
@@ -333,7 +333,7 @@ module.exports = Bone => {
     // static drop() {}
 
     static findAll(options = {}) {
-      let spell = this._find({}, filterOptions(options));
+      const spell = this._find({}, filterOptions(options));
       translateOptions(spell, options);
       if (options.paranoid === false) return spell.unparanoid;
       return spell;

package/src/bone.js

@@ -10,7 +10,7 @@ const pluralize = require('pluralize');
 const { executeValidator, LeoricValidateError } = require('./validator');
 require('reflect-metadata');
 
-const DataTypes = require('./data_types');
+const { default: DataTypes } = require('./data_types');
 const Collection = require('./collection');
 const Spell = require('./spell');
 const Raw = require('./raw');
@@ -102,7 +102,7 @@ function valuesValidate(values, attributes, ctx) {
     const value = values[valueKey];
     if (value == null && defaultValue == null) {
       if (allowNull === false) throw new LeoricValidateError('notNull', name);
-      if ((allowNull === true || allowNull === undefined) && validate.notNull === undefined ) continue;
+      if ((allowNull === true || allowNull === undefined) && validate.notNull === undefined) continue;
     }
     if (!validate) continue;
     for (const key in validate) {
@@ -700,7 +700,7 @@ class Bone {
   async _update(values, options = {}) {
     const Model = this.constructor;
     const { attributes, primaryKey, shardingKey } = Model;
-    let changes = {};
+    const changes = {};
     if (values == null) {
       for (const name in attributes) {
         if (this.changed(name)) changes[name] = this.attribute(name);
@@ -728,7 +728,7 @@ class Bone {
     if (attributes[updatedAt] && !changes[updatedAt] && !changes[deletedAt] && !options.silent) {
       changes[updatedAt] = new Date();
     }
-    if (options.validate !== false ) {
+    if (options.validate !== false) {
       this._validateAttributes(changes);
     }
     const spell = new Spell(Model, options).$where(where).$update(changes);
@@ -911,10 +911,9 @@ class Bone {
     const { attributes } = Model;
     for (const key in attributes) {
       const attribute = attributes[key];
-      if (attribute.primaryKey) continue;
       if (values[key] == null && attribute.defaultValue != null) {
         data[key] = attribute.defaultValue;
-      } else if (values[key] !== undefined){
+      } else if (values[key] !== undefined) {
         data[key] = values[key];
       }
     }
@@ -1668,7 +1667,7 @@ class Bone {
       if (force) {
         await driver.dropTable(table);
         await driver.createTable(table, attributes);
-      } else if (alter){
+      } else if (alter) {
         await driver.alterTable(table, compare(attributes, columnMap));
       } else {
         console.warn('[synchronize_fail] %s couldn\'t be synchronized, please use force or alter to specify execution', this.name);