leoric 2.3.2 → 2.5.0

package/types/index.d.ts

@@ -1,12 +1,24 @@
 import DataType from './data_types';
+import { Hint, IndexHint } from './hint';
 
 export { DataType as DataTypes };
 export * from '../src/decorators';
 
+export type command = 'select' | 'insert' | 'bulkInsert' | 'update' | 'delete' | 'upsert';
+export type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
+
+export class Raw {
+  value: string;
+  type: 'raw';
+}
+
+
 type DataTypes<T> = {
   [Property in keyof T as Exclude<Property, "toSqlString">]: T[Property]
 }
 
+type RawQueryResult = typeof Bone | ResultSet | boolean | number;
+
 interface ExprIdentifier {
   type: 'id';
   value: string;
@@ -37,20 +49,35 @@ interface ExprTernaryOperator {
 }
 
 type ExprOperator = ExprBinaryOperator | ExprTernaryOperator;
+type SpellColumn = ExprIdentifier | Raw;
+
+interface Join {
+  [key: string]: {
+    Model: typeof Bone;
+    on: ExprBinaryOperator
+  }
+}
 
 interface SpellOptions {
-  command?: string;
-  columns: Object[];
+  command?: command;
+  columns: SpellColumn[];
   table: ExprIdentifier;
   whereConditions: ExprOperator[];
   groups: (ExprIdentifier | ExprFunc)[];
   orders: (ExprIdentifier | ExprFunc)[];
   havingCondtions: ExprOperator[];
-  joins: Object;
+  joins: Join;
   skip: number;
   scopes: Function[];
   subqueryIndex: number;
-  rowCount: 0;
+  rowCount?: number;
+  connection?: Connection;
+  sets?: { [key: string]: Literal } | { [key: string]: Literal }[];
+  hints?: Array<Hint | IndexHint>;
+}
+
+export interface SpellMeta extends SpellOptions {
+  Model: typeof Bone;
 }
 
 type OrderOptions = { [name: string]: 'desc' | 'asc' };
@@ -64,7 +91,10 @@ type WithOptions = {
 export 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: Array<string | RawSql> | Array<(name: string) => boolean>): Spell<T, U>;
+  command: string;
+  scopes: Function[];
+
+  select(...names: Array<string | Raw> | Array<(name: string) => boolean>): Spell<T, U>;
   insert(opts: SetOptions): Spell<T, QueryResult>;
   update(opts: SetOptions): Spell<T, QueryResult>;
   upsert(opts: SetOptions): Spell<T, QueryResult>;
@@ -86,7 +116,7 @@ export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Insta
   orWhere(conditions: WhereConditions<T>): Spell<T, U>;
   orWhere(conditions: string, ...values: Literal[]): Spell<T, U>;
 
-  group(...names: Array<string | RawSql>): Spell<T, ResultSet>;
+  group(...names: Array<string | Raw>): Spell<T, ResultSet>;
 
   having(conditions: string, ...values: Literal[]): Spell<T, ResultSet>;
   having(conditions: WhereConditions<T>): Spell<T, ResultSet>;
@@ -115,7 +145,6 @@ export class Spell<T extends typeof Bone, U = InstanceType<T> | Collection<Insta
   toString(): string;
 }
 
