@axiosleo/orm-mysql 0.0.1

package/.eslintrc

@@ -0,0 +1,114 @@
+{
+  "rules": {
+    "indent": [
+      2,
+      2,
+      {
+        "SwitchCase": 1
+      }
+    ],
+    "quotes": [
+      2,
+      "single"
+    ],
+    "linebreak-style": [
+      2,
+      "unix"
+    ],
+    "semi": [
+      2,
+      "always"
+    ],
+    "strict": [
+      2,
+      "global"
+    ],
+    "curly": 2,
+    "eqeqeq": 2,
+    "no-eval": 2,
+    "guard-for-in": 2,
+    "no-caller": 2,
+    "no-else-return": 2,
+    "no-eq-null": 2,
+    "no-extend-native": 2,
+    "no-extra-bind": 2,
+    "no-floating-decimal": 2,
+    "no-implied-eval": 2,
+    "no-labels": 2,
+    "no-with": 2,
+    "no-loop-func": 2,
+    "no-native-reassign": 2,
+    "no-redeclare": [
+      2,
+      {
+        "builtinGlobals": true
+      }
+    ],
+    "no-delete-var": 2,
+    "no-shadow-restricted-names": 2,
+    "no-undef-init": 2,
+    "no-use-before-define": 2,
+    "no-unused-vars": [
+      2,
+      {
+        "args": "none"
+      }
+    ],
+    "no-undefined": 2,
+    "no-undef": 2,
+    "global-require": 0,
+    "no-console": 2,
+    "key-spacing": [
+      2,
+      {
+        "beforeColon": false,
+        "afterColon": true
+      }
+    ],
+    "eol-last": [
+      2,
+      "always"
+    ],
+    "no-inner-declarations": [
+      1
+    ],
+    "no-case-declarations": [
+      1
+    ],
+    "no-multiple-empty-lines": [
+      2,
+      {
+        "max": 1,
+        "maxBOF": 1
+      }
+    ],
+    "space-in-parens": [
+      2,
+      "never"
+    ],
+    "no-multi-spaces": [
+      2,
+      {
+        "ignoreEOLComments": true
+      }
+    ]
+  },
+  "env": {
+    "es6": true,
+    "node": true,
+    "browser": true
+  },
+  "globals": {
+    "describe": true,
+    "it": true,
+    "before": true,
+    "after": true,
+    "beforeEach": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "script",
+    "ecmaFeatures": {}
+  },
+  "extends": "eslint:recommended"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 AxiosLeo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# node-orm-mysql
+MySQL ORM tool

package/index.d.ts

@@ -0,0 +1,120 @@
+import {
+  OkPacket,
+  Connection,
+  QueryOptions,
+  RowDataPacket,
+  ConnectionOptions
+} from 'mysql2';
+
+type Clients = {
+  [key: string]: Connection
+}
+
+type ConditionValueType = null | string | number | boolean | Date | Array<string | number | boolean | Date>;
+
+type OptType = '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE'
+  | 'NOT LIKE' | 'IN' | 'NOT IN' | 'BETWEEN' | 'NOT BETWEEN' | 'IS' | 'IS NOT' | 'REGEXP' | 'NOT REGEXP'
+  | 'AND' | 'OR' | 'GROUP' | 'like' | 'not like' | 'in' | 'not in' | 'between' | 'not between' | 'is' | 'is not' | 'regexp' | 'not regexp' | 'group';
+
+interface WhereOptions {
+  key: string | null;
+  opt: OptType;
+  value: ConditionValueType | WhereOptions[];
+}
+
+interface OrderByOptions {
+  sortField: string,
+  sortOrder: 'asc' | 'desc'
+}
+
+type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count';
+
+interface JoinOption {
+  table: string;
+  alias: string;
+  on: string;
+  type: 'left' | 'right' | 'inner';
+}
+
+interface TableOption {
+  tableName: string;
+  alias: string | null;
+}
+
+interface QueryOperatorOptions {
+  sql: string;
+  values: any[];
+  conditions: WhereOptions[];
+  attrs?: string[] | null;
+  orders: OrderByOptions[];
+  pageLimit?: number;
+  pageOffset?: number;
+  tables: TableOption[];
+  operator: OperatorType | null;
+  data: any | null;
+  groupField: string[];
+  joins: JoinOption[]
+}
+
+export declare class QueryOperator {
+  conn: Connection;
+  options: QueryOperatorOptions
+
+  constructor(conn: Connection, table: TableOption);
+
+  table(tableName: string, alias: string | null): this;
+
+  limit(limit: number): this;
+
+  offset(offset: number): this;
+
+  where(key: string | null, value: ConditionValueType | WhereOptions[], opt?: OptType): this;
+
+  whereConditions(...condition: WhereOptions[]): this;
+
+  orWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+
+  andWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+
+  attr(...attr: string[]): this;
+
+  orderBy(sortField: string, sortOrder: 'asc' | 'desc'): this;
+
+  groupBy(...groupField: string[]): this;
+
+  page(limit: number, offset?: number): this;
+
+  set(data: any): this;
+
+  join(table: string, alias: string, on: string, type: 'left' | 'right' | 'inner'): this;
+
+  buildSql(operator: OperatorType): { sql: string, values: any[] };
+
+  exec(): Promise<any | undefined | RowDataPacket[] | RowDataPacket | OkPacket>;
+
+  select<T>(): Promise<T[]>;
+
+  find<T>(): Promise<T>;
+
+  update(data?: any): Promise<OkPacket>;
+
+  insert(data?: any): Promise<OkPacket>;
+
+  count(): Promise<number>;
+}
+
+export declare class QueryHandler {
+  conn: Connection;
+
+  constructor(conn: Connection);
+
+  table(table: string, alias?: string | null): QueryOperator;
+
+  query(options: QueryOptions): Promise<any>;
+
+  upsert(tableName: string, obj: any, condition: WhereOptions[]): Promise<OkPacket>;
+}
+
+export function createClient(options: ConnectionOptions): Connection;
+
+export function getClient(name: string): Connection;

package/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const {
+  QueryHandler,
+  QueryOperator
+} = require('./src/query');
+
+const { createClient, getClient } = require('./src/client');
+
+module.exports = {
+  QueryHandler,
+  QueryOperator,
+
+  getClient,
+  createClient
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@axiosleo/orm-mysql",
+  "version": "0.0.1",
+  "description": "MySQL ORM tool",
+  "keywords": [
+    "mysql",
+    "orm"
+  ],
+  "author": "AxiosLeo",
+  "directories": {
+    "lib": "src"
+  },
+  "scripts": {
+    "lint": "tsc ./index.d.ts && eslint --fix src/",
+    "test": "mocha --reporter spec --timeout 3000 tests/*.tests.js",
+    "test-cov": "nyc -r=lcov -r=html -r=text -r=json mocha -t 10000 -R spec tests/*.tests.js",
+    "ci": "npm run lint && npm run test-cov",
+    "clear": "rm -rf ./nyc_output ./coverage"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@axiosleo/cli-tool": "^1.4.11",
+    "mysql2": "^2.3.3",
+    "validatorjs": "^3.22.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AxiosLeo/node-orm-mysql"
+  },
+  "devDependencies": {
+    "@types/node": "^15.12.1",
+    "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
+    "eslint": "^7.0",
+    "expect.js": "^0.3.1",
+    "has-flag": "^4.0.0",
+    "mm": "^3.2.0",
+    "mocha": "^9.1.3",
+    "mocha-sinon": "^2.1.2",
+    "pre-commit": "^1.2.2",
+    "sinon": "^9.0.2",
+    "typescript": "^4.3.2"
+  },
+  "pre-commit": {
+    "silent": false,
+    "run": [
+      "lint"
+    ]
+  }
+}

package/src/builder.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const is = require('@axiosleo/cli-tool/src/helper/is');
+
+const _buildFieldKey = (key) => {
+  if (!key) {
+    return '';
+  }
+  return key.split('.').map((k) => `\`${k}\``).join('.');
+};
+
+const _buildContidion = (conditions, prefix) => {
+  const values = [];
+  let sql = typeof prefix === 'undefined' ? ' WHERE ' : '';
+  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(${_buildFieldKey(c.key)})` : `!ISNULL(${_buildFieldKey(c.key)})`;
+      }
+      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})`;
+      }
+      values.push(c.value);
+      return `${_buildFieldKey(c.key)} ${c.opt} ?`;
+    }).join('')}`;
+  }
+  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;
+    }
+    if (Array.isArray(obj[key]) || is.object(obj[key])) {
+      values.push(JSON.stringify(obj[key]));
+    } else {
+      values.push(obj[key]);
+    }
+  });
+  return { fields, values };
+};
+
+const _buldPagenation = (limit, offset) => {
+  let sql = '';
+  if (limit) {
+    sql += ` LIMIT ${limit}`;
+  }
+  if (offset) {
+    sql += ` OFFSET ${offset}`;
+  }
+  return sql;
+};
+
+const _buildTables = (tables) => {
+  return tables.map((t) => {
+    if (t.alias) {
+      return `\`${t.tableName}\` AS \`${t.alias}\``;
+    }
+    return `\`${t.tableName}\``;
+  }).join(' , ');
+};
+
+const _buildOrders = (orders = []) => {
+  const sql = ' ORDER BY ' + orders.map((o) => {
+    return `\`${o.sortField}\` ${o.sortOrder}`;
+  }).join(',');
+  return sql;
+};
+
+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}`;
+    }
+  }).join(' ');
+};
+
+const buildSql = (options) => {
+  let sql = options.sql;
+  let values = options.values;
+  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) => _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(',')}`;
+      }
+      break;
+    }
+    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;
+    }
+    case 'update': {
+      const buildValueRes = _buildValues(options.data);
+      sql = `UPDATE ${_buildTables(options.tables)} SET ${buildValueRes.fields.map(f => `${_buildFieldKey(f)} = ?`).join(',')}`;
+      values = values.concat(values);
+      const buildConditionRes = _buildContidion(options.conditions);
+      sql += buildConditionRes.sql;
+      values = values.concat(buildConditionRes.values);
+      break;
+    }
+    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;
+    }
+    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;
+    }
+    default:
+      throw new Error('Invalid operator: ' + options.operator);
+  }
+
+  return {
+    sql,
+    values: values
+  };
+};
+
+module.exports = {
+  buildSql
+};

