leoric 2.7.2 → 2.8.1

package/src/{types/hint.d.ts → hint.d.ts}

@@ -1,5 +1,14 @@
+export interface BaseHintInterface {
+  index: string;
+}
+
+export interface HintInterface extends BaseHintInterface {
+  type?: INDEX_HINT_TYPE;
+  scope?: INDEX_HINT_SCOPE;
+}
+
 export class Hint {
-  static build(hint: Hint | { index: string } | string): typeof Hint;
+  static build(hint: Hint | BaseHintInterface | string): typeof Hint;
 
   constructor(text: string);
 
@@ -36,6 +45,11 @@ export enum INDEX_HINT_SCOPE {
   groupBy = 'group by',
 }
 
+export enum INDEX_HINT_SCOPE_TYPE {
+  join = 'join',
+  orderBy = 'orderBy',
+  groupBy = 'groupBy',
+}
 export class IndexHint {
   /**
    * build index hint
@@ -53,7 +67,7 @@ export class IndexHint {
    *   scope: INDEX_HINT_SCOPE.groupBy,
    * })
    */
-  static build(hint: string | Array<string> | { index: string, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE }, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE): IndexHint;
+  static build(hint: string | Array<string> | HintInterface, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE): IndexHint;
   
   /**
    * Creates an instance of IndexHint.
@@ -64,33 +78,37 @@ export class IndexHint {
    */
   constructor(index: string, type?: INDEX_HINT_TYPE, scope?: INDEX_HINT_SCOPE);
   
-    set index(values: string | Array<string>);
-  
-    get index(): Array<string>;
-  
-    set type(value: string);
-  
-    get type(): string;
-  
-    set scope(value: string);
-  
-    get scope(): string;
-  
-    toSqlString(): string;
-  
-    /**
-     *
-     * @param {IndexHint} hint
-     * @returns {boolean}
-     * @memberof IndexHint
-     */
-    isEqual(hint: IndexHint): boolean;
-  
-    /**
-     * @static
-     * @param {IndexHint} hints
-     * @returns {Array<IndexHint>}
-     * @memberof IndexHint
-     */
-    static merge(hints: Array<IndexHint>): Array<IndexHint>;
+  set index(values: string | Array<string>);
+
+  get index(): Array<string>;
+
+  set type(value: string);
+
+  get type(): string;
+
+  set scope(value: string);
+
+  get scope(): string;
+
+  toSqlString(): string;
+
+  /**
+   *
+   * @param {IndexHint} hint
+   * @returns {boolean}
+   * @memberof IndexHint
+   */
+  isEqual(hint: IndexHint): boolean;
+
+  /**
+   * @static
+   * @param {IndexHint} hints
+   * @returns {Array<IndexHint>}
+   * @memberof IndexHint
+   */
+  static merge(hints: Array<IndexHint>): Array<IndexHint>;
 }
+
+export type CommonHintsArgs = string | HintInterface | Hint | IndexHint | {
+  [key in INDEX_HINT_SCOPE_TYPE]?: string | Array<string> 
+};

package/src/hint.js

@@ -94,7 +94,7 @@ class IndexHint {
 
     if (isPlainObject(hint)) {
       if (hint.index != null) {
-        return new IndexHint(hint.index, hint.type, hint.scope);
+        return new IndexHint(hint.index, hint.type || type, hint.scope || scope);
       }
 
       for (const key in INDEX_HINT_SCOPE) {
@@ -105,6 +105,8 @@ class IndexHint {
       }
     }
 
+    if (hint instanceof IndexHint) return hint;
+
     throw new SyntaxError(format('Unknown index hint %s', hint));
   }
 
@@ -218,4 +220,8 @@ module.exports = {
   IndexHint,
   INDEX_HINT_TYPE,
   INDEX_HINT_SCOPE,
+  INDEX_HINT_SCOPE_TYPE: Object.keys(INDEX_HINT_SCOPE).reduce((result, entry) => {
+    result[entry] = entry;
+    return result;
+  }, {}),
 };

package/src/realm.js

@@ -83,7 +83,6 @@ async function loadModels(Spine, models, opts) {
     const columns = schemaInfo[model.physicTable] || schemaInfo[model.table];
     if (!model.attributes) initAttributes(model, columns);
     model.load(columns);
-    Spine.models[model.name] = model;
   }
 
   for (const model of models) {
@@ -158,8 +157,9 @@ class Realm {
       models = Object.values(this.models);
     }
 
+    for (const model of models) this.Bone.models[model.name] = model;
     // models could be connected already if cached
-    models = models.filter(model => !model.synchronized);
+    models = models.filter(model => model.synchronized == null);
 
     if (models.length > 0) {
       await loadModels(this.Bone, models, this.options);

package/src/spell.d.ts

@@ -0,0 +1,160 @@
+import { 
+  Literal, command, Raw, Connection,
+  ResultSet, QueryResult,
+  QueryOptions, SetOptions, WithOptions,
+  Collection, WhereConditions, OrderOptions,
+} from './types/common';
+import { AbstractBone } from './types/abstract_bone';
+import { Hint, IndexHint, CommonHintsArgs, HintInterface } from './hint';
+
+interface SpellBookFormatStandardResult {
+  sql?: string;
+  values?: Array<Literal> | {
+    [key: string]: Literal
+  };
+  [key: string]: Literal
+}
+
+interface Join {
+  [key: string]: {
+    Model: typeof AbstractBone;
+    on: ExprBinaryOperator
+  }
+}
+
+interface ExprIdentifier {
+  type: 'id';
+  value: string;
+  qualifiers?: string[]
+}
+
+interface ExprFunc {
+  type: 'func';
+  name: string;
+  args: (ExprLiteral | ExprIdentifier)[];
+}
+
+interface ExprLiteral {
+  type: 'literal';
+  value: Literal;
+}
+
+interface ExprBinaryOperator {
+  type: 'op';
+  name: string;
+  args: [ExprIdentifier, ExprLiteral, ExprLiteral];
+}
+
+interface ExprTernaryOperator {
+  type: 'op';
+  name: 'between' | 'not between';
+  args: [ExprIdentifier, ExprLiteral, ExprLiteral];
+}
+
+type ExprOperator = ExprBinaryOperator | ExprTernaryOperator;
+type SpellColumn = ExprIdentifier | Raw;
+
+interface SpellOptions {
+  command?: command;
+  columns: SpellColumn[];
+  table: ExprIdentifier;
+  whereConditions: ExprOperator[];
+  groups: (ExprIdentifier | ExprFunc)[];
+  orders: (ExprIdentifier | ExprFunc)[];
+  havingCondtions: ExprOperator[];
+  joins: Join;
+  skip: number;
+  scopes: Function[];
+  subqueryIndex: number;
+  rowCount?: number;
+  connection?: Connection;
+  sets?: { [key: string]: Literal } | { [key: string]: Literal }[];
+  hints?: Array<Hint | IndexHint>;
+}
+
+export interface SpellMeta extends SpellOptions {
+  Model: typeof AbstractBone;
+}
+
+export type SpellBookFormatResult<T> = SpellBookFormatStandardResult | T;
+
+export class Spellbook {
+
+  format(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+
+  formatInsert(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+  formatSelect(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+  formatUpdate(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+  formatDelete(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+  formatUpsert(spell: SpellMeta): SpellBookFormatResult<SpellBookFormatStandardResult>;
+}
+
+export class Spell<T extends typeof AbstractBone, U = InstanceType<T> | Collection<InstanceType<T>> | ResultSet | number | null> extends Promise<U> {
+  constructor(Model: T, opts: SpellOptions);
+
+  command: string;
+  scopes: Function[];
+
+  select(...names: Array<string | Raw> | Array<(name: string) => boolean>): Spell<T, U>;
+  insert(opts: SetOptions<T>): Spell<T, QueryResult>;
+  update(opts: SetOptions<T>): Spell<T, QueryResult>;
+  upsert(opts: SetOptions<T>): Spell<T, QueryResult>;
+  delete(): Spell<T, QueryResult>;
+
+  from(table: string | Spell<T>): Spell<T, U>;
+
+  with(opts: WithOptions): Spell<T, U>;
+  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>;
+
+  $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: WhereConditions<T>): Spell<T, U>;
+  orWhere(conditions: string, ...values: Literal[]): Spell<T, U>;
+
+  group(...names: Array<string | Raw>): Spell<T, ResultSet>;
+
+  having(conditions: string, ...values: Literal[]): Spell<T, ResultSet>;
+  having(conditions: WhereConditions<T>): Spell<T, ResultSet>;
+
+  orHaving(conditions: string, ...values: Literal[]): Spell<T, ResultSet>;
+  orHaving(conditions: WhereConditions<T>): Spell<T, ResultSet>;
+
+  order(name: string, order?: 'desc' | 'asc'): Spell<T, U>;
+  order(opts: OrderOptions<T>): Spell<T, U>;
+
+  offset(skip: number): Spell<T, U>;
+  limit(skip: number): Spell<T, U>;
+
+  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<T>;
+
+  increment(name: string, by?: number, options?: QueryOptions): Spell<T, QueryResult>;
+  decrement(name: string, by?: number, options?: QueryOptions): Spell<T, QueryResult>;
+
+  toSqlString(): string;
+  toString(): string;
+
+  all: Spell<T, U>;
+  first: Spell<T, InstanceType<T>>;
+  last: Spell<T, InstanceType<T>>;
+  get(index: number): Spell<T, InstanceType<T>>;
+
+  unscoped: Spell<T, U>;
+  unparanoid: Spell<T, U>;
+
+  optimizerHints(...hints: Array<string | HintInterface | Hint | IndexHint>): Spell<T, U>;
+  useIndex(...hints: Array<CommonHintsArgs>): Spell<T, U>;
+  forceIndex(...hints: Array<CommonHintsArgs>): Spell<T, U>;
+  ignoreIndex(...hints: Array<CommonHintsArgs>): Spell<T, U>;
+}

package/src/spell.js

@@ -14,7 +14,7 @@ const Raw = require('./raw');
 const { AGGREGATOR_MAP } = require('./constants');
 
 /**
- * check condition to avoid use virtual fields as where condtions
+ * check condition to avoid use virtual fields as where conditions
  * @param {Bone} Model
  * @param {Array<Object>} conds
  */
@@ -283,7 +283,7 @@ function scopeDeletedAt(spell) {
 scopeDeletedAt.__paranoid = true;
 
 /**
- * Spell is the query builder of Leoric which has several important charactors that made a powerful querying interface possible.
+ * Spell is the query builder of Leoric which has several important characters that made a powerful querying interface possible.
  *
  * - Deferred
  * - Method chaining
@@ -298,10 +298,10 @@ scopeDeletedAt.__paranoid = true;
  *
  *     const query = Post.find('createdAt > ?', new Date(2012, 4, 15));
  *     const [ { count } ] = query.count();
- *     cosnt posts = query.offset(page * pageSize).limit(pageSize);
+ *     const posts = query.offset(page * pageSize).limit(pageSize);
  *     this.body = { count, posts }
  *
- * `query.count()` and `query.offset()` won't interfere with each other because `new Spell` gets returned everytime these methods were called. For brevity, only the methods start with `$` are documented.
+ * `query.count()` and `query.offset()` won't interfere with each other because `new Spell` gets returned every time these methods were called. For brevity, only the methods start with `$` are documented.
  *
  * For performance reason, {@link Bone} use the prefixed with `$` ones mostly.
  * @alias Spell
@@ -743,7 +743,7 @@ class Spell {
   $having(conditions, ...values) {
     const Model = this.Model;
     for (const condition of parseConditions(Model, conditions, ...values)) {
-      // Postgres can't have alias in HAVING caluse
+      // Postgres can't have alias in HAVING clause
       // https://stackoverflow.com/questions/32730296/referring-to-a-select-aggregate-column-alias-in-the-having-clause-in-postgres
       if (Model.driver.type === 'postgres' && !(condition instanceof Raw)) {
         const { value } = condition.args[0];
@@ -844,7 +844,12 @@ class Spell {
    * @memberof Spell
    */
   $useIndex(...hints) {
-    this.hints.push(...hints.map(hint => IndexHint.build(hint, INDEX_HINT_TYPE.use)));
+    this.hints.push(...hints.map((hint) => {
+      if (hint instanceof IndexHint && hint.type !== INDEX_HINT_TYPE.use) {
+        console.warn('Do not recommend set non-use index hint in useIndex');
+      }
+      return IndexHint.build(hint, INDEX_HINT_TYPE.use)
+    }));
     return this;
   }
 
@@ -858,7 +863,12 @@ class Spell {
    * @memberof Spell
    */
   $forceIndex(...hints) {
-    this.hints.push(...hints.map(hint => IndexHint.build(hint, INDEX_HINT_TYPE.force)));
+    this.hints.push(...hints.map((hint) => {
+      if (hint instanceof Hint || (hint instanceof IndexHint && hint.type !== INDEX_HINT_TYPE.force)) {
+        console.warn('Do not recommend set non-force index hint in forceIndex');
+      }
+      return IndexHint.build(hint, INDEX_HINT_TYPE.force);
+    }));
     return this;
   }
 
@@ -872,7 +882,12 @@ class Spell {
    * @memberof Spell
    */
   $ignoreIndex(...hints) {
-    this.hints.push(...hints.map(hint => IndexHint.build(hint, INDEX_HINT_TYPE.ignore)));
+    this.hints.push(...hints.map((hint) => {
+      if (hint instanceof IndexHint && hint.type !== INDEX_HINT_TYPE.ignore) {
+        console.warn('Do not recommend set non-ignore index hint in ignoreIndex');
+      }
+      return IndexHint.build(hint, INDEX_HINT_TYPE.ignore)
+    }));
     return this;
   }
 
@@ -941,7 +956,7 @@ for (const aggregator in AGGREGATOR_MAP) {
   Object.defineProperty(Spell.prototype, `$${aggregator}`, {
     configurable: true,
     writable: true,
-    value: function Spell_aggreator(name = '*') {
+    value: function Spell_aggregator(name = '*') {
       if (name != '*' && parseExpr(name).type != 'id') {
         throw new Error(`unexpected operand ${name} for ${func.toUpperCase()}()`);
       }