@axiosleo/orm-mysql 0.2.3 → 0.3.0

package/.env

@@ -3,4 +3,4 @@ MYSQL_HOST = "rm-bp1a906h4019pldm6io.mysql.rds.aliyuncs.com"
 MYSQL_USER = "kms"
 MYSQL_PASS = "bmPWuq_vJgupdL9"
 MYSQL_PORT = 3306
-MYSQL_DB = "factory-cloud-dev"
+MYSQL_DB = "business_5b5ecd9941d6cc1bbc065fc6"

package/index.d.ts

@@ -31,9 +31,10 @@ export type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' |
 
 export interface JoinOption {
   table: string;
-  alias: string;
-  on: string;
-  type: 'left' | 'right' | 'inner';
+  table_alias?: string;
+  self_column: string;
+  foreign_column: string;
+  join_type?: 'left' | 'right' | 'inner';
 }
 
 export interface TableOption {
@@ -42,8 +43,6 @@ export interface TableOption {
 }
 
 export interface QueryOperatorOptions {
-  sql: string;
-  values: any[];
   conditions: WhereOptions[];
   attrs?: string[] | null;
   orders: OrderByOptions[];
@@ -88,7 +87,7 @@ export declare class Query {
 
   set(data: any): this;
 
-  join(table: string, alias: string, on: string, type: 'left' | 'right' | 'inner'): this;
+  join(opt: JoinOption): this;
 }
 
 export declare class QueryOperator extends Query {

package/package.json

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

package/runtimes/test.js

@@ -1,32 +1,45 @@
 'use strict';
 
+const dotenv = require('dotenv');
+dotenv.config();
 const { debug } = require('@axiosleo/cli-tool');
-// const mm = require('mm');
-// // const expect = require('chai').expect;
-// const mysql = require('mysql2');
+
+const mysql = require('mysql2');
 const {
-  // QueryHandler,
-  Query
+  QueryHandler,
+  // Query
 } = require('../src/operator');
 
-// mm(mysql, 'createConnection', (options) => {
-//   return {
-
-//   };
-// });
-
-// const conn = mysql.createConnection({});
-// const hanlder = new QueryHandler(conn);
-// // const query = hanlder.table('meta_items', 'u');
-
-// 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);
-
-const q = new Query();
+const conn = mysql.createConnection({
+  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);
+
+const test = async () => {
+  const query = hanlder.table('meta_items_relationship', 'mir')
+    .attr('mi_p.meta as p_meta', 'mi_c.meta as c_meta', 'mir.item_parent as item_parent_id', 'mir.item_child as item_child_id');
+  const res = query
+    .where('mi_p.id', 601)
+    .join({
+      table: 'meta_items',
+      table_alias: 'mi_p',
+      self_column: 'mir.item_parent',
+      foreign_column: 'mi_p.id',
+      // join_type: 'left'
+    })
+    .join({
+      table: 'meta_items',
+      table_alias: 'mi_c',
+      self_column: 'mir.item_child',
+      foreign_column: 'mi_c.id',
+    }).buildSql('select');
+  const result = await query.select();
+  debug.halt(res, result);
+};
+
+test();
 
-debug.log(typeof q, q instanceof Query);

package/src/builder.js

@@ -5,9 +5,8 @@ const is = require('@axiosleo/cli-tool/src/helper/is');
 
 class Builder {
   constructor(options) {
-    let sql = options.sql;
-    this.values = options.values || [];
-
+    let sql = '';
+    this.values = [];
     switch (options.operator) {
       case 'find': {
         options.pageLimit = 1;
@@ -77,14 +76,26 @@ class Builder {
 
   _buildJoins(joins = []) {
     return joins.map((j) => {
-      switch (j.type) {
+      let { table, alias, self_column, foreign_column, join_type } = j;
+      if (alias) {
+        table = `\`${table}\` AS \`${alias}\``;
+      } else {
+        table = `\`${table}\``;
+      }
+      let sql = '';
+      switch (join_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}`;
+          sql = ' LEFT JOIN ';
+          break;
         case 'right':
-          return ` RIGHT JOIN \`${j.table}\` AS \`${j.alias}\` ON ${j.on}`;
+          sql = ' RIGHT JOIN ';
+          break;
+        default:
+          sql = ' INNER JOIN ';
+          break;
       }
+      sql += `${table} ON ${this._buildFieldWithTableName(self_column)} = ${this._buildFieldWithTableName(foreign_column)}`;
+      return sql;
     }).join(' ');
   }
 

package/src/query.js

@@ -3,8 +3,6 @@
 class Query {
   constructor(operator = 'select') {
     this.options = {
-      sql: '',
-      values: [],
       conditions: [],
       orders: [],
       tables: [],
@@ -31,7 +29,17 @@ class Query {
     return this;
   }
 
+  /**
+   * 
+   * @param {string} key 
+   * @param {any} value 
+   * @param {*} opt 
+   * @returns 
+   */
   where(key, value, opt = '=') {
+    if (!key) {
+      throw new Error('key is required');
+    }
     if (this.options.conditions.length) {
       this.options.conditions.push({ key: null, opt: 'AND', value: null });
     }
@@ -131,17 +139,25 @@ class Query {
     return this;
   }
 
-  join(table, alias, on, type) {
-    if (!alias) {
-      throw new Error('Alias is required');
+  /**
+   * @param {{table:string,table_alias?:string,self_column: string,foreign_column: string,join_type?: 'left' | 'right' | 'inner'}} opt 
+   * @returns 
+   */
+  join(opt = {}) {
+    let { table, table_alias, self_column, foreign_column, join_type } = opt;
+    if (!table) {
+      throw new Error('table is required');
+    }
+    if (!self_column) {
+      throw new Error('self_column is required');
     }
-    if (!on) {
-      throw new Error('On is required');
+    if (!foreign_column) {
+      throw new Error('foreign_column is required');
     }
-    if (['left', 'right', 'inner'].indexOf(type) === -1) {
-      throw new Error('Invalid join type : ' + type + '; only supported left, right, inner');
+    if (join_type && ['left', 'right', 'inner'].indexOf(join_type) === -1) {
+      throw new Error('Invalid join type : ' + join_type + '; only supported left, right, inner');
     }
-    this.options.joins.push({ table, alias, on, type });
+    this.options.joins.push({ table, alias: table_alias, self_column, foreign_column, join_type });
     return this;
   }
 }