leoric 2.7.2 → 2.8.1

package/index.js

@@ -52,6 +52,7 @@ Object.assign(Realm, {
   connect,
   disconnect,
   Bone,
+  SequelizeBone: sequelize(Bone),
   Collection,
   DataTypes,
   Logger,

package/package.json

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

package/src/adapters/sequelize.d.ts

@@ -0,0 +1,190 @@
+import { 
+  Attributes, Literal, OperatorCondition, 
+  BoneOptions, ResultSet, Raw,
+  SetOptions, BeforeHooksType, AfterHooksType,
+  QueryOptions, OrderOptions, QueryResult
+} from '../types/common';
+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;
+} | {
+  [key in '$and' | '$or']?: WhereConditions<T>[];
+}
+
+interface SequelizeDestroyOptions extends QueryOptions {
+  force?: boolean;
+}
+
+interface BaseSequelizeConditions<T extends typeof SequelizeBone> extends QueryOptions {
+  where?: WhereConditions<T>;
+  order?: OrderOptions<T>;
+  limit?: number;
+  attributes?: string | Raw | Array<[keyof Extract<InstanceType<T>, Literal>] | string | Raw> | [keyof Extract<InstanceType<T>, Literal>];
+  offset?: number;
+}
+
+interface SequelizeConditions<T extends typeof SequelizeBone> extends BaseSequelizeConditions<T> {
+  group?: string | string[] | Raw;
+  having?: WhereConditions<T> | string | { [key:string]: Literal | Literal[] } | Raw;
+  include?: string | Raw;
+}
+
+interface FindOrCreateOptions<T extends typeof SequelizeBone> extends BaseSequelizeConditions<T> {
+  defaults?: {
+    [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal
+  }
+}
+
+interface FindOrBuildOptions<T extends typeof SequelizeBone> extends FindOrCreateOptions<T> {
+  raw?: boolean;
+  isNewRecord?: boolean;
+  validate?: boolean;
+}
+
+interface DestroyOptions<T extends typeof SequelizeBone> extends SequelizeConditions<T> {
+  force?: boolean;
+}
+
+type ScopeOptions = {
+  override?: boolean
+}
+
+type Values<T extends typeof SequelizeBone> = {
+  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal;
+}
+
+type aggregators = 'count' | 'COUNT' | 'average' | 'AVERAGE' | 'minimum' | 'MINIMUM' | 'maximum' | 'MAXIMUM' | 'sum' | 'SUM';
+
+export class Collection<T extends SequelizeBone> extends Array<T> {
+  save(): Promise<void>;
+  toJSON(): Object[];
+  toObject(): Object[];
+}
+
+export class SequelizeBone extends AbstractBone {
+
+  static get sequelize(): boolean;
+
+  static get Instance(): SequelizeBone;
+
+  static get rawAttributes(): Attributes;
+
+  static getTableName(): boolean;
+
+  static removeAttribute(name: string): void;
+
+  /**
+   *
+   * @static
+   * @param {string} name before/after create|destroy|upsert|remove|update
+   * @param {string | Function} fnNameOrFun function name or function
+   * @param {Function} func hook function
+   */
+  static addHook(
+    name: BeforeHooksType | AfterHooksType | 'beforeDestroy' | 'afterDestroy' | 'beforeBulkDestroy' | 'afterBulkDestroy' | 'beforeBulkUpdate' | 'afterBulkUpdate',
+    fnNameOrFun: string | Function,
+    func?: Function,
+  ): void;
+
+  /**
+   * add scope see https://sequelize.org/master/class/lib/model.js~Model.html#static-method-addScope
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param scope
+   * @param opts
+   */
+  static addScope<T extends typeof SequelizeBone>(this: T, name: string, scope: ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T>, opts?: ScopeOptions): void;
+
+  /**
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param args
+   */
+  static scope<T extends typeof SequelizeBone>(this: T, name?: (string | ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T> | Array<SequelizeConditions<T>>), ...args: any[]): T;
+
+  static unscoped(): Spell<typeof SequelizeBone>;
+
+  /**
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param args
+   */
+  static setScope<T extends typeof SequelizeBone>(this: T, name: (string | ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T> | Array<SequelizeConditions<T>>), ...args: any[]): void;
+
+  static aggregate<T extends typeof SequelizeBone>(this: T, name: string, func: aggregators, options?: SequelizeConditions<T>): Spell<T, number>;
+
+  static build<T extends typeof SequelizeBone>(this: T, values: Values<T>, options?: BoneOptions): InstanceType<T>;
+
+  /**
+   * see https://github.com/sequelize/sequelize/blob/a729c4df41fa3a58fbecaf879265d2fb73d80e5f/src/model.js#L2299
+   * @param valueSets
+   * @param options
+   */
+  static bulkBuild<T extends typeof SequelizeBone>(this:T, valueSets: Array<Values<T>>, options?: BoneOptions): Array<InstanceType<T>>;
+
+  static count<T extends typeof SequelizeBone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static count<T extends typeof SequelizeBone>(this: T, conditions?: SequelizeConditions<T>): Spell<T, ResultSet | number>;
+
+  static decrement<T extends typeof SequelizeBone>(
+    this: T,
+    fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
+    options?: SequelizeConditions<T>
+  ): Spell<T, QueryResult>;
+
+  static increment<T extends typeof SequelizeBone>(
+    this: T,
+    fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
+    options?: SequelizeConditions<T>
+  ): Spell<T, QueryResult>;
+
+  static max<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+  static min<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+  static sum<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+
+  static destroy<T extends typeof SequelizeBone>(this: T, options?: DestroyOptions<T>): Promise<Array<number> | number>;
+  static bulkDestroy<T extends typeof SequelizeBone>(this: T, options?: DestroyOptions<T>): Spell<T, number>;
+
+  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>,
+    count: number,
+  }>
+
+  static findByPk<T extends typeof SequelizeBone>(this:T, pk: number | bigint | string, options?: Pick<SequelizeConditions<T>, 'paranoid' | 'connection' | 'transaction' |'hint' | 'hints'>): Spell<T, InstanceType<T>>;
+
+  static findOne<T extends typeof SequelizeBone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, InstanceType<T>>;
+  static findOne<T extends typeof SequelizeBone>(this: T, primaryKey: number | number[] | bigint): Spell<T, InstanceType<T>>;
+  static findOne<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, InstanceType<T>>;
+
+  static findCreateFind<T extends typeof SequelizeBone>(this: T, options: FindOrCreateOptions<T>): Promise<InstanceType<T>>;
+  static findOrBuild<T extends typeof SequelizeBone>(this: T, options: FindOrBuildOptions<T>): Promise<[InstanceType<T>, boolean]>;
+  static findOrCreate<T extends typeof SequelizeBone>(this: T, options: FindOrBuildOptions<T>): Promise<[InstanceType<T>, boolean]>;
+
+  static restore<T extends typeof SequelizeBone>(this: T, options: BaseSequelizeConditions<T>): Spell<T, number>;
+
+  static update<T extends typeof SequelizeBone>(this: T, values: SetOptions<T>, options: BaseSequelizeConditions<T>): Promise<number>;
+  static bulkUpdate<T extends typeof SequelizeBone>(this: T, values: SetOptions<T>, options: BaseSequelizeConditions<T>): Spell<T, number>;
+
+  /**
+   * An alias of instance constructor. Some legacy code access model name from instance with `this.Model.name`.
+   */
+  get Model(): typeof SequelizeBone;
+  get dataValues(): { [key: string]: Literal };
+
+  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 };
+  previous(key?: string): Literal | Literal[] | { [key: string]: Literal | Literal[] };
+  isSoftDeleted(): boolean;
+
+  increment(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
+  decrement(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
+  destroy(options?: SequelizeDestroyOptions): Promise<this| number>;
+}
+
+export const sequelize: (Bone: AbstractBone) => typeof SequelizeBone;

package/src/adapters/sequelize.js

@@ -19,7 +19,7 @@ function translateOptions(spell, options) {
   if (having) spell.$having(having);
 
   if (order) {
-    if (typeof order === 'string' || order instanceof Raw) {
+    if (typeof order === 'string' || order instanceof Raw || isPlainObject(order)) {
       spell.$order(order);
     } else if (Array.isArray(order) && order.length) {
       if (order.some(item => Array.isArray(item))) {
@@ -45,15 +45,7 @@ function translateOptions(spell, options) {
 }
 
 const setScopeToSpell = (scope) => (spell) => {
-  if (scope.where) {
-    spell.$where(scope.where);
-  }
-  if (scope.order) {
-    spell.$order(scope.order);
-  }
-  if (scope.limit) {
-    spell.$limit(scope.limit);
-  }
+  translateOptions(spell, scope);
 };
 
 /**
@@ -78,7 +70,7 @@ function mergeScope(scopes) {
     }
   }
   return merged;
-};
+}
 
 /**
  * parse scope
@@ -114,7 +106,7 @@ function filterOptions(options = {}) {
 
 // https://sequelize.org/master/class/lib/model.js~Model.html
 // https://sequelize.org/master/manual/model-querying-finders.html
-module.exports = Bone => {
+module.exports = function sequelize(Bone) {
   return class Spine extends Bone {
 
     /*
@@ -139,7 +131,7 @@ module.exports = Bone => {
 
     /**
      * add scope see https://sequelize.org/master/class/lib/model.js~Model.html#static-method-addScope
-     *
+     * @deprecated scope is not recommended to use
      * @static
      * @param {string} name
      * @param {Object|Function} scope
@@ -156,20 +148,31 @@ module.exports = Bone => {
       }
     }
 
+    /**
+     * @deprecated scope is not recommended to use
+     * @param {string} name
+     * @param  {...any} args
+     * @returns
+     */
     static scope(name, ...args) {
       const parentName = this.name;
       class ScopeClass extends this {
         static name = parentName;
-      };
+      }
       ScopeClass.setScope(name, ...args);
       return ScopeClass;
     }
 
+    static get unscoped() {
+      return this.scope();
+    }
+
     static unscoped() {
       return this.scope();
     }
 
     /**
+     * @deprecated scope is not recommended to use
      * @static
      * @param {function|object|array} name
      */
@@ -274,12 +277,13 @@ module.exports = Bone => {
     // EXISTS
     // static bulkCreate() {}
 
-    static async count(options = {}) {
+    static count(options = {}) {
+      if (typeof options === 'string') return super.find().$count(options);
       const { where, col, group, paranoid } = options;
       let spell = super.find(where, filterOptions(options));
       if (Array.isArray(group)) spell.$group(...group);
       if (paranoid === false) spell = spell.unparanoid;
-      return await spell.$count(col);
+      return spell.$count(col);
     }
 
     // EXISTS
@@ -562,7 +566,7 @@ module.exports = Bone => {
     // EXISTS
     // get isNewRecord() {}
 
-    async decrement(fields, options = {}) {
+    decrement(fields, options = {}) {
       const Model = this.constructor;
       const { primaryKey } = Model;
       if (this[primaryKey] == null) {

package/src/bone.d.ts

@@ -0,0 +1,53 @@
+import { Spell } from './spell';
+import { AbstractBone } from './types/abstract_bone';
+import { Collection, Literal, QueryOptions, ResultSet, WhereConditions } from './types/common';
+
+export default class Bone extends AbstractBone {
+
+  /**
+   * SELECT rows
+   * @example
+   * Bone.find('foo = ?', 1)
+   * Bone.find({ foo: { $eq: 1 } })
+   */
+  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, primaryKey: number | number[] | bigint): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, ): Spell<T, Collection<InstanceType<T>>>;
+
+  /**
+   * 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.
+   * @example
+   * Bone.findOne('foo = ?', 1)
+   * Bone.findOne({ foo: { $eq: 1 } })
+   */
+  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, primaryKey: number | number[] | bigint): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, ): Spell<T, InstanceType<T> | null>;
+
+  static sum<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+
+  /**
+   * restore rows
+   * @example
+   * Bone.restore({ title: 'aaa' })
+   * Bone.restore({ title: 'aaa' }, { hooks: false })
+   * @param conditions query conditions
+   * @param opts query options
+   */
+  static restore<T extends typeof Bone>(this: T, conditions: Object, opts?: QueryOptions): Spell<T, number>;
+
+  /**
+   * UPDATE rows.
+   */
+  static update<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>, values?: Object, opts?: QueryOptions): Spell<T, number>;
+
+  /**
+   * Discard all the applied scopes.
+   * @example
+   * Bone.all.unscoped  // includes soft deleted rows
+   */
+  static unscoped: Spell<typeof Bone>;
+
+}

package/src/bone.js

@@ -1291,8 +1291,8 @@ class Bone {
     }
 
     for (const name in attributes) {
-      const { columnName } = attributes[name];
-      if (!(columnName in row)) {
+      const attribute = attributes[name];
+      if (!(attribute.columnName in row) && !attribute.virtual) {
         instance._getRawUnset().add(name);
       }
     }

package/src/decorators.js.map

@@ -1 +1 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["decorators.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["decorators.ts"],"names":[],"mappings":"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"}

package/src/decorators.ts

@@ -37,7 +37,7 @@ function findType(tsType) {
   }
 }
 
-export function Column(options?: ColumnOption | DATA_TYPE<DataType>) {
+export function Column(options?: ColumnOption | DATA_TYPE<DataType> | DataType) {
   return function(target: Bone, propertyKey: string) {
     if (options == null) {
       options = {};
@@ -54,7 +54,7 @@ export function Column(options?: ColumnOption | DATA_TYPE<DataType>) {
     if (!('type' in options)) throw new Error(`unknown column options ${options}`);
 
     // target refers to model prototype, an internal instance of `Bone {}`
-    const model = target.constructor;
+    const model = target.constructor as any;
     const { attributes = (model.attributes = {}) } = model;
     const { name: columnName, ...restOptions } = options;
     attributes[propertyKey] = { ...restOptions, columnName };

package/src/drivers/index.d.ts

@@ -0,0 +1,188 @@
+import { Spellbook, SpellMeta, Spell } from '../spell';
+import { DataType, AbstractDataType } from '../data_types';
+import { Attribute, Pool, ResultSet, Literal, QueryResult, AttributeMeta, ColumnMeta } from '../types/common';
+import { AbstractBone } from '../types/abstract_bone';
+
+export interface ConnectOptions {
+  client?: 'mysql' | 'mysql2' | 'pg' | 'sqlite3' | '@journeyapps/sqlcipher';
+  dialect?: 'mysql' | 'postgres' | 'sqlite';
+  host?: string;
+  port?: number | string;
+  user?: string;
+  password?: string;
+  database: string;
+  charset?: string;
+  models?: string | (typeof AbstractBone)[];
+  subclass?: boolean;
+  driver?: typeof AbstractDriver;
+}
+
+export class AbstractDriver {
+
+  static Spellbook: typeof Spellbook;
+  static DataType: typeof DataType;
+  static Attribute: typeof Attribute;
+
+  /**
+   * The type of driver, currently there are mysql, sqlite, and postgres
+   */
+  type: string;
+
+  /**
+   * The database current driver is using.
+   */
+  database: string;
+
+  /**
+   * The connection pool of the driver.
+   */
+  pool: Pool;
+
+  /**
+   * The SQL dialect
+   */
+  dialect: string;
+
+  spellbook: Spellbook;
+
+  DataType: DataType;
+
+  Attribute: Attribute;
+
+  constructor(options: ConnectOptions);
+
+  escape: (v: string) => string;
+  escapeId: (v: string) => string;
+
+  /**
+   * Grab a connection and query the database
+   */
+  query(sql: string | { sql: string, nestTables?: boolean}, values?: Array<Literal | Literal[]>, opts?: SpellMeta): Promise<QueryResult>;
+
+  /**
+   * disconnect manually
+   * @param callback
+   */
+  disconnect(callback?: Function): Promise<boolean | void>;
+
+  /**
+   * query with spell
+   * @param spell
+   */
+  cast(spell: Spell<typeof AbstractBone, ResultSet | number | null>): Promise<QueryResult>;
+
+  /**
+   * format spell
+   * @param spell SpellMeta
+   */
+  format(spell: SpellMeta): any;
+
+  /**
+   * create table
+   * @param tabe table name
+   * @param attributes attributes
+   */
+  createTable(tabe: string, attributes: { [key: string]: AbstractDataType<DataType> | AttributeMeta }): Promise<void>;
+
+  /**
+   * alter table
+   * @param tabe table name
+   * @param attributes alter attributes
+   */
+  alterTable(tabe: string, attributes: { [key: string]: AbstractDataType<DataType> | AttributeMeta }): Promise<void>;
+
+  /**
+   * describe table
+   * @param table table name
+   */
+  describeTable(table: string): Promise<{ [key: string]: ColumnMeta }>;
+
+  /**
+   * query table schemas
+   * @param database database name
+   * @param table table name or table name array
+   */
+  querySchemaInfo(database: string, table: string | string[]): Promise<{ [key: string] : { [key: string]: ColumnMeta }[]}>;
+
+  /**
+   * add column to table
+   * @param table table name
+   * @param name column name
+   * @param params column meta info
+   */
+  addColumn(table: string, name: string, params: ColumnMeta): Promise<void>;
+
+  /**
+   * change column meta in table
+   * @param table table name
+   * @param name column name
+   * @param params column meta info
+   */
+  changeColumn(table: string, name: string, params: ColumnMeta): Promise<void>;
+
+  /**
+   * remove column in table
+   * @param table table name
+   * @param name column name
+   */
+  removeColumn(table: string, name: string): Promise<void>;
+
+  /**
+   * rename column in table
+   * @param table table name
+   * @param name column name
+   * @param newName new column name
+   */
+  renameColumn(table: string, name: string, newName: string): Promise<void>;
+
+  /**
+   * rename table
+   * @param table table name
+   * @param newTable new table name
+   */
+  renameTable(table: string, newTable: string): Promise<void>;
+
+  /**
+   * drop table
+   * @param table table name
+   */
+  dropTable(table: string): Promise<void>;
+
+  /**
+   * truncate table
+   * @param table table name
+   */
+  truncateTable(table: string): Promise<void>;
+
+  /**
+   * add index in table
+   * @param table table name
+   * @param attributes attributes name
+   * @param opts
+   */
+  addIndex(table: string, attributes: string[], opts?: { unique?: boolean, type?: string }): Promise<void>;
+
+  /**
+   * remove index in table
+   * @param table string
+   * @param attributes attributes name
+   * @param opts
+   */
+  removeIndex(table: string, attributes: string[], opts?: { unique?: boolean, type?: string }): Promise<void>;
+
+}
+
+export class MysqlDriver extends AbstractDriver {
+  type: 'mysql';
+  dialect: 'mysql';
+}
+
+export class PostgresDriver extends AbstractDriver {
+  type: 'postgres';
+  dialect: 'postgres';
+}
+
+export class SqliteDriver extends AbstractDriver {
+  type: 'sqlite';
+  dialect: 'sqlite';
+}

package/src/expr.js

@@ -347,7 +347,8 @@ function parseExprList(str, ...values) {
   const results = [];
   while (chr) {
     results.push(expr());
-    if (chr === ',') next();
+    if (chr && chr !== ',') throw new Error(`Unexpected token ${chr}`);
+    next();
   }
   return results;
 }