@axiosleo/orm-mysql 0.8.0 → 0.8.3

package/README.md

@@ -14,7 +14,7 @@ npm install @axiosleo/orm-mysql
 
 ## Usage
 
-### Create mysql client
+### Create MySQL client
 
 ```javascript
 const { createClient } = require("@axiosleo/orm-mysql");
@@ -230,7 +230,7 @@ const hanlder = new QueryHandler(conn, {
 
 ## License
 
-This project is open-sourced software licensed under the [MIT](LICENSE).
+This project is open-sourced software licensed under [MIT](LICENSE).
 
 
 [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql?ref=badge_large)

package/index.d.ts

@@ -13,7 +13,7 @@ import {
 } from 'mysql2/promise';
 
 export type Clients = {
-  [key: string]: Connection
+  [key: string]: Connection | Pool
 }
 
 export type ConditionValueType = null | string | number | boolean | Date | Array<string | number | boolean | Date> | Query;
@@ -108,10 +108,10 @@ export declare class Query {
 export type QueryResult = any | undefined | RowDataPacket[] | RowDataPacket | OkPacket;
 
 export declare class QueryOperator extends Query {
-  conn: Connection;
+  conn: Connection | Pool;
   options: QueryOperatorOptions
 
-  constructor(conn: Connection, opt?: QueryOperatorBaseOptions);
+  constructor(conn: Connection | Pool, opt?: QueryOperatorBaseOptions);
 
   buildSql(operator: OperatorType): { sql: string, values: any[] };
 
@@ -136,10 +136,10 @@ export declare class QueryOperator extends Query {
 }
 
 export declare class QueryHandler {
-  conn: Connection;
+  conn: Connection | Pool;
   options: QueryOperatorBaseOptions;
 
-  constructor(conn: Connection, options?: QueryOperatorBaseOptions);
+  constructor(conn: Connection | Pool, options?: QueryOperatorBaseOptions);
 
   /**
    * select table
@@ -200,7 +200,7 @@ export declare class TransactionHandler {
 
 export function createClient(options: ConnectionOptions, name?: string | null | undefined): Connection;
 
-export function getClient(name: string): Connection;
+export function getClient(name: string): Connection | Pool;
 
 export function createPool(options: PoolOptions, name?: string | null | undefined): Pool;
 
@@ -253,3 +253,15 @@ export declare class Builder {
   values: any[];
   constructor(options: QueryOperatorOptions);
 }
+
+export declare class MySQLClient extends QueryHandler {
+  constructor(options?: ConnectionOptions, name?: string | null | undefined);
+
+  existDatabase(database?: string): Promise<boolean>;
+
+  existTable(database: string, table: string): Promise<boolean>;
+
+  exexQuery(query: Query, operator: OperatorType): Promise<QueryResult>;
+
+  close(): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.8.0",
+  "version": "0.8.3",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",

package/src/builder.js

@@ -149,10 +149,16 @@ class Builder {
       throw new Error('At least one table is required');
     }
     return tables.map((t) => {
+      let name = t.tableName.split('.').map((n) => {
+        if (n[0] === '`' && n[n.length - 1] === '`') {
+          return n;
+        }
+        return `\`${n}\``;
+      }).join('.');
       if (t.alias) {
-        return `\`${t.tableName}\` AS \`${t.alias}\``;
+        return `${name} AS \`${t.alias}\``;
       }
-      return `\`${t.tableName}\``;
+      return name;
     }).join(' , ');
   }
 

package/src/client.js

@@ -2,7 +2,9 @@
 
 const mysql = require('mysql2');
 const mysqlPromise = require('mysql2/promise');
-const { validate } = require('./utils');
+const { _validate } = require('./utils');
+const { QueryHandler, Query } = require('./operator');
+const { _query } = require('./utils');
 
 const clients = {};
 
