leoric 1.13.1 → 1.13.5

package/History.md

@@ -1,3 +1,45 @@
+1.13.5 / 2021-10-26
+===================
+
+## What's Changed
+* docs: enhance aggregation query types & fix raw query result type by @cyjake in https://github.com/cyjake/leoric/pull/208
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.13.4...v1.13.5
+
+1.13.4 / 2021-10-25
+===================
+
+## What's Changed
+* docs: spell & model methods should be generic  by @cyjake in https://github.com/cyjake/leoric/pull/206
+* docs: enhance query options, instance type, and toJSON() result type by @cyjake in https://github.com/cyjake/leoric/pull/207
+
+This version brings correct (and hopefully better) typescript definitions, with the dts checked continuously at test/types tests. With this version, users that have model types correctly pinned at Bone will get code completion including class fields. Such as:
+
+![image](https://user-images.githubusercontent.com/252317/138683240-98ee9e79-4b3e-449c-bc95-a449d457d64f.png)
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.13.3...v1.13.4
+
+1.13.3 / 2021-10-21
+===================
+
+## What's Changed
+* refactor: persist edge cases of type casting in integration tests by @cyjake in https://github.com/cyjake/leoric/pull/202
+* docs: renaming attributes by @cyjake in https://github.com/cyjake/leoric/pull/203
+* fix: JSON.uncast(string) should not serialize twice by @cyjake in https://github.com/cyjake/leoric/pull/205
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.13.2...v1.13.3
+
+1.13.2 / 2021-10-18
+===================
+
+## What's Changed
+* fix: attribute.uncast([]) and realm.connect with synchronized models by @cyjake in https://github.com/cyjake/leoric/pull/201
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v1.13.1...v1.13.2
+
 1.13.1 / 2021-10-18
 ===================
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "1.13.1",
+  "version": "1.13.5",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -20,7 +20,8 @@
     "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:sqlcipher": "./test/start.sh test/integration/sqlcipher.test.js",
+    "test:dts": "./test/start.sh dts",
     "test:coverage": "nyc ./test/start.sh && nyc report --reporter=lcov",
     "lint": "eslint ./",
     "lint:fix": "eslint . --fix"
@@ -58,8 +59,8 @@
     "@babel/eslint-parser": "^7.14.7",
     "@cara/minami": "^1.2.3",
     "@journeyapps/sqlcipher": "^5.2.0",
+    "@types/mocha": "^9.0.0",
     "@types/node": "^16.10.1",
-    "coffee": "^5.4.0",
     "dayjs": "^1.10.3",
     "eslint": "^7.20.0",
     "expect.js": "^0.3.1",
@@ -71,6 +72,6 @@
     "pg": "^8.5.1",
     "sinon": "^10.0.0",
     "sqlite3": "^5.0.2",
-    "typescript": "^4.4.3"
+    "typescript": "^4.4.4"
   }
 }

package/src/adapters/sequelize.js

@@ -154,7 +154,10 @@ module.exports = Bone => {
     }
 
     static scope(name, ...args) {
-      class ScopeClass extends this {};
+      const parentName = this.name;
+      class ScopeClass extends this {
+        static name = parentName;
+      };
       ScopeClass.setScope(name, ...args);
       return ScopeClass;
     }

package/src/bone.js

@@ -820,7 +820,7 @@ class Bone {
    * restore rows
    * @param {Object} conditions query conditions
    * @param {Object?} opts query options
-   * @returns
+   * @returns {Spell}
    */
   static restore(conditions, opts = {}) {
     const { deletedAt } = this.timestamps;

package/src/data_types.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const util = require('util');
 const invokable = require('./utils/invokable');
 
 /**
@@ -66,6 +67,15 @@ class DataType {
     }
   }
 
+  /**
+   * Check if params is instance of DataType or not
+   * @param {*} params
+   * @returns {boolean}
+   */
+  static is(params) {
+    return params instanceof DataType;
+  }
+
   /**
    * cast raw data returned from data packet into js type
    */
@@ -181,7 +191,10 @@ class INTEGER extends DataType {
   }
 
   uncast(value) {
-    if (typeof value === 'string') return parseInt(value, 10);
+    const originValue = value;
+    if (value == null) return value;
+    if (typeof value === 'string') value = parseInt(value, 10);
+    if (isNaN(value)) throw new Error(util.format('invalid integer: %s', originValue));
     return value;
   }
 }
@@ -227,27 +240,31 @@ class DATE extends DataType {
   }
 
   uncast(value) {
+    const originValue = value;
+
     if (value == null) return value;
     if (typeof value.toDate === 'function') {
       value = value.toDate();
     }
 
+    // @deprecated
+    // vaguely standard date formats such as 2021-10-15 15:50:02,548
+    if (typeof value === 'string' && rDateFormat.test(value)) {
+      value = new Date(`${value.replace(' ', 'T').replace(',', '.')}Z`);
+    }
+
+    // 1634611135776
+    // '2021-10-15T08:38:43.877Z'
+    if (!(value instanceof Date)) value = new Date(value);
+    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));
+
     const { precision } = this;