-type Literal = null | undefined | boolean | number | bigint | string | Date | object | ArrayBuffer;
 
 type OperatorCondition = {
   [key in '$eq' | '$ne']?: Literal;
@@ -141,16 +170,28 @@ type InstanceValues<T> = {
   [Property in keyof Extract<T, Literal>]?: Extract<T, Literal>[Property]
 }
 
-export interface AttributeMeta {
+export interface ColumnMeta {
   columnName?: string;
   columnType?: string;
   allowNull?: boolean;
   defaultValue?: Literal;
   primaryKey?: boolean;
+  unique?: boolean;
   dataType?: string;
+  comment?: string;
+  datetimePrecision?: string;
+}
+
+declare type validator = Literal | Function | Array<Literal | Literal[]>;
+
+export interface AttributeMeta extends ColumnMeta {
   jsType?: Literal;
   type: DataType;
+  virtual?: boolean,
   toSqlString: () => string;
+  validate: {
+    [key: string]: validator;
+  }
 }
 
 interface RelateOptions {
@@ -187,7 +228,59 @@ declare class Pool {
   getConnection(): Connection;
 }
 
-declare class Driver {
+declare class Attribute {
+  /**
+   * attribute name
+   */
+  name: string;
+  /**
+   * primaryKey tag
+   */
+  primaryKey: boolean;
+  allowNull: boolean;
+  /**
+   * attribute column name in table
+   */
+  columnName: string;
+  columnType: string;
+  type: typeof DataType;
+  defaultValue: Literal;
+  dataType: string;
+  jsType: Literal;
+  virtual: boolean;
+
+  euals(columnInfo: ColumnMeta): boolean;
+  cast(value: Literal): Literal;
+  uncast(value: Literal): Literal;
+}
+
+interface SpellBookFormatStandardResult {
+  sql?: string;
+  values?: Array<Literal> | {
+    [key: string]: Literal
+  };
+  [key: string]: Literal
+}
+
+export type SpellBookFormatResult<T> = SpellBookFormatStandardResult | T;
+
+declare 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>;
+}
+
+declare 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
    */
@@ -203,10 +296,153 @@ declare class 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, values?: Array<Literal | Literal[]>): Promise<QueryResult>;
+  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 Bone, 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]: DataTypes<DataType> | AttributeMeta }): Promise<void>;
+
+  /**
+   * alter table
+   * @param tabe table name
+   * @param attributes alter attributes
+   */
+  alterTable(tabe: string, attributes: { [key: string]: DataTypes<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';
 }
 
 type ResultSet = {
@@ -220,7 +456,7 @@ export class Collection<T extends Bone> extends Array<T> {
 }
 
 export class Bone {
-  static DataTypes: DataType;
+  static DataTypes: typeof DataType;
 
   /**
    * get the connection pool of the driver
@@ -230,7 +466,7 @@ export class Bone {
   /**
    * The driver that powers the model
    */
-  static driver: Driver;
+  static driver: AbstractDriver;
 
   /**
    * The connected models structured as `{ [model.name]: model }`, e.g. `Bone.model.Post => Post`
@@ -303,6 +539,7 @@ export class Bone {
 
   static alias(name: string): string;
   static alias(data: Record<string, Literal>): Record<string, Literal>;
+  static unalias(name: string): string;
 
   static hasOne(name: string, opts?: RelateOptions): void;
   static hasMany(name: string, opts?: RelateOptions): void;
@@ -457,8 +694,8 @@ export class Bone {
    *   yield Muscle.create({ boneId: bone.id, bar: 1 })
    * });
    */
-  static transaction(callback: GeneratorFunction): Promise<void>;
-  static transaction(callback: (connection: Connection) => Promise<void>): Promise<void>;
+  static transaction(callback: GeneratorFunction): Promise<RawQueryResult>;
+  static transaction(callback: (connection: Connection) => Promise<RawQueryResult>): Promise<RawQueryResult>;
 
   /**
    * DROP the table
@@ -474,7 +711,7 @@ export class Bone {
 
   static initialize(): void;
 
-  constructor(values: { [key: string]: Literal });
+  constructor(values: { [key: string]: Literal }, opts?: { isNewRecord?: boolean });
 
   /**
    * @example
@@ -609,6 +846,7 @@ export interface ConnectOptions {
   charset?: string;
   models?: string | (typeof Bone)[];
   subclass?: boolean;
+  driver?: typeof AbstractDriver;
 }
 
 interface InitOptions {
@@ -626,12 +864,6 @@ interface SyncOptions {
   alter?: boolean;
 }
 
-type RawSql = {
-  __raw: true,
-  value: string,
-  type: 'raw',
-};
-
 interface RawQueryOptions {
   replacements?: { [key:string]: Literal | Literal[] };
   model: Bone;
@@ -641,11 +873,14 @@ interface RawQueryOptions {
 export default class Realm {
   Bone: typeof Bone;
   DataTypes: typeof DataType;
-  driver: Driver;
+  driver: AbstractDriver;
   models: Record<string, Bone>;
+  connected?: boolean;
 
   constructor(options: ConnectOptions);
 
+  connect(): Promise<Bone>;
+
   define(
     name: string,
     attributes: Record<string, DataTypes<DataType> | AttributeMeta>,
@@ -653,14 +888,14 @@ export default class Realm {
     descriptors?: Record<string, Function>,
   ): typeof Bone;
 
-  raw(sql: string): RawSql;
+  raw(sql: string): Raw;
 
   escape(value: Literal): string;
 
-  query(sql: string, values?: Array<Literal>, options?: RawQueryOptions): ResultSet;
+  query(sql: string, values?: Array<Literal>, options?: RawQueryOptions): RawQueryResult;
 
-  transaction(callback: GeneratorFunction): Promise<void>;
-  transaction(callback: (connection: Connection) => Promise<void>): Promise<void>;
+  transaction(callback: GeneratorFunction): Promise<RawQueryResult>;
+  transaction(callback: (connection: Connection) => Promise<RawQueryResult>): Promise<RawQueryResult>;
 
   sync(options?: SyncOptions): Promise<void>;
 }
@@ -676,3 +911,8 @@ export default class Realm {
  * })
  */
 export function connect(opts: ConnectOptions): Promise<Realm>;
+export function disconnect(realm: Realm, callback?: Function): Promise<boolean | void>;
+export {
+  Hint,
+  IndexHint,
+}

package/src/drivers/abstract/schema.js

@@ -1,143 +0,0 @@
-'use strict';
-
-const { heresql } = require('../../utils/string');
-
-module.exports = {
-  async createTable(table, attributes) {
-    const { escapeId, Attribute } = this;
-    const chunks = [ `CREATE TABLE ${escapeId(table)}` ];
-    const columns = Object.keys(attributes).map(name => {
-      const attribute = new Attribute(name, attributes[name]);
-      return attribute.toSqlString();
-    });
-    chunks.push(`(${columns.join(', ')})`);
-    await this.query(chunks.join(' '));
-  },
-
-  async alterTable(table, attributes) {
-    const { escapeId, Attribute } = this;
-    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
-
-    const actions = Object.keys(attributes).map(name => {
-      const options = attributes[name];
-      // { [columnName]: { remove: true } }
-      if (options.remove) return `DROP COLUMN ${escapeId(name)}`;
-      const attribute = new Attribute(name, options);
-      return [
-        options.modify ? 'MODIFY COLUMN' : 'ADD COLUMN',
-        attribute.toSqlString(),
-      ].join(' ');
-    });
-    chunks.push(actions.join(', '));
-    await this.query(chunks.join(' '));
-  },
-
-  async describeTable(table) {
-    const { database } = this.options;
-    const schemaInfo = await this.querySchemaInfo(database, table);
-    return schemaInfo[table].reduce(function(result, column) {
-      result[column.columnName] = column;
-      return result;
-    }, {});
-  },
-
-  async addColumn(table, name, params) {
-    const { escapeId, Attribute } = this;
-    const attribute = new Attribute(name, params);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)}
-      ADD COLUMN ${attribute.toSqlString()}
-    `);
-    await this.query(sql);
-  },
-
-  async changeColumn(table, name, params) {
-    const { escapeId, Attribute } = this;
-    const attribute = new Attribute(name, params);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)}
-      MODIFY COLUMN ${attribute.toSqlString()}
-    `);
-    await this.query(sql);
-  },
-
-  async removeColumn(table, name) {
-    const { escapeId, Attribute } = this;
-    const { columnName } = new Attribute(name);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)} DROP COLUMN ${escapeId(columnName)}
-    `);
-    await this.query(sql);
-  },
-
-  async renameColumn(table, name, newName) {
-    const { escapeId, Attribute } = this;
-    const { columnName } = new Attribute(name);
-    const attribute = new Attribute(newName);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)}
-      RENAME COLUMN ${escapeId(columnName)} TO ${escapeId(attribute.columnName)}
-    `);
-    await this.query(sql);
-  },
-
-  async renameTable(table, newTable) {
-    const { escapeId } = this;
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)} RENAME TO ${escapeId(newTable)}
-    `);
-    await this.query(sql);
-  },
-
-  async dropTable(table) {
-    const { escapeId } = this;
-    await this.query(`DROP TABLE IF EXISTS ${escapeId(table)}`);
-  },
-
-  async truncateTable(table) {
-    const { escapeId } = this;
-    await this.query(`TRUNCATE TABLE ${escapeId(table)}`);
-  },
-
-  async addIndex(table, attributes, opts = {}) {
-    const { escapeId, Attribute } = this;
-    const columns = attributes.map(name => new Attribute(name).columnName);
-    const type = opts.unique ? 'UNIQUE' : opts.type;
-    const prefix = type === 'UNIQUE' ? 'uk' : 'idx';
-    const { name } = {
-      name: [ prefix, table ].concat(columns).join('_'),
-      ...opts,
-    };
-
-    if (type != null && ![ 'UNIQUE', 'FULLTEXT', 'SPATIAL' ].includes(type)) {
-      throw new Error(`Unexpected index type: ${type}`);
-    }
-
-    const sql = heresql(`
-      CREATE ${type ? `${type} INDEX` : 'INDEX'} ${escapeId(name)}
-      ON ${escapeId(table)} (${columns.map(escapeId).join(', ')})
-    `);
-    await this.query(sql);
-  },
-
-  async removeIndex(table, attributes, opts = {}) {
-    const { escapeId, Attribute } = this;
-    let name;
-    if (Array.isArray(attributes)) {
-      const columns = attributes.map(entry => new Attribute(entry).columnName);
-      const type = opts.unique ? 'UNIQUE' : opts.type;
-      const prefix = type === 'UNIQUE' ? 'uk' : 'idx';
-      name = [ prefix, table ].concat(columns).join('_');
-    } else if (typeof attributes === 'string') {
-      name = attributes;
-    } else {
-      throw new Error(`Unexpected index name: ${attributes}`);
-    }
-
-    const sql = this.type === 'mysql'
-      ? `DROP INDEX ${escapeId(name)} ON ${escapeId(table)}`
-      : `DROP INDEX IF EXISTS ${escapeId(name)}`;
-    await this.query(sql);
-  },
-
-};

package/src/drivers/mysql/schema.js

@@ -1,98 +0,0 @@
-'use strict';
-
-const Attribute = require('./attribute');
-const schema = require('../abstract/schema');
-const { heresql } = require('../../utils/string');
-
-module.exports = {
-  ...schema,
-
-  /**
-   * Fetch columns of give tables from database
-   * - https://dev.mysql.com/doc/mysql-infoschema-excerpt/5.6/en/columns-table.html
-   * @param {string} database
-   * @param {string|string[]} tables
-   */
-  async querySchemaInfo(database, tables) {
-    tables = [].concat(tables);
-    const sql = heresql(`
-      SELECT table_name, column_name, column_type, data_type, is_nullable,
-             column_default, column_key, column_comment,
-             datetime_precision
-        FROM information_schema.columns
-       WHERE table_schema = ? AND table_name in (?)
-       ORDER BY table_name, column_name
-    `);
-
-    const { rows } = await this.query(sql, [ database, tables ]);
-    const schemaInfo = {};
-
-    for (const entry of rows) {
-      // make sure the column names are in lower case
-      const row = Object.keys(entry).reduce((obj, name) => {
-        obj[name.toLowerCase()] = entry[name];
-        return obj;
-      }, {});
-      const tabelName = row.table_name;
-      const columns = schemaInfo[tabelName] || (schemaInfo[tabelName] = []);
-      columns.push({
-        columnName: row.column_name,
-        columnType: row.column_type,
-        comment: row.column_comment,
-        defaultValue: row.column_default,
-        dataType: row.data_type,
-        allowNull: row.is_nullable === 'YES',
-        primaryKey: row.column_key == 'PRI',
-        unique: row.column_key == 'PRI' || row.column_key == 'UNI',
-        datetimePrecision: row.datetime_precision,
-      });
-    }
-
-    return schemaInfo;
-  },
-
-  /**
-   * Rename column with SQL that works on older versions of MySQL
-   * - https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
-   * - https://dev.mysql.com/doc/refman/8.0/en/alter-table.html
-   * @param {string} table
-   * @param {string} column the old column name
-   * @param {string} newColumn the new column name
-   */
-  async renameColumn(table, name, newName) {
-    const { escapeId } = this;
-    const { database } = this.options;
-    const { columnName } = new Attribute(name);
-    const schemaInfo = await this.querySchemaInfo(database, table);
-    const { columnName: _, ...columnInfo } = schemaInfo[table].find(entry => {
-      return entry.columnName == columnName;
-    });
-
-    if (!columnInfo) {
-      throw new Error(`Unable to find column ${table}.${columnName}`);
-    }
-
-    const attribute = new Attribute(newName, columnInfo);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)}
-      CHANGE COLUMN ${escapeId(columnName)} ${attribute.toSqlString()}
-    `);
-    await this.query(sql);
-  },
-
-  async describeTable(table) {
-    const { escapeId } = this;
-    const { rows } = await this.query(`DESCRIBE ${escapeId(table)}`);
-    const result = {};
-    for (const row of rows) {
-      result[row.Field] = {
-        columnName: row.Field,
-        columnType: row.Type,
-        allowNull: row.Null === 'YES',
-        defaultValue: row.Default,
-        autoIncrement: row.Extra === 'auto_increment',
-      };
-    }
-    return result;
-  },
-};