package/src/client.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const mysql = require('mysql2');
+const { validate } = require('./utils');
+
+const clients = {};
+
+/**
+ * initialize client
+ * @param {mysql.ConnectionOptions} options
+ * @returns {mysql.Connection}
+ */
+const createClient = (options) => {
+  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 :
+    `${options.host}:${options.port}:${options.user}:${options.password}:${options.database}`;
+  if (clients[key]) {
+    return clients[key];
+  }
+  clients[key] = mysql.createConnection(options);
+  clients[key].connect();
+  return clients[key];
+};
+
+/**
+ * get client
+ * @param {*} name 
+ * @returns {mysql.Connection}
+ */
+const getClient = (name) => {
+  if (!name) {
+    throw new Error('name is required');
+  }
+  if (!clients[name]) {
+    throw new Error(`client ${name} not found`);
+  }
+  return clients[name];
+};
+
+module.exports = {
+  getClient,
+  createClient
+};

package/src/query.js

@@ -0,0 +1,231 @@
+'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;
+    this.options = {
+      sql: '',
+      values: [],
+      conditions: [],
+      orders: [],
+      tables: [],
+      operator: null,
+      data: null,
+      groupField: [],
+    };
+    this.options.tables.push(table);
+  }
+
+  table(tableName, alias) {
+    this.options.tables.push({ tableName, alias });
+    return this;
+  }
+
+  limit(limit) {
+    this.options.pageLimit = limit;
+    return this;
+  }
+
+  offset(offset) {
+    this.options.pageOffset = offset;
+    return this;
+  }
+
+  where(key, value, opt = '=') {
+    if (this.options.conditions.length) {
+      this.options.conditions.push({ key: null, opt: 'AND', value: null });
+    }
+    this.options.conditions.push({
+      key, opt, value,
+    });
+    return this;
+  }
+
+  whereConditions(...condition) {
+    if (this.options.conditions.length) {
+      this.options.conditions.push({ key: null, opt: 'AND', value: null });
+    }
+    condition.forEach((c) => {
+      this.options.conditions.push(c);
+    });
+    return this;
+  }
+
+  orWhere(key, opt, value) {
+    if (!this.options.conditions.length) {
+      throw new Error('At least one where condition is required');
+    }
+    this.options.conditions.push({
+      key: null,
+      opt: 'OR',
+      value: null
+    }, { key, opt, value });
+    return this;
+  }
+
+  andWhere(key, opt, value) {
+    if (!this.options.conditions.length) {
+      throw new Error('At least one where condition is required');
+    }
+    this.options.conditions.push({
+      key: null,
+      opt: 'AND',
+      value: null
+    }, { key, opt, value });
+    return this;
+  }
+
+  attr(...attr) {
+    if (!this.options.attrs) {
+      this.options.attrs = [];
+    }
+    this.options.attrs.push(...attr);
+    return this;
+  }
+
+  orderBy(sortField, sortOrder) {
+    this.options.orders.push({ sortField, sortOrder });
+    return this;
+  }
+
+  groupBy(...groupField) {
+    this.options.groupField.push(...groupField);
+    return this;
+  }
+
+  page(limit, offset = 0) {
+    this.options.pageLimit = limit;
+    this.options.pageOffset = offset;
+    return this;
+  }
+
+  set(data) {
+    if (!this.options.data) {
+      this.options.data = {};
+    }
+    Object.assign(this.options.data, data);
+    return this;
+  }
+
+  join(table, alias, on, type) {
+    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';
+    const [res] = await this.exec();
+    return res;
+  }
+
+  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';
+    const res = await this.exec();
+    return res;
+  }
+}
+
+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, obj, condition = []) {
+    const [row] = await this.table(tableName).whereConditions(...condition).select();
+    if (row) {
+      return await this.table(tableName).update(obj);
+    }
+    return await this.table(tableName).insert(obj);
+  }
+}
+
+module.exports = {
+  QueryOperator,
+  QueryHandler
+};

package/src/utils.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const Validator = require('validatorjs');
+
+const validate = (obj, rules) => {
+  let validation = new Validator(obj, rules);
+  validation.check();
+  if (validation.fails()) {
+    const errors = validation.errors.all();
+    const keys = Object.keys(errors);
+    throw new Error(`${keys[0]}: ${errors[keys[0]]}`);
+  }
+};
+
+module.exports = {
+  validate
+};