-    if (value instanceof Date && precision < 3) {
+    if (precision < 3) {
       const result = new Date(value);
       result.setMilliseconds(result.getMilliseconds() % (10 ** precision));
       return result;
     }
-
-    if (typeof value === 'string') {
-      // vaguely standard date formats such as 2021-10-15 15:50:02,548
-      if (rDateFormat.test(value)) {
-        return new Date(`${value.replace(' ', 'T').replace(',', '.')}Z`);
-      }
-      // Date.parse('2021-10-15T08:38:43.877Z')
-      return new Date(value);
-    }
-    return value instanceof Date ? value : new Date(value);
+    return value;
   }
 }
 
@@ -261,12 +278,29 @@ class DATEONLY extends DataType {
     return this.dataType.toUpperCase();
   }
 
+  cast(value) {
+    if (value == null) return value;
+    if (value instanceof Date) return value;
+    return new Date(value);
+  }
+
   uncast(value) {
+    const originValue = value;
+
     if (value == null) return value;
     if (typeof value.toDate === 'function') {
       value = value.toDate();
     }
 
+    // @deprecated
+    // vaguely standard date formats such as 2021-10-15 15:50:02,548
+    if (typeof value === 'string' && rDateFormat.test(value)) {
+      value = new Date(`${value.replace(' ', 'T').replace(',', '.')}Z`);
+    }
+
+    if (!(value instanceof Date)) value = new Date(value);
+    if (isNaN(value)) throw new Error(util.format('invalid date: %s', originValue));;
+
     return new Date(value.getFullYear(), value.getMonth(), value.getDate());
   }
 }

package/src/drivers/abstract/attribute.js

