leoric 2.8.4 → 2.8.5

package/History.md

@@ -1,3 +1,13 @@
+2.8.5 / 2022-09-21
+==================
+
+## What's Changed
+* fix: deletedAt should always be checked when associating models by @cyjake in https://github.com/cyjake/leoric/pull/347
+* fix: generic type for getDataValue by @vagusX in https://github.com/cyjake/leoric/pull/346
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.8.4...v2.8.5
+
 2.8.4 / 2022-09-20
 ==================
 

package/index.d.ts

@@ -76,8 +76,8 @@ export default class Realm {
 
   query<T extends typeof Bone>(sql: string, values?: Array<Literal>, options?: RawQueryOptions & { model?: T }): Promise<{ rows: T extends typeof Bone ? InstanceType<T>[] : Object[], fields?: Object[], affectedRows?: number }>;
 
-  transaction<T extends (connection: Connection) => Generator>(callback: T): Promise<GeneratorReturnType<ReturnType<T>>>;
-  transaction<T extends (connection: Connection) => Promise<any>>(callback: T): Promise<ReturnType<T>>;
+  transaction<T extends (options: { connection: Connection }) => Generator>(callback: T): Promise<GeneratorReturnType<ReturnType<T>>>;
+  transaction<T extends (options: { connection: Connection }) => Promise<any>>(callback: T): Promise<ReturnType<T>>;
 
   sync(options?: SyncOptions): Promise<void>;
 }

package/package.json

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

package/src/adapters/sequelize.d.ts

@@ -1,5 +1,5 @@
-import { 
-  Attributes, Literal, OperatorCondition, 
+import {
+  Attributes, Literal, OperatorCondition,
   BoneOptions, ResultSet, Raw,
   SetOptions, BeforeHooksType, AfterHooksType,
   QueryOptions, OrderOptions, QueryResult
@@ -181,8 +181,9 @@ export class SequelizeBone extends AbstractBone {
   where(): { [key: string]:  number | bigint | string };
   set(key: string, value: Literal | Literal[]): void;
   get(key?: string): Literal | { [key: string]: Literal };
-  setDataValue(key: string, value: Literal | Literal[]): void;
-  getDataValue(key?: string): Literal | { [key: string]: Literal };
+  setDataValue<T, Key extends keyof T>(this: T, key: Key, value: T[Key]): void;
+  getDataValue<T>(this: T): T;
+  getDataValue<T, Key extends keyof T>(this: T, key: Key): T[Key];
   previous(key?: string): Literal | Literal[] | { [key: string]: Literal | Literal[] };
   isSoftDeleted(): boolean;
 

package/src/bone.js

@@ -1016,6 +1016,9 @@ class Bone {
       if (columnInfo && attribute.type instanceof DataTypes.DATE && attribute.type.precision == null) {
         attribute.type.precision = columnInfo.datetimePrecision;
       }
+      // if (columnInfo && columnInfo.defaultValue != null && attribute.defaultValue === undefined) {
+      //   attribute.defaultValue = columnInfo.defaultValue;
+      // }
     }
 
     const primaryKey = Object.keys(attributes).find(key => attributes[key].primaryKey);
@@ -1263,10 +1266,8 @@ class Bone {
       throw new Error(`unable to use virtual attribute ${opts.foreignKey} as foreign key in model ${Model.name}`);
     }
 
-    const { deletedAt } = this.timestamps;
-    if (Model.attributes[deletedAt] && !opts.where) {
-      opts.where = { [deletedAt]: null };
-    }
+    const { deletedAt } = Model.timestamps;
+    if (Model.attributes[deletedAt]) opts.where = { [deletedAt]: null, ...opts.where };
     this.associations[name] = { ...opts, Model };
   }
 

package/src/drivers/abstract/attribute.js

@@ -131,7 +131,7 @@ class Attribute {
 
   equals(columnInfo) {
     if (!columnInfo) return false;
-    const props = [ 'allowNull', 'dataType', 'primaryKey' ];
+    const props = [ 'allowNull', 'dataType', 'defaultValue', 'primaryKey' ];
     for (const prop of props) {
       // SQLite has default value as string even if data type is integer
       if (this[prop] != columnInfo[prop]) {

package/src/spell.js

@@ -165,7 +165,11 @@ function joinOnConditions(spell, BaseModel, baseName, refName, { where, associat
   };
   if (!where) where = association.where;
   if (where) {
-    const whereConditions = walkExpr(parseConditions(BaseModel, where)[0], node => {
+    const whereConditions = parseConditions(BaseModel, where).reduce((result, condition) => {
+      if (!result) return condition;
+      return { type: 'op', name: 'and', args: [ result, condition ] };
+    });
+    walkExpr(whereConditions, node => {
       if (node.type == 'id') node.qualifiers = [refName];
     });
     return { type: 'op', name: 'and', args: [ onConditions, whereConditions ] };

package/src/types/abstract_bone.d.ts

@@ -215,8 +215,8 @@ export class AbstractBone {
    *   yield Muscle.create({ boneId: bone.id, bar: 1 })
    * });
    */
-  static transaction<T extends (connection: Connection) => Generator>(callback: T): Promise<GeneratorReturnType<ReturnType<T>>>;
-  static transaction<T extends (connection: Connection) => Promise<any>>(callback: T): Promise<ReturnType<T>>;
+  static transaction<T extends (options: { connection: Connection }) => Generator>(callback: T): Promise<GeneratorReturnType<ReturnType<T>>>;
+  static transaction<T extends (options: { connection: Connection }) => Promise<any>>(callback: T): Promise<ReturnType<T>>;
   
   static describe(): Promise<{[key: string]: any[]}>;
 

package/src/types/common.d.ts

@@ -36,8 +36,14 @@ export interface Connection {
    */
   query(
     query: string,
-    values: Array<Literal | Literal[]>,
+    values?: Array<Literal | Literal[]>,
   ): Promise<QueryResult>;
+
+  query(
+    query: string,
+    values?: Array<Literal | Literal[]>,
+    callback?: (err: Error, result: QueryResult) => void,
+  ): void
 }
 
 export declare class Pool {