leoric 1.9.0 → 1.12.0

package/History.md

@@ -1,3 +1,38 @@
+1.12.0 / 2021-10-12
+===================
+
+  * feat: support custom fields query and sequelize mode export rawAttributes (#192)
+  * refactor: collection format query result (#194)
+  * refactor: object condition parsing and expression formatting (#191)
+
+1.11.1 / 2021-09-28
+===================
+
+This version fixes lots of issues regarding logical operator in object conditions.
+
+  * fix: logical operator with multiple conditions such as (#190)
+  * fix: sequelize mode support HAVING, and select fields raw sql support (#187)
+  * fix: support len validator (#188)
+  * fix: normalize logical operator conditions before formatting with spellbook (#186)
+
+1.11.0 / 2021-09-24
+===================
+
+  * feat: support BINARY(length), VARBINARY(length), and BLOB (#169)
+  * fix: logic operate should adapt one argument (#183)
+  * fix: Bone.load() should be idempotent, make sure associations is intact (#184)
+  * fix: selected instance isNewRecord is false (#182)
+  * fix: set options.busyTimeout to mitigate SQLITE_BUSY (#176)
+  * fix: turn on long stack trace of sqlite driver (#175)
+  * docs: how to contribute (#180)
+
+1.10.0 / 2021-09-14
+===================
+
+  * feat: SQLite driver should emit "connection" event when new connection is created (#168)
+  * fix: bulkCreate(...records) should recognize custom setters (#168)
+  * fix: attribute.equals() check should ignore defaultValue (#172)
+
 1.9.0 / 2021-09-04
 ==================
 
@@ -74,7 +109,7 @@
 ==================
 
   * feat: support class static attributes and hooks (#131)
-  * fix: names defined in Bone.attributes should be always enumerable (#128)
+  * fix: names defined in Bone.attributes should always be enumerable (#128)
   * chore: add quality badge to readme (#129)
 
 1.5.2 / 2021-07-02

package/Readme.md

@@ -4,7 +4,7 @@
 [![NPM Downloads](https://img.shields.io/npm/dm/leoric.svg?style=flat)](https://www.npmjs.com/package/leoric)
 [![NPM Version](http://img.shields.io/npm/v/leoric.svg?style=flat)](https://www.npmjs.com/package/leoric)
 [![Build Status](https://travis-ci.org/cyjake/leoric.svg)](https://travis-ci.org/cyjake/leoric)
-[![Coverage Status](https://coveralls.io/repos/github/cyjake/leoric/badge.svg?branch=master)](https://coveralls.io/github/cyjake/leoric?branch=master)
+[![codecov](https://codecov.io/gh/cyjake/leoric/branch/master/graph/badge.svg?token=OZZWTZTDS1)](https://codecov.io/gh/cyjake/leoric)
 
 Leoric is an object-relational mapping for Node.js, which is heavily influenced by Active Record of Ruby on Rails. See the [documentation](https://leoric.js.org) for detail.
 

package/index.js

@@ -1,18 +1,16 @@
 'use strict';
 
-const fs = require('fs').promises;
-const path = require('path');
 
 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 { findDriver } = require('./src/drivers');
 const migrations = require('./src/migrations');
 const sequelize = require('./src/adapters/sequelize');
-const { camelCase, heresql } = require('./src/utils/string');
+const { heresql } = require('./src/utils/string');
 const Hint = require('./src/hint');
+const Realm = require('./src/realm');
 
 /**
  * @typedef {Object} RawSql
@@ -21,233 +19,6 @@ const Hint = require('./src/hint');
  * @property {string} type
  */
 
-/**
- *
- * @typedef {Object} QueryResult
- * @property {Array} rows
- * @property {Array} fields
- */
-
-/**
- * find models in directory
- * @param {string} dir
- * @returns {Array.<Bone>}
- */
-async function findModels(dir) {
-  if (!dir || typeof dir !== 'string') {
-    throw new Error(`Unexpected dir (${dir})`);
-  }
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const models = [];
-
-  for (const entry of entries) {
-    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);
-    }
-  }
-
-  return models;
-}
-
-function initAttributes(model, columns) {
-  const attributes = {};
-
-  for (const columnInfo of columns) {
-    const { columnName, dataType, defaultValue, ...restInfo } = columnInfo;
-    const name = columnName == '_id' ? columnName : camelCase(columnName);
-    // leave out defaultValue to let database take over the default
-    attributes[name] = {
-      ...restInfo,
-      columnName,
-      dataType,
-      type: model.driver.DataTypes.findType(dataType),
-    };
-  }
-
-  model.init(attributes);
-}
-
-async function loadModels(Spine, models, opts) {
-  const { database } = opts;
-  const tables = models.map(model => model.physicTable);
-  const schemaInfo = await Spine.driver.querySchemaInfo(database, tables);
-
-  for (const model of models) {
-    const columns = schemaInfo[model.physicTable];
-    if (!model.attributes) initAttributes(model, columns);
-    model.load(columns);
-    Spine.models[model.name] = model;
-  }
-
-  for (const model of models) {
-    model.initialize();
-  }
-}
-
-function createSpine(opts) {
-  if (opts.Bone && opts.Bone.prototype instanceof Bone) return opts.Bone;
-  if (opts.sequelize) return sequelize(Bone);
-  if (opts.subclass !== true) return Bone;
-  return class Spine extends Bone {};
-}
-
-const rReplacementKey = /\s:(\w+)\b/g;
-
-class Realm {
-  constructor(opts = {}) {
-    const { client, dialect, database, ...restOpts } = {
-      dialect: 'mysql',
-      database: opts.db || opts.storage,
-      ...opts
-    };
-    const Spine = createSpine(opts);
-    const models = {};
-
-    const driver = new (findDriver(dialect))({
-      client,
-      database,
-      ...restOpts
-    });
-
-    const options = {
-      client,
-      dialect,
-      database,
-      ...restOpts,
-      define: { underscored: true, ...opts.define },
-    };
-
-    this.Bone = Spine;
-    this.models = Spine.models = models;
-    this.driver = Spine.driver = driver;
-    this.options = Spine.options = options;
-  }
-
-  define(name, attributes, opts = {}, descriptors = {}) {
-    const Model = class extends this.Bone {
-      static name = name;
-    };
-    Model.init(attributes, opts, descriptors);
-    this.Bone.models[name] = Model;
-    return Model;
-  }
-
-  async connect() {
-    const { models: dir } = this.options;
-
-    let models;
-    if (dir) {
-      models = Array.isArray(dir) ? dir : (await findModels(dir));
-    } else {
-      models = Object.values(this.models);
-    }
-
-    if (models.length > 0) {
-      await loadModels(this.Bone, models, this.options);
-    }
-    this.connected = true;
-    return this.Bone;
-  }
-
-  async sync() {
-    if (!this.connected) await this.connect();
-    const { models } = this;
-
-    for (const model of Object.values(models)) {
-      await model.sync();
-    }
-  }
-
-  /**
-   * raw query
-   * @param {string} query
-   * @param {Array<any>} values
-   * @param {Connection} opts.connection specific connection of this query, may used in a transaction
-   * @param {Bone} opts.model target model to inject values
-   * @returns {QueryResult}
-   * @memberof Realm
-   */
-  async query(query, values, opts = {}) {
-    if (values && typeof values === 'object' && !Array.isArray(values)) {
-      if ('replacements' in values) {
-        const { model, connection } = values;
-        opts.replacements = values.replacements;
-        if (model) opts.model = model;
-        if (connection) opts.connection = connection;
-      } else {
-        opts.replacements = values;
-      }
-      values = [];
-    }
-
-    const replacements = opts.replacements || {};
-    query = query.replace(rReplacementKey, function replacer(m, key) {
-      if (!replacements.hasOwnProperty(key)) {
-        throw new Error(`unable to replace :${key}`);
-      }
-      values.push(replacements[key]);
-      return '?';
-    });
-
-    const { rows, ...restRes } = await this.driver.query(query, values, opts);
-    const results = [];
-
-    if (rows && rows.length && opts.model && opts.model.prototype instanceof this.Bone) {
-      const { attributeMap } = opts.model;
-
-      for (const data of rows) {
-        const instance = opts.model.instantiate(data);
-        for (const key in data) {
-          if (!attributeMap.hasOwnProperty(key)) instance[key] = data[key];
-        }
-        results.push(instance);
-      }
-    }
-
-    return {
-      rows: results.length > 0 ? results : rows,
-      ...restRes
-    };
-  }
-
-  async transaction(callback) {
-    return await this.Bone.transaction(callback);
-  }
-
-  /**
-   * raw sql object
-   * @static
-   * @param {string} sql
-   * @returns {RawSql}
-   * @memberof Realm
-   */
-  static raw(sql) {
-    if (typeof sql !== 'string') {
-      throw new TypeError('sql must be a string');
-    }
-    return {
-      __raw: true,
-      value: sql,
-      type: 'raw',
-    };
-  }
-
-  // instance.raw
-  raw(sql) {
-    return Realm.raw(sql);
-  }
-  /**
-   * escape value
-   * @param {string} value
-   * @returns {string} escaped value
-   * @memberof Realm
-   */
-  escape(value) {
-    return this.driver.escape(value);
-  }
-}
 
 /**
  * Connect models to database. Need to provide both connect options and models.
@@ -261,7 +32,8 @@ const connect = async function connect(opts) {
   opts = { Bone, ...opts };
   if (opts.Bone.driver) throw new Error('connected already');
   const realm = new Realm(opts);
-  return await realm.connect();
+  await realm.connect();
+  return realm;
 };
 
 Object.assign(Realm.prototype, migrations, { DataTypes });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "1.9.0",
+  "version": "1.12.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -20,6 +20,7 @@
     "test:mysql2": "./test/start.sh test/integration/mysql2.test.js",
     "test:postgres": "./test/start.sh test/integration/postgres.test.js",
     "test:sqlite": "./test/start.sh test/integration/sqlite.test.js",
+    "test:dts": "./test/start.sh test/types/dts.test.js",
     "test:coverage": "nyc ./test/start.sh && nyc report --reporter=lcov",
     "lint": "eslint ./",
     "lint:fix": "eslint . --fix"
@@ -56,6 +57,9 @@
     "@babel/core": "^7.14.6",
     "@babel/eslint-parser": "^7.14.7",
     "@cara/minami": "^1.2.3",
+    "@journeyapps/sqlcipher": "^5.2.0",
+    "@types/node": "^16.10.1",
+    "coffee": "^5.4.0",
     "dayjs": "^1.10.3",
     "eslint": "^7.20.0",
     "expect.js": "^0.3.1",
@@ -66,6 +70,7 @@
     "nyc": "^15.1.0",
     "pg": "^8.5.1",
     "sinon": "^10.0.0",
-    "sqlite3": "^5.0.2"
+    "sqlite3": "^5.0.2",
+    "typescript": "^4.4.3"
   }
 }

package/src/adapters/sequelize.js

@@ -4,14 +4,19 @@ const { setupSingleHook } = require('../setup_hooks');
 const { compose, isPlainObject } = require('../utils');
 
 function translateOptions(spell, options) {
-  const { attributes, where, group, order, offset, limit, include } = options;
+  const { attributes, where, group, order, offset, limit, include, having } = options;
 
   if (attributes) spell.$select(attributes);
   if (include) {
     if (typeof include === 'string') spell.$with(include);
   }
   if (where) spell.$where(where);
-  if (group) spell.$group(group);
+  if (group) {
+    if (Array.isArray(group)) spell.$group(...group);
+    else spell.$group(group);
+  }
+  if (having) spell.$having(having);
+
   if (order) {
     if (typeof order === 'string') {
       spell.$order(order);
@@ -125,6 +130,10 @@ module.exports = Bone => {
       return this;
     }
 
+    static get rawAttributes() {
+      return this.attributes;
+    }
+
     /**
      * add scope see https://sequelize.org/master/class/lib/model.js~Model.html#static-method-addScope
      *

package/src/bone.js

@@ -914,7 +914,7 @@ class Bone {
    */
   static load(columns = []) {
     const { Attribute } = this.driver;
-    const { attributes, options } = this;
+    const { associations = {}, attributes, options } = this;
     const attributeMap = {};
     const table = this.table || snakeCase(pluralize(this.name));
     const tableAlias = camelCase(pluralize(this.name || table));
@@ -943,7 +943,7 @@ class Bone {
       primaryKey,
       columns,
       attributeMap,
-      associations: [],
+      associations,
       tableAlias,
       synchronized: Object.keys(compare(attributes, columns)).length === 0,
     }));
@@ -1147,20 +1147,31 @@ class Bone {
    * @return {Bone}
    */
   static instantiate(row) {
-    const { attributes, driver } = this;
+    const { attributes, driver, attributeMap } = this;
     const instance = new this();
 
-    for (const name in attributes) {
-      const { columnName, jsType } = attributes[name];
-      if (columnName in row) {
+    for (const columnName in row) {
+      const value = row[columnName];
+      if (attributeMap.hasOwnProperty(columnName)) {
+        const { jsType, name } = attributeMap[columnName];
         // to make sure raw and rawSaved hold two different objects
-        instance._setRaw(name, driver.cast(row[columnName], jsType));
-        instance._setRawSaved(name, driver.cast(row[columnName], jsType));
+        instance._setRaw(name, driver.cast(value, jsType));
+        instance._setRawSaved(name, driver.cast(value, jsType));
       } else {
+        if (!isNaN(value)) instance[columnName] = Number(value);
+        else if (!isNaN(Date.parse(value))) instance[columnName] = new Date(value);
+        else instance[columnName] = value;
+      }
+    }
+
+    for (const name in attributes) {
+      const { columnName } = attributes[name];
+      if (!(columnName in row)) {
         instance._getRawUnset().add(name);
       }
     }
 
+    instance.isNewRecord = false;
     return instance;
   }
 
@@ -1313,16 +1324,16 @@ class Bone {
       opts.uniqueKeys = opts.uniqueKeys.map((field) => this.unalias(field));
     }
 
+    // records might change when filter through custom setters
+    records = instances.map(instance => instance.getRaw());
+
     // bulk create with instances is possible only if
     // 1) either all of records primary key are set
     // 2) or none of records priamry key is set and primary key is auto incremented
     if (!(autoIncrement && unset || allset)) {
       // validate first
       if (options.validate !== false) {
-        records.map(record => {
-          if (record instanceof Bone) record._validateAttributes();
-          else this._validateAttributes(record);
-        });
+        for (const record of records) this._validateAttributes(record);
       }
       return await new Spell(this, options).$bulkInsert(records);
     }
@@ -1493,7 +1504,7 @@ class Bone {
 
     const { attributes, columns } = this;
 
-    if (Object.keys(columns).length === 0) {
+    if (columns.length === 0) {
       await driver.createTable(table, attributes);
     } else {
       await driver.alterTable(table, compare(attributes, columns));