leoric 2.0.3 → 2.1.1

package/History.md

@@ -1,4 +1,38 @@
-2.0.3 / 2021-02-11
+2.1.1 / 2022-02-23
+==================
+
+## What's Changed
+* fix: fix #274 update with fields option by @JimmyDaddy in https://github.com/cyjake/leoric/pull/275
+* fix:  upsert should set createdAt  by default while createdAt  not set  by @JimmyDaddy in https://github.com/cyjake/leoric/pull/277
+* fix: previousChanges should check instance is new record or not while specific attributes' values were undefined by @JimmyDaddy in https://github.com/cyjake/leoric/pull/276
+* docs: add types for realm by @luckydrq in https://github.com/cyjake/leoric/pull/278
+
+## New Contributors
+* @luckydrq made their first contribution in https://github.com/cyjake/leoric/pull/278
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.1.0...v2.1.1
+
+2.1.0 / 2022-02-17
+==================
+
+## What's Changed
+* feat: fix #270 sequelize mode bulkBuild by @JimmyDaddy in https://github.com/cyjake/leoric/pull/273
+* fix:  mysql delete/remove/destroy with limit and orders by @JimmyDaddy in https://github.com/cyjake/leoric/pull/272
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.0.4...v2.1.0
+
+2.0.4 / 2022-02-16
+==================
+
+## What's Changed
+* fix: fix unit test  error by @LB4027221 in https://github.com/cyjake/leoric/pull/269
+* fix: attribute.defaultValue should be set when init attributes by @cyjake in https://github.com/cyjake/leoric/pull/271
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.0.3...v2.0.4
+
+2.0.3 / 2022-02-11
 ==================
 
 ## What's Changed
@@ -9,7 +43,7 @@
 
 **Full Changelog**: https://github.com/cyjake/leoric/compare/v2.0.2...v2.0.3
 
-2.0.2 / 2021-02-10
+2.0.2 / 2022-02-10
 ==================
 
 ## What's Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "2.0.3",
+  "version": "2.1.1",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",

package/src/adapters/sequelize.js

@@ -257,6 +257,17 @@ module.exports = Bone => {
       return instance;
     }
 
+    /**
+     * see https://github.com/sequelize/sequelize/blob/a729c4df41fa3a58fbecaf879265d2fb73d80e5f/src/model.js#L2299
+     * @param {Array<Object>} valueSets 
+     * @param {Object} options 
+     * @returns 
+     */
+    static bulkBuild(valueSets, options = {}) {
+      if (!valueSets.length) return [];
+      return valueSets.map(value => this.build(value, options));
+    }
+
     // EXISTS
     // static bulkCreate() {}
 
