leoric 2.9.1 → 2.9.2

package/package.json

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

package/src/adapters/sequelize.d.ts

@@ -8,7 +8,7 @@ import { AbstractBone } from '../types/abstract_bone';
 import { Spell } from '../spell';
 
 type WhereConditions<T extends typeof SequelizeBone> = {
-  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal | Literal[] | OperatorCondition;
+  [Property in BoneColumns<T>]?: Literal | Literal[] | OperatorCondition;
 } | {
   [key in '$and' | '$or']?: WhereConditions<T>[];
 }
@@ -41,9 +41,7 @@ interface SequelizeConditions<T extends typeof SequelizeBone> extends BaseSequel
 }
 
 interface FindOrCreateOptions<T extends typeof SequelizeBone> extends BaseSequelizeConditions<T> {
-  defaults?: {
-    [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal
-  }
+  defaults?: BoneCreateValues<T>;
 }
 
 interface FindOrBuildOptions<T extends typeof SequelizeBone> extends FindOrCreateOptions<T> {
@@ -130,19 +128,19 @@ export class SequelizeBone extends AbstractBone {
    */
   static bulkBuild<T extends typeof SequelizeBone>(this:T, valueSets: Array<BoneCreateValues<T>>, options?: BoneOptions): Array<InstanceType<T>>;
 
+  static count<T extends typeof SequelizeBone>(this: T, conditions?: SequelizeConditions<T>): Spell<T, ResultSet<T> | number>;
   static count<T extends typeof SequelizeBone>(this: T, name?: BoneColumns<T>): Spell<T, ResultSet<T> | number>;
   static count<T extends typeof SequelizeBone>(this: T, name?: Raw | '*'): Spell<T, ResultSet<T> | number>;
-  static count<T extends typeof SequelizeBone>(this: T, conditions?: SequelizeConditions<T>): Spell<T, ResultSet<T> | number>;
 
   static decrement<T extends typeof SequelizeBone>(
     this: T,
-    fields: { [Property in keyof Extract<InstanceType<T>, Literal>]?: number } | string | Array<BoneColumns<T> | string> ,
+    fields: { [Property in BoneColumns<T>]?: number } | string | Array<BoneColumns<T> | string> ,
     options?: SequelizeConditions<T>
   ): Spell<T, QueryResult>;
 
   static increment<T extends typeof SequelizeBone>(
     this: T,
-    fields: { [Property in keyof Extract<InstanceType<T>, Literal>]?: number } | string | Array<BoneColumns<T> | string> ,
+    fields: { [Property in BoneColumns<T>]?: number } | string | Array<BoneColumns<T> | string> ,
     options?: SequelizeConditions<T>
   ): Spell<T, QueryResult>;
 
@@ -161,7 +159,7 @@ export class SequelizeBone extends AbstractBone {
   static findAll<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, Collection<InstanceType<T>>>;
   static find<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, InstanceType<T> | null>;
   static findAndCountAll<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Promise<{
-    rows: Array<typeof SequelizeBone>,
+    rows: Array<InstanceType<T>>,
     count: number,
   }>
 

package/src/collection.js

@@ -98,16 +98,18 @@ function dispatch(spell, rows, fields) {
 
   const results = new Collection();
   for (const row of rows) {
-    const result = {};
-    for (const prop in row) {
+    const result = Object.keys(row).reduce((res, prop) => {
       const data = row[prop];
       const qualifier = prop === table ? tableAlias : prop;
       if (qualifier === '' || qualifier === tableAlias) {
-        Object.assign(result, data);
+        Object.assign(res, data);
       } else {
-        if (Object.values(data).some(value => value != null)) result[prop] = data;
+        if (Object.values(data).some(value => value != null)) {
+          res[prop] = data;
+        }
       }
-    }
+      return res;
+    }, {});
     let current;
     if (joined && result[primaryColumn] != null) {
       current = results.find(r => r[primaryKey] == result[primaryColumn]);

package/src/spell.d.ts

@@ -2,7 +2,7 @@ import {
   Literal, command, Raw, Connection,
   ResultSet, QueryResult,
   QueryOptions, SetOptions, WithOptions,
-  Collection, WhereConditions, OrderOptions, BoneColumns,
+  Collection, WhereConditions, OrderOptions, BoneColumns, OnConditions,
 } from './types/common';
 import { AbstractBone } from './types/abstract_bone';
 import { Hint, IndexHint, CommonHintsArgs, HintInterface } from './hint';
@@ -92,6 +92,9 @@ export class Spellbook {
 export class Spell<T extends typeof AbstractBone, U = InstanceType<T> | Collection<InstanceType<T>> | ResultSet<T> | number | null> extends Promise<U> {
   constructor(Model: T, opts: SpellOptions);
 
+  Model: T;
+  connection: Connection;
+
   command: string;
   scopes: Function[];
 
@@ -107,7 +110,7 @@ export class Spell<T extends typeof AbstractBone, U = InstanceType<T> | Collecti
   with(...qualifiers: string[]): Spell<T, U>;
 
   join<V extends typeof AbstractBone>(Model: V, onConditions: string, ...values: Literal[]): Spell<T, U>;
-  join<V extends typeof AbstractBone>(Model: V, onConditions: WhereConditions<T>): Spell<T, U>;
+  join<V extends typeof AbstractBone>(Model: V, onConditions: OnConditions<T>): Spell<T, U>;
 
   $where(conditions: WhereConditions<T>): this;
   $where(conditions: string, ...values: Literal[]): this;
@@ -165,9 +168,9 @@ export class Spell<T extends typeof AbstractBone, U = InstanceType<T> | Collecti
   toString(): string;
 
   all: Spell<T, U>;
-  first: Spell<T, InstanceType<T>>;
-  last: Spell<T, InstanceType<T>>;
-  get(index: number): Spell<T, InstanceType<T>>;
+  first: Spell<T, InstanceType<T> | null>;
+  last: Spell<T, InstanceType<T> | null>;
+  get(index: number): Spell<T, InstanceType<T> | null>;
 
   unscoped: Spell<T, U>;
   unparanoid: Spell<T, U>;

package/src/types/abstract_bone.d.ts

@@ -3,7 +3,7 @@ import {
   Pool, Literal, WhereConditions,
   Collection, ResultSet, OrderOptions,
   QueryOptions, AttributeMeta, AssociateOptions, Values, Connection, BulkCreateOptions, BoneCreateValues,
-  GeneratorReturnType, BoneColumns, InstanceColumns, Raw,
+  GeneratorReturnType, BoneColumns, InstanceColumns, Raw, OnConditions,
 } from './common';
 import { AbstractDriver } from '../drivers';
 import { Spell } from '../spell';
@@ -110,7 +110,7 @@ export class AbstractBone {
   static renameAttribute<T extends typeof AbstractBone>(this: T, originalName: string, newName: string): void;
 
   static alias<T extends typeof AbstractBone>(this: T, name: BoneColumns<T>): string;
-  static alias<T extends typeof AbstractBone>(this: T, data: Record<BoneColumns<T>, Literal>): Record<string, Literal>;
+  static alias<T extends typeof AbstractBone>(this: T, data: { [key in BoneColumns<T>]: Literal }): Record<string, Literal>;
   static unalias<T extends typeof AbstractBone>(this: T, name: BoneColumns<T>): string;
 
   // after alias/unalias
@@ -127,7 +127,7 @@ export class AbstractBone {
    * @example
    * Bone.create({ foo: 1, bar: 'baz' })
    */
-  static create<T extends typeof AbstractBone>(this: T, values: BoneCreateValues<T> & Partial<Record<BoneColumns<T>, Literal>>, options?: QueryOptions): Promise<InstanceType<T>>;
+  static create<T extends typeof AbstractBone>(this: T, values: BoneCreateValues<T>, options?: QueryOptions): Promise<InstanceType<T>>;
 
   /**
    * INSERT or UPDATE rows
@@ -192,8 +192,8 @@ export class AbstractBone {
    * @example
    * Bone.join(Muscle, 'bones.id == muscles.boneId')
    */
-  static join<T extends typeof AbstractBone>(this: T, Model: AbstractBone, onConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
-  static join<T extends typeof AbstractBone>(this: T, Model: AbstractBone, onConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static join<T extends typeof AbstractBone, U extends typeof AbstractBone>(this: T, Model: U, onConditions: OnConditions<T>): Spell<T, Collection<InstanceType<T>>>;
+  static join<T extends typeof AbstractBone, U extends typeof AbstractBone>(this: T, Model: U, onConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
 
   /**
    * Set WHERE conditions

package/src/types/common.d.ts

@@ -30,6 +30,10 @@ export interface QueryResult {
   fields?: Array<{ table: string, name: string }>,
 }
 
+interface TransactionMethodOptions {
+  Model: typeof AbstractBone;
+}
+
 export interface Connection {
   /**
    * MySQL
@@ -44,6 +48,13 @@ export interface Connection {
     values?: Array<Literal | Literal[]>,
     callback?: (err: Error, result: QueryResult) => void,
   ): void
+
+  begin(opts: TransactionMethodOptions): Promise<void>;
+
+  commit(opts: TransactionMethodOptions): Promise<void>;
+
+  rollback(opts: TransactionMethodOptions): Promise<void>;
+
 }
 
 export declare class Pool {
@@ -65,7 +76,7 @@ export interface QueryOptions {
 }
 
 export type BulkCreateOptions = QueryOptions & {
-  updateOnDuplicate?: string[];
+  updateOnDuplicate?: string[] | true;
   fields?: string[];
 }
 
@@ -147,7 +158,7 @@ export class Raw {
 }
 
 export type SetOptions<T extends typeof AbstractBone> = {
-  [Property in keyof Extract<InstanceType<T>, Literal>]: Literal
+  [Property in BoneColumns<T>]: Literal
 } | { 
   [key: string]: Literal
 };
@@ -156,10 +167,12 @@ export type WithOptions = {
   [qualifier: string]: { select: string | string[], throughRelation?: string }
 }
 
+type OrderSortType = 'desc' | 'asc' | Uppercase<'desc' | 'asc'>;
+
 type OrderOptions<T extends typeof AbstractBone> = {
-  [key in keyof Extract<InstanceType<T>, Literal>]?: 'desc' | 'asc'
-} | [ BoneColumns<T>, 'desc' | 'asc' ] 
-| Array<BoneColumns<T> | [ BoneColumns<T>, 'desc' | 'asc' ] | Raw | string | Array<Raw | string>>
+  [Property in Extract<BoneColumns<T>, Literal>]?: OrderSortType
+} | [ BoneColumns<T>, OrderSortType ] 
+| Array<BoneColumns<T> | [ BoneColumns<T>, OrderSortType ] | Raw | string | Array<Raw | string>>
 | string | Raw;
 
 export class Collection<T extends AbstractBone> extends Array<T> {
@@ -169,7 +182,13 @@ export class Collection<T extends AbstractBone> extends Array<T> {
 }
 
 export type WhereConditions<T extends typeof AbstractBone> = {
-  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal | Literal[] | OperatorCondition;
+  [Property in BoneColumns<T>]?: Literal | Literal[] | OperatorCondition;
+} | {
+  [key in '$and' | '$or']?: WhereConditions<T>[];
+}
+
+export type OnConditions<T extends typeof AbstractBone> = {
+  [Property in BoneColumns<T>]?: Literal | Literal[] | OperatorCondition ;
 } | {
   [key in '$and' | '$or']?: WhereConditions<T>[];
 }