@@ -86,7 +86,7 @@ class Attribute {
 
     // { foo: STRING }
     // { foo: STRING(255) }
-    if (typeof params === 'function' || params instanceof DataTypes) {
+    if (typeof params === 'function' || DataTypes.is(params)) {
       params = { type: params };
     }
     const type = createType(DataTypes, params);
@@ -127,7 +127,9 @@ class Attribute {
   }
 
   uncast(value) {
-    if (Array.isArray(value)) return value.map(entry => this.type.uncast(entry));
+    if (Array.isArray(value) && this.jsType !== JSON) {
+      return value.map(entry => this.type.uncast(entry));
+    }
     return this.type.uncast(value);
   }
 }

package/src/drivers/sqlite/index.js

@@ -9,6 +9,7 @@ const { escapeId, escape } = require('./sqlstring');
 const schema = require('./schema');
 const spellbook = require('./spellbook');
 const Pool = require('./pool');
+
 class SqliteDriver extends AbstractDriver {
   constructor(opts = {}) {
     super(opts);

package/src/expr_formatter.js

@@ -197,16 +197,18 @@ function coerceLiteral(spell, ast) {
   const { args } = ast;
   const firstArg = args[0];
 
-  if (firstArg.type === 'id') {
-    const model = findModel(spell, firstArg.qualifiers);
-    const attribute = model && model.attributeMap[firstArg.value];
-
-    if (attribute) {
-      for (const arg of args.slice(1)) {
-        if (arg.type === 'literal') {
-          arg.value = attribute.uncast(arg.value);
-        }
-      }
+  if (firstArg.type !== 'id') return;
+
+  const model = findModel(spell, firstArg.qualifiers);
+  const attribute = model && model.attributes[firstArg.value];
+
+  if (!attribute) return;
+
+  for (const arg of args.slice(1)) {
+    if (arg.type === 'literal') {
+      // { params: { $like: '%foo%' } }
+      if (attribute.jsType === JSON && typeof arg.value === 'string') continue;
+      arg.value = attribute.uncast(arg.value);
     }
   }
 }

package/src/realm.js

@@ -91,6 +91,10 @@ class Realm {
     const Spine = createSpine(opts);
     const models = {};
 
+    if (Array.isArray(opts.models)) {
+      for (const model of opts.models) models[model.name] = model;
+    }
+
     const driver = new (findDriver(dialect))({
       client,
       database,
@@ -130,8 +134,11 @@ class Realm {
       models = Object.values(this.models);
     }
 
+    // models could be connected already if cached
+    models = models.filter(model => !model.synchronized);
+
     if (models.length > 0) {
-      await loadModels(this.Bone, models.filter(model => !model.synchronized), this.options);
+      await loadModels(this.Bone, models, this.options);
     }
     this.connected = true;
     return this.Bone;

package/src/spell.js

@@ -65,7 +65,7 @@ function parseSelect(spell, ...names) {
  * @param {Spell} spell
  * @param {Object} obj - key-value pairs of attributes
  * @param {boolean} strict - check attribute exist or not
- * @returns
+ * @returns {Object}
  */
 function formatValueSet(spell, obj, strict = true) {
   const { Model, silent = false, command } = spell;

package/types/index.d.ts

@@ -44,85 +44,89 @@ interface SpellOptions {
   rowCount: 0;
 }
 
-type SpellFactory = (spell: Spell) => Promise<null | number | Collection<Bone> | ResultSet>;
-
 type OrderOptions = { [name: string]: 'desc' | 'asc' };
 
 type SetOptions = { [key: string]: Literal };
 
 type WithOptions = {
-  [qualifier: string]: { select: string[], throughRelation: string }
+  [qualifier: string]: { select: string | string[], throughRelation?: string }
 }
 
-declare class Spell {
-  constructor(Model: Bone, factory: SpellFactory, opts: SpellOptions);
+declare class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<InstanceType<T>> | ResultSet | number | null> extends Promise<U> {
+  constructor(Model: T, opts: SpellOptions);
 
-  select(...names: string[]): Spell & Promise<Bone>;
-  insert(opts: SetOptions): Spell & Promise<number>;
-  update(opts: SetOptions): Spell & Promise<number>;
-  upsert(opts: SetOptions): Spell & Promise<number>;
-  delete(): Spell & Promise<number>;
+  select(...names: Array<string | RawSql>): Spell<T, U>;
+  insert(opts: SetOptions): Spell<T, number>;
+  update(opts: SetOptions): Spell<T, number>;
+  upsert(opts: SetOptions): Spell<T, number>;
+  delete(): Spell<T, number>;
 
-  from(table: string | Spell): Spell & Promise<Bone>;
+  from(table: string | Spell<T>): Spell<T, U>;
 
-  with(opts: WithOptions): Spell & Promise<Bone>;
-  with(...qualifiers: string[]): Spell & Promise<Bone>;
+  with(opts: WithOptions): Spell<T, U>;
+  with(...qualifiers: string[]): Spell<T, U>;
 
-  join(Model: Bone, onConditions: string, ...values: Literal[]): Spell & Promise<Bone>;
-  join(Model: Bone, onConditions: WhereConditions): Spell & Promise<Bone>;
+  join<V extends typeof Bone>(Model: V, onConditions: string, ...values: Literal[]): Spell<T, U>;
+  join<V extends typeof Bone>(Model: V, onConditions: WhereConditions<T>): Spell<T, U>;
 
-  where(conditions: string, ...values: Literal[]): Spell & Promise<Bone>;
-  where(conditions: WhereConditions): Spell & Promise<Bone>;
+  $where(conditions: WhereConditions<T>): this;
+  $where(conditions: string, ...values: Literal[]): this;
+  where(conditions: WhereConditions<T>): Spell<T, U>;
+  where(conditions: string, ...values: Literal[]): Spell<T, U>;
 
-  orWhere(conditions: string, ...values: Literal[]): Spell & Promise<Bone>;
-  orWhere(conditions: WhereConditions): Spell & Promise<Bone>;
+  orWhere(conditions: WhereConditions<T>): Spell<T, U>;
+  orWhere(conditions: string, ...values: Literal[]): Spell<T, U>;
 
-  group(...names: string[]): Spell & Promise<ResultSet>;
+  group(...names: Array<string | RawSql>): Spell<T, ResultSet>;
 
-  having(conditions: string, ...values: Literal[]): Spell & Promise<ResultSet>;
-  having(conditions: WhereConditions): Spell & Promise<ResultSet>;
+  having(conditions: string, ...values: Literal[]): Spell<T, ResultSet>;
+  having(conditions: WhereConditions<T>): Spell<T, ResultSet>;
 
-  orHaving(conditions: string, ...values: Literal[]): Spell & Promise<ResultSet>;
-  orHaving(conditions: WhereConditions): Spell & Promise<ResultSet>;
+  orHaving(conditions: string, ...values: Literal[]): Spell<T, ResultSet>;
+  orHaving(conditions: WhereConditions<T>): Spell<T, ResultSet>;
 
-  order(name: string, order?: 'desc' | 'asc'): Spell & Promise<Bone>;
-  order(opts: OrderOptions): Spell & Promise<Bone>;
+  order(name: string, order?: 'desc' | 'asc'): Spell<T, U>;
+  order(opts: OrderOptions): Spell<T, U>;
 
-  offset(skip: number): Spell & Promise<Bone>;
-  limit(skip: number): Spell & Promise<Bone>;
+  offset(skip: number): Spell<T, U>;
+  limit(skip: number): Spell<T, U>;
 
-  count(name?: string): Spell & Promise<ResultSet>;
-  average(name?: string): Spell & Promise<ResultSet>;
-  minimum(name?: string): Spell & Promise<ResultSet>;
-  maximum(name?: string): Spell & Promise<ResultSet>;
-  sum(name?: string): Spell & Promise<ResultSet>;
+  count(name?: string): Spell<T, Extract<U, ResultSet | number>>;
+  average(name?: string): Spell<T, Extract<U, ResultSet | number>>;
+  minimum(name?: string): Spell<T, Extract<U, ResultSet | number>>;
+  maximum(name?: string): Spell<T, Extract<U, ResultSet | number>>;
+  sum(name?: string): Spell<T, Extract<U, ResultSet | number>>;
 
-  batch(size?: number): AsyncIterable<Bone>;
+  batch(size?: number): AsyncIterable<T>;
 
   toSqlString(): string;
   toString(): string;
 }
 
-type Literal = null | boolean | number | string | Date | JSON | ArrayBuffer;
+type Literal = null | undefined | boolean | number | string | Date | object | ArrayBuffer;
 
 type OperatorCondition = {
   [key in '$eq' | '$ne']?: Literal;
 } & {
   [key in '$in' | '$nin' | '$notIn']?: Literal[] | Set<Literal>;
 } & {
-  [key in '$like' | '$notLike']?: Literal[];
+  [key in '$like' | '$notLike']?: string;
 } & {
   [key in '$gt' | '$gte' | '$lt' | '$lte']?: number;
 } & {
   [key in '$between' | '$notBetween']?: [number, number] | [Date, Date];
 };
 
-interface WhereConditions {
-  [key: string]: Literal | Literal[] | OperatorCondition;
+type WhereConditions<T extends typeof Bone> = {
+  [Property in keyof T['attributes']]?: Literal | Literal[] | OperatorCondition;
+}
+
+type Values<T extends typeof Bone> = {
+  [Property in keyof T['attributes']]?: Literal;
 }
 
-interface Values {
-  [key: string]: Literal;
+type InstanceValues<T> = {
+  [Property in keyof Extract<T, Literal>]?: Extract<T, Literal>[Property]
 }
 
 declare class DataType {}
@@ -148,10 +152,17 @@ interface RelateOptions {
 }
 
 interface QueryOptions {
-  validate?: boolean,
-  individualHooks?: boolean,
-  hooks?: boolean,
-  paranoid?: boolean,
+  validate?: boolean;
+  individualHooks?: boolean;
+  hooks?: boolean;
+  paranoid?: boolean;
+}
+
+interface QueryResult {
+  insertId?: number;
+  affectedRows?: number;
+  rows?: Array<Record<string, Literal>>,
+  fields?: Array<{ table: string, name: string }>,
 }
 
 interface Connection {
@@ -160,9 +171,8 @@ interface Connection {
    */
   query(
     query: string,
-    values: Array<Literal>,
-    callback: (err: Error|null, results: ResultSet, fields: Array<string>) => void
-  ): void;
+    values: Array<Literal | Literal[]>,
+  ): Promise<QueryResult>;
 }
 
 declare class Pool {
@@ -188,19 +198,19 @@ declare class Driver {
   /**
    * Grab a connection and query the database
    */
-  query(sql: string, values: Array<Literal>): ResultSet;
+  query(sql: string, values?: Array<Literal | Literal[]>): Promise<QueryResult>;
 }
 
-type ResultSet = Values[] | { [qualifier: string]: Values }[]
+type ResultSet = {
+  [key: string]: Literal
+};
 
-declare class Collection<Bone> extends Array<Bone> {
+declare class Collection<T extends Bone> extends Array<T> {
   save(): Promise<void>;
   toJSON(): Object[];
   toObject(): Object[];
 }
 
-type Query = Spell & Promise<Collection<Bone>>;
-
 export class Bone {
   /**
    * The connection pool of the specified client, with few `Leoric_` prefixed methods extended to eliminate client differences.
@@ -218,7 +228,7 @@ export class Bone {
   static model: { [key: string]: Bone };
 
   /**
-   * The table name of current model, which needs to be specified by the model subclass.
+   * The table name of the model, which needs to be specified by the model subclass.
    */
   static table: string;
 
@@ -228,10 +238,15 @@ export class Bone {
   static tableAlias: string;
 
   /**
-   * The primary key of current model, defaults to `id`.
+   * The primary key of the model, defaults to `id`.
    */
   static primaryKey: string;
 
+  /**
+   * The primary column of the table, defaults to `id`. This is {@link Bone.primaryKey} in snake case.
+   */
+  static primaryColumn: string;
+
   /**
    * The attribute definitions of the model.
    */
@@ -260,7 +275,7 @@ export class Bone {
    * @param conditions query conditions
    * @param opts query options
    */
-  static restore(conditions: Object, opts?: QueryOptions): Spell & Promise<number>;
+  static restore<T extends typeof Bone>(this: T, conditions: Object, opts?: QueryOptions): Spell<T, number>;
 
   /**
    * Override attribute metadata
@@ -288,7 +303,7 @@ export class Bone {
    * @example
    * Bone.create({ foo: 1, bar: 'baz' })
    */
-  static create(values: Values, options?: QueryOptions): Promise<Bone>;
+  static create<T extends typeof Bone>(this: T, values: Values<T>, options?: QueryOptions): Promise<InstanceType<T>>;
 
   /**
    * INSERT or UPDATE rows
@@ -297,12 +312,12 @@ export class Bone {
    * @param values values
    * @param opt query options
    */
-  static upsert(values: Object, options?: QueryOptions): Spell & Promise<number>;
+  static upsert<T extends typeof Bone>(this: T, values: Object, options?: QueryOptions): Spell<T, number>;
 
   /**
    * Batch INSERT
    */
-  static bulkCreate(records: Array<Record<string, Literal>>, options?: QueryOptions): Promise<Array<Bone>>;
+  static bulkCreate<T extends typeof Bone>(this: T, records: Array<Record<string, Literal>>, options?: QueryOptions): Promise<Array<InstanceType<T>>>;
 
   /**
    * SELECT rows
@@ -310,21 +325,21 @@ export class Bone {
    * Bone.find('foo = ?', 1)
    * Bone.find({ foo: { $eq: 1 } })
    */
-  static find(whereConditions: string, ...values: Literal[]): Query;
-  static find(whereConditions: WhereConditions): Query;
-  static find(): Query;
+  static find<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, ): Spell<T, Collection<InstanceType<T>>>;
 
   /**
    * SELECT all rows. In production, when the table is at large, it is not recommended to access records in this way. To iterate over all records, {@link Bone.batch} shall be considered as the better alternative. For tables with soft delete enabled, which means they've got `deletedAt` attribute, use {@link Bone.unscoped} to discard the default scope.
    */
-  static all: Query;
+  static all: Spell<typeof Bone, Collection<Bone>>;
 
   /**
    * Discard all the applied scopes.
    * @example
    * Bone.all.unscoped  // includes soft deleted rows
    */
-  static unscoped: Query;
+  static unscoped: Spell<typeof Bone>;
 
   /**
    * SELECT rows LIMIT 1. Besides limiting the results to one rows, the type of the return value is different from {@link Bone.find} too. If no results were found, {@link Bone.findOne} returns null. If results were found, it returns the found record instead of wrapping them as a collection.
@@ -332,9 +347,9 @@ export class Bone {
    * Bone.findOne('foo = ?', 1)
    * Bone.findOne({ foo: { $eq: 1 } })
    */
-  static findOne(whereConditions: string, ...values: Literal[]): Spell & Promise<Bone | null>;
-  static findOne(whereConditions: WhereConditions): Spell & Promise<Bone | null>;
-  static findOne(): Spell & Promise<Bone | null>;
+  static findOne<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, ): Spell<T, InstanceType<T> | null>;
 
   /**
    * SELECT rows OFFSET index LIMIT 1
@@ -342,24 +357,24 @@ export class Bone {
    * Bone.get(8)
    * Bone.find({ foo: { $gt: 1 } }).get(42)
    */
-  static get(index: number): Spell & Promise<Bone | null>;
+  static get<T extends typeof Bone>(this: T, index: number): Spell<T, InstanceType<T> | null>;
 
   /**
    * SELECT rows ORDER BY id ASC LIMIT 1
    */
-  static first: Spell & Promise<Bone | null>;
+  static first: Spell<typeof Bone, Bone | null>;
 
   /**
    * SELECT rows ORDER BY id DESC LIMIT 1
    */
-  static last: Spell & Promise<Bone | null>;
+  static last: Spell<typeof Bone, Bone | null>;
 
   /**
    * Short of `Bone.find().with(...names)`
    * @example
    * Post.include('author', 'comments').where('posts.id = ?', 1)
    */
-  static include(...names: string[]) : Query;
+  static include<T extends typeof Bone>(this: T, ...names: string[]) : Spell<T>;
 
   /**
    * Whitelist SELECT fields by names or filter function
@@ -370,16 +385,16 @@ export class Bone {
    * Bone.select('MONTH(date), foo + 1')
    * Bone.select(name => name !== foo)
    */
-  static select(...names: string[]): Query;
-  static select(filter: (name: string) => boolean): Query;
+  static select<T extends typeof Bone>(this: T, ...names: string[]): Spell<T>;
+  static select<T extends typeof Bone>(this: T, filter: (name: string) => boolean): Spell<T>;
 
   /**
    * JOIN arbitrary models with given ON conditions
    * @example
    * Bone.join(Muscle, 'bones.id == muscles.boneId')
    */
-  static join(Model: Bone, onConditions: string, ...values: Literal[]): Query;
-  static join(Model: Bone, onConditions: WhereConditions): Query;
+  static join<T extends typeof Bone>(this: T, Model: Bone, onConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static join<T extends typeof Bone>(this: T, Model: Bone, onConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
 
   /**
    * Set WHERE conditions
@@ -387,8 +402,8 @@ export class Bone {
    * Bone.where('foo = ?', 1)
    * Bone.where({ foo: { $eq: 1 } })
    */
-  static where(whereConditions: string, ...values: Literal[]): Query;
-  static where(whereConditions: WhereConditions): Query;
+  static where<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static where<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
 
   /**
    * Set GROUP fields
@@ -396,7 +411,7 @@ export class Bone {
    * Bone.group('foo')
    * Bone.group('MONTH(createdAt)')
    */
-  static group(...names: string[]): Spell & Promise<ResultSet>;
+  static group<T extends typeof Bone>(this: T, ...names: string[]): Spell<T, ResultSet>;
 
   /**
    * Set ORDER fields
@@ -405,24 +420,24 @@ export class Bone {
    * Bone.order('foo', 'desc')
    * Bone.order({ foo: 'desc' })
    */
-  static order(name: string, order?: 'desc' | 'asc'): Query;
-  static order(opts: OrderOptions): Query;
+  static order<T extends typeof Bone>(this: T, name: string, order?: 'desc' | 'asc'): Spell<T>;
+  static order<T extends typeof Bone>(this: T, opts: OrderOptions): Spell<T>;
 
-  static count(name?: string): Spell & Promise<ResultSet>;
-  static average(name?: string): Spell & Promise<ResultSet>;
-  static minimum(name?: string): Spell & Promise<ResultSet>;
-  static maximum(name?: string): Spell & Promise<ResultSet>;
-  static sum(name?: string): Spell & Promise<ResultSet>;
+  static count<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static average<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static minimum<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static maximum<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static sum<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
 
   /**
    * UPDATE rows.
    */
-  static update(whereConditions: WhereConditions, values?: Object, opts?: QueryOptions): Spell & Promise<number>;
+  static update<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>, values?: Object, opts?: QueryOptions): Spell<T, number>;
 
   /**
    * Remove rows. If soft delete is applied, an UPDATE query is performed instead of DELETing records directly. Set `forceDelete` to true to force a `DELETE` query.
    */
-  static remove(whereConditions: WhereConditions, forceDelete?: boolean, opt?: QueryOptions): Spell & Promise<number>;
+  static remove<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>, forceDelete?: boolean, opt?: QueryOptions): Spell<T, number>;
 
   /**
    * Grabs a connection and starts a transaction process. Both GeneratorFunction and AsyncFunction are acceptable. If GeneratorFunction is used, the connection of the transaction process will be passed around automatically.
@@ -445,7 +460,7 @@ export class Bone {
    */
   static truncate(): Promise<void>;
 
-  constructor(values: Values);
+  constructor(values: { [key: string]: Literal });
 
   /**
    * Get or set attribute value. Getting the value of unset attribute gives an error.
@@ -511,8 +526,8 @@ export class Bone {
    * bone.remove(true)  // => DELETE FROM ... WHERE ...
    * bone.remove(true, { hooks: false })
    */
-  remove(forceDelete?: boolean): Spell & Promise<number>;
-  remove(forceDelete?: boolean, opts?: QueryOptions): Spell & Promise<number>;
+  remove(forceDelete?: boolean): Promise<number>;
+  remove(forceDelete?: boolean, opts?: QueryOptions): Promise<number>;
 
   /**
    * update or insert record.
@@ -521,31 +536,31 @@ export class Bone {
    * bone.upsert({ hooks: false })
    * @param opts queryOptions
    */
-  upsert(opts?: QueryOptions): Spell & Promise<number>;
+  upsert(opts?: QueryOptions): Promise<number>;
 
   /**
    * update rows
    * @param changes data changes
    * @param opts query options
    */
-  update(changes: Object, opts?: QueryOptions): Spell & Promise<number>;
+  update(changes: Object, opts?: QueryOptions): Promise<number>;
 
   /**
    * create instance
    * @param opts query options
    */
-  create(opts?: QueryOptions): Spell & Promise<Bone>;
+  create(opts?: QueryOptions): Promise<this>;
 
   /**
    * reload instance
    */
-  reload(): Promise<Bone>;
+  reload(): Promise<this>;
 
   /**
    * restore data
    * @param opts query options
    */
-  restore(opts?: QueryOptions): Promise<Bone>;
+  restore(opts?: QueryOptions): Promise<this>;
 
   /**
    * Gets called when `JSON.stringify(instance)` is invoked.
@@ -556,7 +571,7 @@ export class Bone {
    * post.toJSON()  // => { id: 1, ... }
    * @return {Object}
    */
-  toJSON(): Record<string, any>;
+  toJSON(): InstanceValues<this>;
 
   /**
    * This is the loyal twin of {@link Bone#toJSON} because when generating the result object, the raw values of attributes are used, instead of the values returned by custom getters (if any).
@@ -567,7 +582,7 @@ export class Bone {
    * post.toObject()  // => { id: 1, ... }
    * @return {Object}
    */
-  toObject(): Record<string, Literal>;
+  toObject(): InstanceValues<this>;
 }
 
 interface ConnectOptions {
@@ -576,7 +591,7 @@ interface ConnectOptions {
   host?: string;
   user?: string;
   database: string;
-  models?: string | Bone[];
+  models?: string | (typeof Bone)[];
 }
 
 interface InitOptions {
@@ -596,7 +611,7 @@ type RawSql = {
 };
 
 interface RawQueryOptions {
-  replacements?: Values;
+  replacements?: { [key:string]: Literal | Literal[] };
   model: Bone;
   connection: Connection;
 }