@@ -12,7 +14,7 @@ const clients = {};
  * @returns {mysql.Connection}
  */
 const createClient = (options, name = null) => {
-  validate(options, {
+  _validate(options, {
     host: 'required|string',
     user: 'required|string',
     password: 'required|string',
@@ -35,7 +37,7 @@ const createClient = (options, name = null) => {
  * @returns {mysqlPromise.Connection}
  */
 const createPromiseClient = async (options, name = null) => {
-  validate(options, {
+  _validate(options, {
     host: 'required|string',
     user: 'required|string',
     password: 'required|string',
@@ -57,7 +59,7 @@ const createPromiseClient = async (options, name = null) => {
  * @returns {mysql.Pool}
  */
 const createPool = (options, name = null) => {
-  validate(options, {
+  _validate(options, {
     host: 'required|string',
     user: 'required|string',
     password: 'required|string',
@@ -89,7 +91,58 @@ const getClient = (name) => {
   return clients[name];
 };
 
+class MySQLClient extends QueryHandler {
+
+  /**
+   * @param {mysql.ConnectionOptions} options 
+   * @param {*} name 
+   */
+  constructor(options, name = 'default') {
+    const conn = createClient(options, name);
+    super(conn);
+  }
+
+  async existTable(database, table) {
+    const c = await this.table('information_schema.TABLES')
+      .where('TABLE_SCHEMA', database)
+      .where('TABLE_NAME', table)
+      .count();
+    return !!c;
+  }
+
+  async existDatabase(database) {
+    const c = await this.table('information_schema.SCHEMATA')
+      .where('SCHEMA_NAME', database)
+      .count();
+    return !!c;
+  }
+
+  /**
+   * @param {import('./operator').Query} query 
+   */
+  async exexQuery(query, operator = null) {
+    if (query instanceof Query) {
+      query.options.operator = operator;
+      return await _query(this.conn, query.options);
+    }
+  }
+
+  async close() {
+    return new Promise((resolve, reject) => {
+      this.conn.end((err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+}
+
 module.exports = {
+  MySQLClient,
+
   getClient,
   createPool,
   createClient,

package/src/operator.js

@@ -3,42 +3,7 @@
 const { Builder } = require('./builder');
 const Query = require('./query');
 const Hook = require('./hook');
-
-const query = async (conn, options, opt = null) => {
-  switch (options.driver) {
-    case 'mysql': {
-      if (opt === null) {
-        const builder = new Builder(options);
-        opt = {
-          sql: builder.sql,
-          values: builder.values || [],
-        };
-      }
-      return new Promise((resolve, reject) => {
-        if (options.transaction) {
-          conn.execute(opt)
-            .then((res) => resolve(res))
-            .catch((err) => reject(err));
-        } else {
-          conn.query(opt, (err, result) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(result);
-            }
-          });
-        }
-      });
-    }
-    default: {
-      const promise = options.query_handler(conn, options, opt);
-      if (!(promise instanceof Promise)) {
-        throw new Error('query_handler must return a promise');
-      }
-      return promise;
-    }
-  }
-};
+const { _query } = require('./utils');
 
 class QueryOperator extends Query {
   /**
@@ -77,17 +42,17 @@ class QueryOperator extends Query {
     try {
       switch (this.options.operator) {
         case 'find': {
-          const tmp = await query(this.conn, this.options);
+          const tmp = await _query(this.conn, this.options);
           res = tmp[0];
           break;
         }
         case 'count': {
-          const [tmp] = await query(this.conn, this.options);
+          const [tmp] = await _query(this.conn, this.options);
           res = tmp.count;
           break;
         }
         default:
-          res = await query(this.conn, this.options);
+          res = await _query(this.conn, this.options);
       }
       Hook.listen({ label: 'post', table: from, opt: this.options.operator }, this.options, res);
     } catch (err) {
@@ -140,18 +105,23 @@ class QueryOperator extends Query {
 class QueryHandler {
   constructor(conn, options = {}) {
     this.conn = conn;
-    this.optinos = options;
+    this.options = options;
   }
 
+  /**
+   * 
+   * @param {import('mysql2').QueryOptions} opt 
+   * @returns 
+   */
   async query(opt) {
     if (!opt) {
       throw new Error('opt is required');
     }
-    return await query(this.conn, this.options, opt);
+    return await _query(this.conn, this.options, opt);
   }
 
   table(table, alias = null) {
-    return (new QueryOperator(this.conn, this.optinos)).table(table, alias);
+    return (new QueryOperator(this.conn, this.options)).table(table, alias);
   }
 
   async upsert(tableName, data, condition = {}) {

package/src/utils.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const Validator = require('validatorjs');
+const { Builder } = require('./builder');
 
-const validate = (obj, rules) => {
+const _validate = (obj, rules) => {
   let validation = new Validator(obj, rules);
   validation.check();
   if (validation.fails()) {
@@ -12,6 +13,43 @@ const validate = (obj, rules) => {
   }
 };
 
+const _query = async (conn, options, opt = null) => {
+  switch (options.driver) {
+    case 'mysql': {
+      if (opt === null) {
+        const builder = new Builder(options);
+        opt = {
+          sql: builder.sql,
+          values: builder.values || [],
+        };
+      }
+      return new Promise((resolve, reject) => {
+        if (options.transaction) {
+          conn.execute(opt)
+            .then((res) => resolve(res))
+            .catch((err) => reject(err));
+        } else {
+          conn.query(opt, (err, result) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(result);
+            }
+          });
+        }
+      });
+    }
+    default: {
+      const promise = options.query_handler(conn, options, opt);
+      if (!(promise instanceof Promise)) {
+        throw new Error('query_handler must return a promise');
+      }
+      return promise;
+    }
+  }
+};
+
 module.exports = {
-  validate
+  _validate,
+  _query
 };