@axiosleo/orm-mysql 0.0.1 → 0.1.0-alpha.3

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

@@ -6,42 +6,42 @@ import {
   ConnectionOptions
 } from 'mysql2';
 
-type Clients = {
+export type Clients = {
   [key: string]: Connection
 }
 
-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>;
 
-type OptType = '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE'
+export 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 {
+export interface WhereOptions {
   key: string | null;
   opt: OptType;
   value: ConditionValueType | WhereOptions[];
 }
 
-interface OrderByOptions {
+export interface OrderByOptions {
   sortField: string,
   sortOrder: 'asc' | 'desc'
 }
 
-type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count';
+export type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count';
 
-interface JoinOption {
+export interface JoinOption {
   table: string;
   alias: string;
   on: string;
   type: 'left' | 'right' | 'inner';
 }
 
-interface TableOption {
+export interface TableOption {
   tableName: string;
   alias: string | null;
 }
 
-interface QueryOperatorOptions {
+export interface QueryOperatorOptions {
   sql: string;
   values: any[];
   conditions: WhereOptions[];
@@ -70,6 +70,8 @@ export declare class QueryOperator {
 
   where(key: string | null, value: ConditionValueType | WhereOptions[], opt?: OptType): this;
 
+  whereObject(obj: Record<string, ConditionValueType>): this;
+
   whereConditions(...condition: WhereOptions[]): this;
 
   orWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
@@ -101,6 +103,8 @@ export declare class QueryOperator {
   insert(data?: any): Promise<OkPacket>;
 
   count(): Promise<number>;
+
+  delete(id?: number): Promise<OkPacket>;
 }
 
 export declare class QueryHandler {
@@ -112,9 +116,9 @@ export declare class QueryHandler {
 
   query(options: QueryOptions): Promise<any>;
 
-  upsert(tableName: string, obj: any, condition: WhereOptions[]): Promise<OkPacket>;
+  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/package.json

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

package/runtimes/test.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { debug } = require('@axiosleo/cli-tool');
+const mm = require('mm');
+// const expect = require('chai').expect;
+const mysql = require('mysql2');
+const { QueryHandler } = require('../src/query');
+
+mm(mysql, 'createConnection', (options) => {
+  return {
+
+  };
+});
+
+const conn = mysql.createConnection({});
+const hanlder = new QueryHandler(conn);
+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` = ?');
+

package/src/builder.js

@@ -2,15 +2,36 @@
 
 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) {
+  if (key === null) {
     return '';
   }
-  return key.split('.').map((k) => `\`${k}\``).join('.');
+  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);
 };
 
 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) => {
@@ -20,6 +41,19 @@ const _buildContidion = (conditions, prefix) => {
       if (c.value === null) {
         return c.opt === '=' ? `ISNULL(${_buildFieldKey(c.key)})` : `!ISNULL(${_buildFieldKey(c.key)})`;
       }
+      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;
+      }
       const opt = c.opt.toLowerCase();
       if (opt === 'in' && Array.isArray(c.value)) {
         values.push(c.value.join(','));
@@ -44,10 +78,6 @@ const _buildValues = (obj) => {
   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 {
@@ -128,7 +158,7 @@ const buildSql = (options) => {
     case 'update': {
       const buildValueRes = _buildValues(options.data);
       sql = `UPDATE ${_buildTables(options.tables)} SET ${buildValueRes.fields.map(f => `${_buildFieldKey(f)} = ?`).join(',')}`;
-      values = values.concat(values);
+      values = values.concat(buildValueRes.values);
       const buildConditionRes = _buildContidion(options.conditions);
       sql += buildConditionRes.sql;
       values = values.concat(buildConditionRes.values);

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/query.js

@@ -60,6 +60,11 @@ class QueryOperator {
     return this;
   }
 
+  whereObject(object = {}) {
+    Object.keys(object).forEach((key) => this.where(key, object[key]));
+    return this;
+  }
+
   whereConditions(...condition) {
     if (this.options.conditions.length) {
       this.options.conditions.push({ key: null, opt: 'AND', value: null });
@@ -102,7 +107,7 @@ class QueryOperator {
     return this;
   }
 
-  orderBy(sortField, sortOrder) {
+  orderBy(sortField, sortOrder = 'asc') {
     this.options.orders.push({ sortField, sortOrder });
     return this;
   }
@@ -165,8 +170,7 @@ class QueryOperator {
 
   async find() {
     this.options.operator = 'find';
-    const [res] = await this.exec();
-    return res;
+    return await this.exec();
   }
 
   async update(data) {
@@ -187,8 +191,15 @@ class QueryOperator {
 
   async count() {
     this.options.operator = 'count';
-    const res = await this.exec();
-    return res;
+    return await this.exec();
+  }
+
+  async delete(id) {
+    if (id) {
+      this.where('id', id);
+    }
+    this.options.operator = 'delete';
+    return await this.exec();
   }
 }
 
@@ -216,12 +227,12 @@ class QueryHandler {
     });
   }
 
-  async upsert(tableName, obj, condition = []) {
-    const [row] = await this.table(tableName).whereConditions(...condition).select();
-    if (row) {
-      return await this.table(tableName).update(obj);
+  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(obj);
+    return await this.table(tableName).insert(data);
   }
 }