@axiosleo/orm-mysql 0.1.0-pre-alpha.3 → 0.1.1

package/README.md

@@ -1,2 +1,85 @@
-# node-orm-mysql
-MySQL ORM tool
+# @axiosleo/orm-mysql
+
+## Installation
+
+```bash
+npm install @axiosleo/orm-mysql
+```
+
+## Usage
+
+```javascript
+const { createClient, QueryHandler } = require('@axiosleo/orm-mysql');
+
+const conn = createClient({
+    host: process.env.MYSQL_HOST,
+    port: process.env.MYSQL_PORT,
+    user: process.env.MYSQL_USER,
+    password: process.env.MYSQL_PASS,
+    database: process.env.MYSQL_DB,
+});
+
+const hanlder = new QueryHandler(conn);
+
+async function selectExample(){
+    const query = handler.table('users');  // init QueryOperator by table name
+
+    query.attr('id', 'name', 'age');  // set attributes
+    query.where('name','Joe');        // set where condition
+    query.orWhere('age', '>', 18);    // set or where condition
+    query.andWhere('age', '<', 30);   // set and where condition
+    query.orderBy('age', 'desc');     // set order by
+    query.limit(10);                  // set limit
+    query.offset(0);                  // set offset
+
+    let rows = await query.select();  // select
+}
+
+async function findExample(){
+    const query = handler.table('users');  // init QueryOperator by table name
+
+    query.attr('id', 'name', 'age');  // set attributes
+    query.where('name','Joe');        // set where condition
+    query.orWhere('age', '>', 18);    // set or where condition
+    query.andWhere('age', '<', 30);   // set and where condition
+    query.orderBy('age', 'desc');     // set order by
+    // query.limit(10);               // not supported set limit
+    // query.offset(10);              // not supported set offset
+
+    let row = await query.find();     // find single row
+}
+
+async function insertExample(){
+    const query = handler.table('users');
+
+    // insert
+    let row = await query.insert({
+        name: 'Joe',
+        age: 18,
+    });
+}
+
+async function updateExample(){
+    const query = handler.table('users');
+
+    // update
+    let row = await query.where('name','Joe').update({
+        name: 'Joe',
+        age: 18,
+    });
+}
+
+async function deleteExample(){
+    const query = handler.table('users');
+
+    // delete with conditions
+    let result = await query.where('name','Joe').delete();
+
+    // delete by id
+    result = await query.delete(1);
+}
+```
+
+## License
+
+This project is open-sourced software licensed under the [MIT](LICENSE).

package/index.d.ts

@@ -10,7 +10,7 @@ export type Clients = {
   [key: string]: Connection
 }
 
-export type ConditionValueType = null | string | number | boolean | Date | Array<string | number | boolean | Date>;
+export type ConditionValueType = null | string | number | boolean | Date | Array<string | number | boolean | Date> | Query;
 
 export type OptType = '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE'
   | 'NOT LIKE' | 'IN' | 'NOT IN' | 'BETWEEN' | 'NOT BETWEEN' | 'IS' | 'IS NOT' | 'REGEXP' | 'NOT REGEXP'
@@ -53,14 +53,12 @@ export interface QueryOperatorOptions {
   operator: OperatorType | null;
   data: any | null;
   groupField: string[];
-  joins: JoinOption[]
+  joins: JoinOption[];
+  having: WhereOptions[];
 }
 
