groupcore-utils 2.2.0 → 3.0.0

package/database/crud.js

@@ -39,11 +39,45 @@ module.exports = class {
   /**
    * @method read()
    * @description get data from table
-   * @param {Object} where - if no where, all the data will be returned from db table without any 'where' clause.  shape {field, value}
+   * @param {Object} where - if no where, all the data will be returned from db table without any 'where' clause.
+   * shape {fields (array of fields {field, value}), condition array ("and" or "or") to correspond with fields}
    * @param {Array} orderBy - explicitly specify the order, either asc or desc
    * @returns {Promise}
    */
   read({ where, orderBy }) {
+    if (where && !_.has(where, 'fields')) {
+      return this.readV1({ where, orderBy });
+    }
+
+    let query;
+    let whereClause = '';
+    if (where) {
+      where.fields.forEach((field, i) => {
+        if (_.last(where.fields) === field) {
+          whereClause += `${field.field} = '${field.value}'`;
+        } else {
+          whereClause += `${field.field} = '${field.value}' ${where.conditions[i]} `;
+        }
+      });
+    }
+
+    if (orderBy) {
+      if (where) {
+        query = `select * from ${this.dbTable} where ${whereClause} order by ${orderBy}`;
+      } else {
+        query = `select * from ${this.dbTable} order by ${orderBy}`;
+      }
+    } else if (where) {
+      query = `select * from ${this.dbTable} where ${whereClause}`;
+    } else {
+      query = `select * from ${this.dbTable}`;
+    }
+
+    return this.db.query(query);
+  }
+
+  // should be deprecated soon
+  readV1({ where, orderBy }) {
     let query;
 
     if (orderBy) {
@@ -61,19 +95,6 @@ module.exports = class {
     return this.db.query(query);
   }
 
-  // with orderby
-  // readOrderBy(where = null) {
-  //   let query;
-  //
-  //   if (where) {
-  //     query = `select * from ${this.dbTable} where ${where.field} = '${where.value}'`;
-  //   } else {
-  //     query = `select * from ${this.dbTable}`;
-  //   }
-  //
-  //   return new Db().query(query);
-  // }
-
   /**
    * @method update
    * @description update db table by id
@@ -121,39 +142,4 @@ module.exports = class {
   query({ statement }) {
     return this.db.query(statement);
   }
-
-  /**
-   * @method join
-   * @description join two or more tables during db query
-   * @param tables {array} - list of tables to join, object in the shape {table: <string>, fields: <array>}
-   * @param joins {array} - list of the joins in the shape {table: <string>, id: <string>}
-   * @param whereClauses {array} - list of where clauses in the shape {table: <string>, key: <string>, value: <string|integer>}
-   * @param mainTable {string} -  the main table from the to join others
-   * @param mainId {string} - the id to join on the main table, expected to be the primary key if the main table
-   */
-  join({ tables = [], joins = [], whereClauses = [], mainTable, mainId }) {
-    // build join query
-    let query = 'select ';
-    tables.forEach((table) => {
-      table.fields.forEach((field) => {
-        query += `${table.table}.${field}, `;
-      });
-    });
-
-    query += `from ${mainTable} `;
-
-    joins.forEach((join) => {
-      query += `inner join ${join.table} on ${mainTable}.${mainId} = ${join.table}.${join.id} `;
-    });
-
-    query += ' where ';
-    whereClauses.forEach((clause) => {
-      query += `${clause.table}.${clause.key} = ${clause.value} `;
-    });
-
-    query = query.replace(', from', ' from');
-    query = query.replace(' where', 'where');
-
-    return query.trim();
-  }
 };

package/database/crud.spec.js

@@ -1,36 +1,124 @@
+const mysql = require('mysql');
 const Crud = require('./crud');
+const Init = require('./init');
 
-test('should generate the join right query - 2 tables', () => {
-  const tables = [
-    { table: 'users', fields: ['name', 'address'] },
-    { table: 'categories', fields: ['name'] },
-  ];
+jest.spyOn(mysql, 'createConnection').mockImplementation(() => {
+  console.log('connected');
+});
 
-  const joins = [{ table: 'categories', id: 'user' }];
+const db = new Init({ host: '', user: '', password: '', db: '' });
+describe('read()', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  it('should work when "where" is an object', async () => {
+    expect.hasAssertions();
 
-  const whereClauses = [{ table: 'users', key: 'id', value: 10 }];
-  const query = new Crud({ dbTable: 'test', db: 'test' }).join({ tables, joins, whereClauses, mainTable: 'users', mainId: 'id' });
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({ where: { field: 'id', value: '10' }, orderBy: null });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = '10'");
+    expect(querySpy).toHaveBeenCalledTimes(1);
+  });
 
-  expect(query).toBe('select users.name, users.address, categories.name from users inner join categories on users.id = categories.user where users.id = 10');
-});
+  it('should work when "where" is an array of objects with "and" condition', async () => {
+    expect.hasAssertions();
+
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: {
+        conditions: ['and'],
+        fields: [
+          { field: 'id', value: '10' },
+          { field: 'username', value: 'test' },
+        ],
+      },
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = '10' and username = 'test'");
+  });
+
+  it('should work when "where" is an array of objects with "or" condition', async () => {
+    expect.hasAssertions();
+
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: {
+        conditions: ['or'],
+        fields: [
+          { field: 'id', value: '10' },
+          { field: 'tag', value: 'test' },
+        ],
+      },
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = '10' or tag = 'test'");
+  });
+
+  it('should work when "where" has just one in array', async () => {
+    expect.hasAssertions();
+
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: {
+        conditions: null,
+        fields: [{ field: 'id', value: '10' }],
+      },
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = '10'");
+  });
+
+  it('should work when "where" is an array of objects with multiple conditions', async () => {
+    expect.hasAssertions();
 
-test('should generate the right join query - 3 tables', () => {
-  const tables = [
-    { table: 'users', fields: ['name', 'address'] },
-    { table: 'categories', fields: ['name'] },
-    { table: 'ages', fields: ['age'], id: 'user' },
-  ];
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: {
+        conditions: ['or', 'and'],
+        fields: [
+          { field: 'id', value: '10' },
+          { field: 'tag', value: 'test' },
+          { field: 'slug', value: 'testslug' },
+        ],
+      },
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = '10' or tag = 'test' and slug = 'testslug'");
+  });
 
-  const joins = [
-    { table: 'categories', id: 'user' },
-    { table: 'ages', id: 'user' },
-  ];
+  it('should work without any conditions', async () => {
+    expect.hasAssertions();
 
-  const whereClauses = [{ table: 'users', key: 'id', value: 10 }];
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: null,
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith('select * from test');
+  });
 
-  const query = new Crud({ dbTable: 'test', db: 'test' }).join({ tables, joins, whereClauses, mainTable: 'users', mainId: 'id' });
+  it('should support deprecated usage', async () => {
+    expect.hasAssertions();
 
-  expect(query).toBe(
-    'select users.name, users.address, categories.name, ages.age from users inner join categories on users.id = categories.user inner join ages on users.id = ages.user where users.id = 10'
-  );
+    const querySpy = jest.spyOn(Init.prototype, 'query').mockImplementation(() => {
+      console.log('query called');
+    });
+    await new Crud({ dbTable: 'test', db }).read({
+      where: { field: 'id', value: 'test' },
+      orderBy: null,
+    });
+    expect(querySpy).toHaveBeenCalledWith("select * from test where id = 'test'");
+  });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groupcore-utils",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Utilities for working with some core features",
   "main": "Utils.js",
   "scripts": {
@@ -17,13 +17,14 @@
   },
   "homepage": "https://bitbucket.org/thegroupc/groupcore-utils/src/master",
   "dependencies": {
-    "lodash": "^4.17.21",
     "axios": "^0.26.1",
     "bcrypt": "^5.0.1",
     "easy-rbac": "^3.2.0",
     "escape-quotes": "^1.0.2",
     "jsonwebtoken": "^8.5.1",
+    "lodash": "^4.17.21",
     "moment": "^2.29.2",
+    "mysql": "^2.18.1",
     "nodemailer": "^6.7.3",
     "random-number": "^0.0.9"
   },