@@ -308,7 +319,9 @@ module.exports = Bone => {
     // proxy to class.destroy({ individualHooks=false }) see https://github.com/sequelize/sequelize/blob/4063c2ab627ad57919d5b45cc7755f077a69fa5e/lib/model.js#L2895  before(after)BulkDestroy
     static async bulkDestroy(options = {}) {
       const { where, force } = options;
-      return await this.remove(where || {}, force, { ...options });
+      const spell = this._remove(where || {}, force, { ...options });
+      translateOptions(spell, options);
+      return spell;
     }
 
     // EXISTS
@@ -495,11 +508,11 @@ module.exports = Bone => {
     // get isNewRecord() {}
 
     async update(values = {}, options = {}) {
-      const { fields } = options;
+      const { fields = [] } = options;
       const changeValues = {};
       const originalValues = Object.assign({}, this.getRaw());
       for (const name in values) {
-        if (values[name] !== undefined && this.hasAttribute(name)) {
+        if (values[name] !== undefined && this.hasAttribute(name) && (!fields.length || fields.includes(name))) {
           // exec custom setters in case it exist
           this[name] = values[name];
           changeValues[name] = this.attribute(name);

package/src/bone.js

@@ -152,7 +152,6 @@ class Bone {
     }
   }
 
-
   /**
    * Get or set attribute value by name. This method is quite similiar to `jQuery.attr()`. If the attribute isn't selected when queried from database, an error will be thrown when accessing it.
    *
@@ -184,7 +183,6 @@ class Bone {
     }
 
     if (args.length > 1) {
-      // execute validators
       this.#raw[name] = value instanceof Raw ? value : attribute.cast(value);
       this.#rawUnset.delete(name);
       return this;
@@ -620,9 +618,10 @@ class Bone {
   async update(values, options = {}) {
     const changes = {};
     const originalValues = Object.assign({}, this.#raw);
+    const { fields = [] } = options;
     if (typeof values === 'object') {
       for (const name in values) {
-        if (values[name] !== undefined && this.hasAttribute(name)) {
+        if (values[name] !== undefined && this.hasAttribute(name) && (!fields.length || fields.includes(name))) {
           // exec custom setters in case it exist
           this[name] = values[name];
           changes[name] = this.attribute(name);
@@ -790,7 +789,7 @@ class Bone {
       }, opts);
       return result;
     }
-    return await Model.remove(condition, forceDelete, { hooks: false, ...opts });
+    return await Model._remove(condition, forceDelete, opts);
   }
 
   /**
@@ -1455,6 +1454,24 @@ class Bone {
    * @return {Spell}
    */
   static remove(conditions, forceDelete = false, options) {
+    return this._remove(conditions, forceDelete, options);
+  }
+
+  /**
+   * private method for internal calling
+   * Remove any record that matches `conditions`.
+   * - If `forceDelete` is true, `DELETE` records from database permanently.
+   * - If not, update `deletedAt` attribute with current date.
+   * - If `forceDelete` isn't true and `deleteAt` isn't around, throw an Error.
+   * @example
+   * Post.remove({ title: 'Leah' })         // mark Post { title: 'Leah' } as deleted
+   * Post.remove({ title: 'Leah' }, true)   // delete Post { title: 'Leah' }
+   * Post.remove({}, true)                  // delete all data of posts
+   * @param {Object}  conditions
+   * @param {boolean} forceDelete
+   * @return {Spell}
+   */
+  static _remove(conditions, forceDelete = false, options) {
     const { deletedAt } = this.timestamps;
     if (forceDelete !== true && this.attributes[deletedAt]) {
       return Bone.update.call(this, conditions, { [deletedAt]: new Date() }, {

package/src/drivers/abstract/attribute.js

@@ -123,7 +123,8 @@ class Attribute {
   }
 
   cast(value) {
-    return this.type.cast(value);
+    const castedValue = this.type.cast(value);
+    return castedValue == null? null : castedValue;
   }
 
   uncast(value, strict = true) {

package/src/drivers/abstract/spellbook.js

@@ -356,15 +356,14 @@ function formatInsert(spell) {
       }
     } else {
       for (const name in involved) {
-        // upsert should not update createdAt
-        if (updateOnDuplicate && createdAt && name === createdAt) continue;
         attributes.push(Model.attributes[name]);
       }
     }
 
     for (const entry of attributes) {
       columns.push(entry.columnName);
-      if (updateOnDuplicate && createdAt && entry.name === createdAt) continue;
+      if (updateOnDuplicate && createdAt && entry.name === createdAt 
+        && !(Array.isArray(updateOnDuplicate) && updateOnDuplicate.includes(createdAt))) continue;
       updateOnDuplicateColumns.push(entry.columnName);
     }
 
@@ -385,7 +384,6 @@ function formatInsert(spell) {
     }
     for (const name in sets) {
       const value = sets[name];
-      // upsert should not update createdAt
       columns.push(Model.unalias(name));
       if (value instanceof Raw) {
         values.push(SqlString.raw(value.value));

package/src/drivers/mysql/spellbook.js

@@ -49,7 +49,10 @@ module.exports = {
     const sets = [];
     // Make sure the correct LAST_INSERT_ID is returned.
     // - https://stackoverflow.com/questions/778534/mysql-on-duplicate-key-last-insert-id
-    sets.push(`${escapeId(primaryColumn)} = LAST_INSERT_ID(${escapeId(primaryColumn)})`);
+    // if insert attributes include primary column, `primaryKey = LAST_INSERT_ID(primaryKey)` is not need any more
+    if (!columns.includes(primaryColumn)) {
+      sets.push(`${escapeId(primaryColumn)} = LAST_INSERT_ID(${escapeId(primaryColumn)})`);
+    }
     sets.push(...columns.map(column => `${escapeId(column)}=VALUES(${escapeId(column)})`));
 
     return `ON DUPLICATE KEY UPDATE ${sets.join(', ')}`;
@@ -75,4 +78,19 @@ module.exports = {
 
     return result;
   },
+  /**
+   * DELETE ... ORDER BY ...LIMIT
+   * @param {Spell} spell 
+   */
+  formatDelete(spell) {
+    const result = spellbook.formatDelete.call(this, spell);
+    const { rowCount, orders } = spell;
+    const chunks = [];
+
+    if (orders.length > 0) chunks.push(`ORDER BY ${this.formatOrders(spell, orders).join(', ')}`);
+    if (rowCount > 0) chunks.push(`LIMIT ${rowCount}`);
+    if (chunks.length > 0) result.sql += ` ${chunks.join(' ')}`;
+
+    return result;
+  }
 };

package/src/drivers/postgres/schema.js

@@ -57,13 +57,18 @@ module.exports = {
 
       if (dataType === 'character varying') dataType = 'varchar';
       if (dataType === 'timestamp without time zone') dataType = 'timestamp';
+
+      let columnDefault = row.column_default;
+      if (/^NULL::/i.test(columnDefault)) columnDefault = null;
+      if (dataType === 'boolean') columnDefault = columnDefault === 'true';
+
       const primaryKey = row.constraint_type === 'PRIMARY KEY';
       const precision = row.datetime_precision;
 
       columns.push({
         columnName: row.column_name,
         columnType: length > 0 ? `${dataType}(${length})` : dataType,
-        defaultValue: primaryKey ? null : row.column_default,
+        defaultValue: primaryKey ? null : columnDefault,
         dataType,
         allowNull: row.is_nullable !== 'NO',
         // https://www.postgresql.org/docs/9.5/infoschema-table-constraints.html

package/src/drivers/sqlite/schema.js

@@ -75,8 +75,9 @@ async function alterTableWithChangeColumn(driver, table, changes) {
 }
 
 // eslint-disable-next-line no-unused-vars
-function parseDefaultValue(text) {
+function parseDefaultValue(text, type) {
   if (typeof text !== 'string') return text;
+  if (type === 'boolean') return text === 'true';
 
   try {
     const ast = parseExpr(text);
@@ -84,7 +85,7 @@ function parseDefaultValue(text) {
       return ast.value;
     }
   } catch (err) {
-    debug('[parseDefaultValue] [%s] %s', text, err.stack);
+    debug('[parseDefaultValue] [%s] %s', text, err);
   }
 
   return text;
@@ -111,10 +112,11 @@ module.exports = {
         const columnType = type.toLowerCase();
         const [, dataType, precision ] = columnType.match(rColumnType);
         const primaryKey = pk === 1;
+
         const result = {
           columnName: name,
           columnType,
-          defaultValue: parseDefaultValue(dflt_value),
+          defaultValue: parseDefaultValue(dflt_value, type),
           dataType: dataType,
           allowNull: primaryKey ? false : notnull == 0,
           primaryKey,

package/src/realm.js

@@ -49,9 +49,8 @@ function initAttributes(model, columns) {
   const attributes = {};
 
   for (const columnInfo of columns) {
-    const { columnName, columnType, defaultValue, ...restInfo } = columnInfo;
+    const { columnName, columnType, ...restInfo } = columnInfo;
     const name = columnName === '_id' ? columnName : camelCase(columnName);
-    // leave out defaultValue to let database take over the default
     attributes[name] = {
       ...restInfo,
       columnName,

package/types/index.d.ts

@@ -593,13 +593,15 @@ export class Bone {
   toObject(): InstanceValues<this>;
 }
 
-interface ConnectOptions {
+export interface ConnectOptions {
   client?: 'mysql' | 'mysql2' | 'pg' | 'sqlite3' | '@journeyapps/sqlcipher';
   dialect?: 'mysql' | 'postgres' | 'sqlite';
   host?: string;
+  port?: number | string;
   user?: string;
   database: string;
   models?: string | (typeof Bone)[];
+  subclass?: boolean;
 }
 
 interface InitOptions {
@@ -612,6 +614,11 @@ interface InitOptions {
   };
 }
 
+interface SyncOptions {
+  force?: boolean;
+  alter?: boolean;
+}
+
 type RawSql = {
   __raw: true,
   value: string,
@@ -626,6 +633,7 @@ interface RawQueryOptions {
 
 export default class Realm {
   Bone: typeof Bone;
+  DataTypes: typeof DataType;
   driver: Driver;
   models: Record<string, Bone>;
 
@@ -633,9 +641,9 @@ export default class Realm {
 
   define(
     name: string,
-    attributes: Record<string, AttributeMeta>,
-    options: InitOptions,
-    descriptors: Record<string, Function>,
+    attributes: Record<string, DataTypes<DataType> | AttributeMeta>,
+    options?: InitOptions,
+    descriptors?: Record<string, Function>,
   ): Bone;
 
   raw(sql: string): RawSql;
@@ -646,6 +654,8 @@ export default class Realm {
 
   transaction(callback: GeneratorFunction): Promise<void>;
   transaction(callback: (connection: Connection) => Promise<void>): Promise<void>;
+
+  sync(options?: SyncOptions): Promise<void>;
 }
 
 /**