-export declare class QueryOperator {
-  conn: Connection;
-  options: QueryOperatorOptions
-
-  constructor(conn: Connection, table: TableOption);
+export declare class Query {
+  constructor(operator?: OperatorType);
 
   table(tableName: string, alias: string | null): this;
 
@@ -84,11 +82,20 @@ export declare class QueryOperator {
 
   groupBy(...groupField: string[]): this;
 
+  having(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+
   page(limit: number, offset?: number): this;
 
   set(data: any): this;
 
   join(table: string, alias: string, on: string, type: 'left' | 'right' | 'inner'): this;
+}
+
+export declare class QueryOperator extends Query {
+  conn: Connection;
+  options: QueryOperatorOptions
+
+  constructor(conn: Connection);
 
   buildSql(operator: OperatorType): { sql: string, values: any[] };
 
@@ -103,6 +110,8 @@ export declare class QueryOperator {
   insert(data?: any): Promise<OkPacket>;
 
   count(): Promise<number>;
+
+  delete(id?: number): Promise<OkPacket>;
 }
 
 export declare class QueryHandler {
@@ -117,6 +126,6 @@ export declare class QueryHandler {
   upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
 }
 
-export function createClient(options: ConnectionOptions): Connection;
+export function createClient(options: ConnectionOptions, name?: string | null | undefined): Connection;
 
 export function getClient(name: string): Connection;

package/index.js

@@ -2,12 +2,14 @@
 
 const {
   QueryHandler,
-  QueryOperator
-} = require('./src/query');
+  QueryOperator,
+  Query
+} = require('./src/operator');
 
 const { createClient, getClient } = require('./src/client');
 
 module.exports = {
+  Query,
   QueryHandler,
   QueryOperator,
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.1.0-pre-alpha.3",
+  "version": "0.1.1",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",

package/runtimes/test.js

@@ -4,18 +4,22 @@ const { debug } = require('@axiosleo/cli-tool');
 const mm = require('mm');
 // const expect = require('chai').expect;
 const mysql = require('mysql2');
-const { QueryHandler } = require('../src/query');
+const { QueryHandler, Query } = require('../src/operator');
 
 mm(mysql, 'createConnection', (options) => {
-  return {};
+  return {
+
+  };
 });
 
 const conn = mysql.createConnection({});
 const hanlder = new QueryHandler(conn);
-const query = hanlder.table('meta_items', 'u');
+// const query = hanlder.table('meta_items', 'u');
 
-// query.attr('UNIX_TIMESTAMP(deleted_at) AS deleted_at');
-query.where('u.meta->$.id', '06fbd857-7006-fee7-259d-fd3ed8f19b35');
-debug.log(query.buildSql('select').sql);
-// expect(query.buildSql('select').sql).to.be.equal('SELECT * FROM `users` AS `u` WHERE `u`.`id` = ?');
+const query = hanlder.table('meta_items');
+const subQuery = new Query('select');
+subQuery.table('meta_items').attr('item_code').groupBy('item_code').having('COUNT(*)', '>', 1);
+const res = query.where('item_code', subQuery, 'IN').buildSql('select');
+// expect(res.sql).to.be.equal('SELECT * FROM `users` AS `u` WHERE `name` IN (SELECT * FROM `users`)');
 
+debug.log(res);

package/src/builder.js

@@ -1,203 +1,207 @@
 'use strict';
 
+const Query = require('./query');
 const is = require('@axiosleo/cli-tool/src/helper/is');
 
-const _buildFieldWithTableName = (key) => {
-  if (key.indexOf('$') !== -1) {
-    return key;
-  }
-  return key.split('.').map((k) => k.indexOf('`') !== -1 ? k : `\`${k}\``).join('.');
-};
-
-const _buildFieldKey = (key) => {
-  if (key === null) {
-    return '';
-  }
-  if (key.indexOf('(') !== -1 && key.indexOf(')') !== -1) {
-    let field = key.substring(key.indexOf('(') + 1, key.indexOf(')'));
-    key = key.substring(0, key.indexOf('(')) + '(' + _buildFieldWithTableName(field) + ')' + key.substring(key.indexOf(')') + 1);
-  }
-  if (key.indexOf(' as ') !== -1) {
-    const field = key.substring(key.indexOf(' as ') + 4);
-    key = key.substring(0, key.indexOf(' as ')) + ' AS ' + _buildFieldWithTableName(field);
-  } else if (key.indexOf(' AS ') !== -1) {
-    const field = key.substring(key.indexOf(' AS ') + 4);
-    key = key.substring(0, key.indexOf(' AS ')) + ' AS ' + _buildFieldWithTableName(field);
-  }
-  return _buildFieldWithTableName(key);
-};
+class Builder {
+  constructor(options) {
+    let sql = options.sql;
+    this.values = options.values || [];
 
-const _buildContidion = (conditions, prefix) => {
-  const values = [];
-  if (is.empty(conditions)) {
-    return { sql: '', values };
-  }
-  let sql = typeof prefix === 'undefined' ? ' WHERE ' : '';
-  if (conditions.length) {
-    sql += `${conditions.map((c) => {
-      if (c.key === null && c.value === null) {
-        return ` ${c.opt} `;
+    switch (options.operator) {
+      case 'find': {
+        options.pageLimit = 1;
+        options.pageOffset = 0;
+      }
+      // eslint-disable-next-line no-fallthrough
+      case 'select': {
+        sql = `SELECT ${options.attrs ? options.attrs.map((a) => this._buildFieldKey(a)).join(',') : '*'} FROM ${this._buildTables(options.tables)}`;
+        sql += this._buildJoins(options.joins);
+        sql += this._buildContidion(options.conditions);
+        sql += options.orders.length > 0 ? this._buildOrders(options.orders) : '';
+        sql += this._buldPagenation(options.pageLimit, options.pageOffset);
+        if (options.groupField.length) {
+          sql += ` GROUP BY ${options.groupField.map(f => this._buildFieldKey(f)).join(',')}`;
+          sql += this._buildHaving(options.having);
+        } else if (options.having && options.having.length) {
+          throw new Error('having is not allowed without "GROUP BY"');
+        }
+        break;
+      }
+      case 'insert': {
+        const fields = this._buildValues(options.data);
+        sql = `INSERT INTO ${this._buildTables(options.tables)}(${fields.map((f) => this._buildFieldKey(f))}) VALUES (${fields.map(() => '?').join(',')})`;
+        break;
       }
-      if (c.value === null) {
-        return c.opt === '=' ? `ISNULL(${_buildFieldKey(c.key)})` : `!ISNULL(${_buildFieldKey(c.key)})`;
+      case 'update': {
+        const fields = this._buildValues(options.data);
+        sql = `UPDATE ${this._buildTables(options.tables)} SET ${fields.map(f => `${this._buildFieldKey(f)} = ?`).join(',')}`;
+        sql += this._buildContidion(options.conditions);
+        break;
       }
-      if (c.key && c.key.indexOf('->') !== -1) {
-        const keys = c.key.split('->');
-        values.push(c.value);
-        const res = _buildContidion([
-          {
-            key: `JSON_EXTRACT(${_buildFieldKey(keys[0])}, '${keys[1]}')`,
-            opt: c.opt,
-            value: c.value
-          }
-        ], '');
-        values.push(...res.values);
-        return res.sql;
+      case 'delete': {
+        sql = `DELETE FROM ${this._buildTables(options.tables)}`;
+        if (!options.conditions.length) {
+          throw new Error('At least one where condition is required for delete operation');
+        }
+        sql += this._buildContidion(options.conditions);
+        break;
       }
-      const opt = c.opt.toLowerCase();
-      if (opt === 'in' && Array.isArray(c.value)) {
-        values.push(c.value.join(','));
-        return `${_buildFieldKey(c.key)} IN (?)`;
-      } else if (opt === 'group' && Array.isArray(c.value)) {
-        const res = _buildContidion(c.value, '');
-        values.push(...res.values);
-        return `(${res.sql})`;
+      case 'count': {
+        sql = `SELECT COUNT(*) AS count FROM ${this._buildTables(options.tables)}`;
+        sql += this._buildContidion(options.conditions);
+        if (options.groupField.length) {
+          sql += ` GROUP BY ${options.groupField.map(f => this._buildFieldKey(f)).join(',')}`;
+          sql += this._buildHaving(options.having);
+        } else if (options.having && options.having.length) {
+          throw new Error('having is not allowed without "GROUP BY"');
+        }
+        break;
       }
-      values.push(c.value);
-      return `${_buildFieldKey(c.key)} ${c.opt} ?`;
-    }).join('')}`;
+      default:
+        throw new Error('Invalid operator: ' + options.operator);
+    }
+
+    this.sql = sql;
   }
-  return {
-    sql,
-    values
-  };
-};
 
-const _buildValues = (obj) => {
-  const fields = [];
-  const values = [];
-  Object.keys(obj).forEach((key) => {
-    fields.push(`${key}`);
-    if (obj[key] === null) {
-      values.push('NULL');
-      return;
+  _buildHaving(having) {
+    if (!having.length) {
+      return '';
     }
-    if (Array.isArray(obj[key]) || is.object(obj[key])) {
-      values.push(JSON.stringify(obj[key]));
-    } else {
-      values.push(obj[key]);
-    }
-  });
-  return { fields, values };
-};
+    return this._buildContidion(having, ' HAVING ');
+  }
 
-const _buldPagenation = (limit, offset) => {
-  let sql = '';
-  if (limit) {
-    sql += ` LIMIT ${limit}`;
+  _buildJoins(joins = []) {
+    return joins.map((j) => {
+      switch (j.type) {
+        case 'left':
+          return ` LEFT JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
+        case 'inner':
+          return ` INNER JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
+        case 'right':
+          return ` RIGHT JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
+      }
+    }).join(' ');
   }
-  if (offset) {
-    sql += ` OFFSET ${offset}`;
+
+  _buildOrders(orders = []) {
+    const sql = ' ORDER BY ' + orders.map((o) => {
+      return `\`${o.sortField}\` ${o.sortOrder}`;
+    }).join(',');
+    return sql;
   }
-  return sql;
-};
 
-const _buildTables = (tables) => {
-  return tables.map((t) => {
-    if (t.alias) {
-      return `\`${t.tableName}\` AS \`${t.alias}\``;
+  _buildTables(tables) {
+    if (!tables.length) {
+      throw new Error('At least one table is required');
     }
-    return `\`${t.tableName}\``;
-  }).join(' , ');
-};
-
-const _buildOrders = (orders = []) => {
-  const sql = ' ORDER BY ' + orders.map((o) => {
-    return `\`${o.sortField}\` ${o.sortOrder}`;
-  }).join(',');
-  return sql;
-};
+    return tables.map((t) => {
+      if (t.alias) {
+        return `\`${t.tableName}\` AS \`${t.alias}\``;
+      }
+      return `\`${t.tableName}\``;
+    }).join(' , ');
+  }
 
-const _buildJoins = (joins = []) => {
-  return joins.map((j) => {
-    switch (j.type) {
-      case 'left':
-        return ` LEFT JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
-      case 'inner':
-        return ` INNER JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
-      case 'right':
-        return ` RIGHT JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
+  _buldPagenation(limit, offset) {
+    let sql = '';
+    if (limit) {
+      sql += ` LIMIT ${limit}`;
     }
-  }).join(' ');
-};
-
-const buildSql = (options) => {
-  let sql = options.sql;
-  let values = options.values;
-  switch (options.operator) {
-    case 'find': {
-      options.pageLimit = 1;
-      options.pageOffset = 0;
+    if (offset) {
+      sql += ` OFFSET ${offset}`;
     }
-    // eslint-disable-next-line no-fallthrough
-    case 'select': {
-      sql = `SELECT ${options.attrs ? options.attrs.map((a) => _buildFieldKey(a)).join(',') : '*'} FROM ${_buildTables(options.tables)}`;
-      sql += _buildJoins(options.joins);
-      const res = _buildContidion(options.conditions);
-      sql += res.sql;
-      values = options.values.concat(res.values);
-      sql += options.orders.length > 0 ? _buildOrders(options.orders) : '';
-      sql += _buldPagenation(options.pageLimit, options.pageOffset);
-      if (options.groupField.length) {
-        sql += ` GROUP BY ${options.groupField.join(',')}`;
+    return sql;
+  }
+
+  _buildValues(obj) {
+    const fields = [];
+    Object.keys(obj).forEach((key) => {
+      fields.push(`${key}`);
+      if (obj[key] instanceof Date) {
+        this.values.push(obj[key]);
+      } else if (Array.isArray(obj[key]) || is.object(obj[key])) {
+        this.values.push(JSON.stringify(obj[key]));
+      } else {
+        this.values.push(obj[key]);
       }
-      break;
+    });
+    return fields;
+  }
+
+  _buildConditionValues(val) {
+    if (val instanceof Query) {
+      const builder = new Builder(val.options);
+      this.values = this.values.concat(builder.values);
+      return builder.sql;
     }
-    case 'insert': {
-      const buildValueRes = _buildValues(options.data);
-      sql = `INSERT INTO ${_buildTables(options.tables)}(${buildValueRes.fields.map((f) => _buildFieldKey(f))}) VALUES (${buildValueRes.fields.map(() => '?').join(',')})`;
-      values = values.concat(buildValueRes.values);
-      break;
+    return null;
+  }
+
+  _buildContidion(conditions, prefix) {
+    if (!conditions.length) {
+      return '';
     }
-    case 'update': {
-      const buildValueRes = _buildValues(options.data);
-      sql = `UPDATE ${_buildTables(options.tables)} SET ${buildValueRes.fields.map(f => `${_buildFieldKey(f)} = ?`).join(',')}`;
-      values = values.concat(buildValueRes.values);
-      const buildConditionRes = _buildContidion(options.conditions);
-      sql += buildConditionRes.sql;
-      values = values.concat(buildConditionRes.values);
-      break;
+    let sql = typeof prefix === 'undefined' ? ' WHERE ' : prefix;
+    if (conditions.length) {
+      sql += `${conditions.map((c) => {
+        if (c.key === null && c.value === null) {
+          return ` ${c.opt} `;
+        }
+        if (c.value === null) {
+          return c.opt === '=' ? `ISNULL(${this._buildFieldKey(c.key)})` : `!ISNULL(${this._buildFieldKey(c.key)})`;
+        }
+        if (c.key && c.key.indexOf('->') !== -1) {
+          const keys = c.key.split('->');
+          return this._buildContidion([
+            {
+              key: `JSON_EXTRACT(${this._buildFieldKey(keys[0])}, '${keys[1]}')`,
+              opt: c.opt,
+              value: c.value
+            }
+          ], '');
+        }
+        const opt = c.opt.toLowerCase();
+        if (opt === 'in' && Array.isArray(c.value)) {
+          let res = this._buildConditionValues(c.value);
+          return res ? `${this._buildFieldKey(c.key)} IN (${res})` : `${this._buildFieldKey(c.key)} IN (?)`;
+        } else if (opt === 'group' && Array.isArray(c.value)) {
+          return `(${this._buildContidion(c.value, '')})`;
+        }
+        let res = this._buildConditionValues(c.value);
+        return res ? `${this._buildFieldKey(c.key)} ${c.opt} (${res})` : `${this._buildFieldKey(c.key)} ${c.opt} ?`;
+      }).join('')}`;
     }
-    case 'delete': {
-      sql = `DELETE FROM ${_buildTables(options.tables)}`;
-      if (!options.conditions.length) {
-        throw new Error('At least one where condition is required for delete operation');
-      }
-      const buildConditionRes = _buildContidion(options.conditions);
-      sql += buildConditionRes.sql;
-      values = values.concat(buildConditionRes.values);
-      break;
+    return sql;
+  }
+
+  _buildFieldKey(key) {
+    if (key === null) {
+      return '';
     }
-    case 'count': {
-      sql = `SELECT COUNT(*) AS count FROM ${_buildTables(options.tables)}`;
-      const buildConditionRes = _buildContidion(options.conditions);
-      sql += buildConditionRes.sql;
-      values = values.concat(buildConditionRes.values);
-      if (options.groupField.length) {
-        sql += ` GROUP BY ${options.groupField.join(',')}`;
-      }
-      break;
+    if (key.indexOf('(') !== -1 && key.indexOf(')') !== -1) {
+      let field = key.substring(key.indexOf('(') + 1, key.indexOf(')'));
+      key = key.substring(0, key.indexOf('(')) + '(' + this._buildFieldWithTableName(field) + ')' + key.substring(key.indexOf(')') + 1);
+    }
+    if (key.indexOf(' as ') !== -1) {
+      const field = key.substring(key.indexOf(' as ') + 4);
+      key = key.substring(0, key.indexOf(' as ')) + ' AS ' + this._buildFieldWithTableName(field);
+    } else if (key.indexOf(' AS ') !== -1) {
+      const field = key.substring(key.indexOf(' AS ') + 4);
+      key = key.substring(0, key.indexOf(' AS ')) + ' AS ' + this._buildFieldWithTableName(field);
     }
-    default:
-      throw new Error('Invalid operator: ' + options.operator);
+    return this._buildFieldWithTableName(key);
   }
 
-  return {
-    sql,
-    values: values
-  };
-};
+  _buildFieldWithTableName(key) {
+    if (key.indexOf('$') !== -1 || key.indexOf('*') !== -1) {
+      return key;
+    }
+    return key.split('.').map((k) => k.indexOf('`') !== -1 ? k : `\`${k}\``).join('.');
+  }
+}
 
 module.exports = {
-  buildSql
+  Builder
 };

package/src/client.js

@@ -10,16 +10,15 @@ const clients = {};
  * @param {mysql.ConnectionOptions} options
  * @returns {mysql.Connection}
  */
-const createClient = (options) => {
+const createClient = (options, name = null) => {
   validate(options, {
-    name: 'string',
     host: 'required|string',
     user: 'required|string',
     password: 'required|string',
     port: 'required|integer',
     database: 'required|string',
   });
-  const key = options.name ? options.name :
+  const key = name ? name :
     `${options.host}:${options.port}:${options.user}:${options.password}:${options.database}`;
   if (clients[key]) {
     return clients[key];

package/src/operator.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { Builder } = require('./builder');
+const Query = require('./query');
+
+const query = async (conn, options) => {
+  return new Promise((resolve, reject) => {
+    conn.query(options, (err, result) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+};
+
+class QueryOperator extends Query {
+  /**
+   * @param {*} conn 
+   */
+  constructor(conn) {
+    super(null);
+    this.conn = conn;
+  }
+
+  buildSql(operator) {
+    this.options.operator = operator;
+    return new Builder(this.options);
+  }
+
+  async exec() {
+    if (!this.options.operator) {
+      throw new Error('Invalid operator: ' + this.options.operator);
+    }
+    const builder = this.buildSql(this.options.operator);
+    const { sql, values } = builder;
+    const options = {
+      sql, values
+    };
+    switch (this.options.operator) {
+      case 'find': {
+        const res = await query(this.conn, options);
+        return res[0];
+      }
+      case 'count': {
+        const [res] = await query(this.conn, options);
+        return res.count;
+      }
+      default:
+        return query(this.conn, options);
+    }
+  }
+
+  async select() {
+    this.options.operator = 'select';
+    return await this.exec();
+  }
+
+  async find() {
+    this.options.operator = 'find';
+    return await this.exec();
+  }
+
+  async update(data) {
+    this.options.operator = 'update';
+    if (data) {
+      this.set(data);
+    }
+    return await this.exec();
+  }
+
+  async insert(data) {
+    this.options.operator = 'insert';
+    if (data) {
+      this.set(data);
+    }
+    return await this.exec();
+  }
+
+  async count() {
+    this.options.operator = 'count';
+    return await this.exec();
+  }
+
+  async delete(id) {
+    if (id) {
+      this.where('id', id);
+    }
+    this.options.operator = 'delete';
+    return await this.exec();
+  }
+}
+
+class QueryHandler {
+  constructor(conn) {
+    this.conn = conn;
+  }
+
+  async query(options) {
+    return new Promise((resolve, reject) => {
+      this.conn.query(options, (err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+
+  table(table, alias = null) {
+    return (new QueryOperator(this.conn)).table(table, alias);
+  }
+
+  async upsert(tableName, data, condition = {}) {
+    const count = await this.table(tableName).whereObject(condition).count();
+    if (count) {
+      return await this.table(tableName).whereObject(condition).update(data);
+    }
+    return await this.table(tableName).insert(data);
+  }
+}
+
+module.exports = {
+  QueryOperator,
+  QueryHandler,
+  Query
+};

package/src/query.js

@@ -1,38 +1,18 @@
 'use strict';
 
-const { buildSql } = require('./builder');
-
-const query = async (conn, options) => {
-  return new Promise((resolve, reject) => {
-    conn.query(options, (err, result) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(result);
-      }
-    });
-  });
-};
-
-class QueryOperator {
-  /**
-   * 
-   * @param {*} conn 
-   * @param {TableOption} table 
-   */
-  constructor(conn, table) {
-    this.conn = conn;
+class Query {
+  constructor(operator = 'select') {
     this.options = {
       sql: '',
       values: [],
       conditions: [],
       orders: [],
       tables: [],
-      operator: null,
+      operator,
       data: null,
       groupField: [],
+      having: []
     };
-    this.options.tables.push(table);
   }
 
   table(tableName, alias) {
@@ -117,6 +97,22 @@ class QueryOperator {
     return this;
   }
 
+  having(key, opt = '=', value = null) {
+    let optUpper = opt.toUpperCase();
+    if (optUpper === 'AND' || optUpper === 'OR') {
+      this.options.having.push({ key: null, opt: optUpper, value: null });
+      return this;
+    }
+    if (this.options.having.length) {
+      let lastOpt = this.options.having[this.options.having.length - 1].opt.toUpperCase();
+      if (lastOpt !== 'AND' && lastOpt !== 'OR') {
+        this.options.having.push({ key: null, opt: 'AND', value: null });
+      }
+    }
+    this.options.having.push({ key, opt, value });
+    return this;
+  }
+
   page(limit, offset = 0) {
     this.options.pageLimit = limit;
     this.options.pageOffset = offset;
@@ -135,100 +131,6 @@ class QueryOperator {
     this.options.joins.push({ table, alias, on, type });
     return this;
   }
-
-  buildSql(operator) {
-    this.options.operator = operator;
-    return buildSql(this.options);
-  }
-
-  async exec() {
-    if (!this.options.operator) {
-      throw new Error('Invalid operator: ' + this.options.operator);
-    }
-    const { sql, values } = this.buildSql(this.options.operator);
-    const options = {
-      sql, values
-    };
-    switch (this.options.operator) {
-      case 'find': {
-        const res = await query(this.conn, options);
-        return res[0];
-      }
-      case 'count': {
-        const [res] = await query(this.conn, options);
-        return res.count;
-      }
-      default:
-        return query(this.conn, options);
-    }
-  }
-
-  async select() {
-    this.options.operator = 'select';
-    return await this.exec();
-  }
-
-  async find() {
-    this.options.operator = 'find';
-    return await this.exec();
-  }
-
-  async update(data) {
-    this.options.operator = 'update';
-    if (data) {
-      this.set(data);
-    }
-    return await this.exec();
-  }
-
-  async insert(data) {
-    this.options.operator = 'insert';
-    if (data) {
-      this.set(data);
-    }
-    return await this.exec();
-  }
-
-  async count() {
-    this.options.operator = 'count';
-    return await this.exec();
-  }
-}
-
-class QueryHandler {
-  constructor(conn) {
-    this.conn = conn;
-  }
-
-  async query(options) {
-    return new Promise((resolve, reject) => {
-      this.conn.query(options, (err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(result);
-        }
-      });
-    });
-  }
-
-  table(table, alias = null) {
-    return new QueryOperator(this.conn, {
-      tableName: table,
-      alias
-    });
-  }
-
-  async upsert(tableName, data, condition = {}) {
-    const count = await this.table(tableName).whereObject(condition).count();
-    if (count) {
-      return await this.table(tableName).whereObject(condition).update(data);
-    }
-    return await this.table(tableName).insert(data);
-  }
 }
 
-module.exports = {
-  QueryOperator,
-  QueryHandler
-};
+module.exports = Query;