mysql(insert, select, update, delete): return just the query

CHANGELOG.md

@@ -5,7 +5,10 @@
 ### 3.0.0-alpha.3
 
 - permission.get: default search with deleted=0
-
+- session.put: added
+- routes/permission: added GET, POST, DELETE
+- mysql(insert, select, update, delete): return just the query
+- 
 
 
 [3.0.0-alpha.3]: https://github.com/NicTool/api/releases/tag/3.0.0-alpha.3

lib/group.js

@@ -11,33 +11,24 @@ class Group {
   async create(args) {
     if (args.id) {
       const g = await this.get({ id: args.id })
-      if (g.length) return g[0].id
+      if (g.length === 1) return g[0].id
     }
 
-    return await Mysql.insert(
-      `INSERT INTO nt_group`,
-      mapToDbColumn(args, groupDbMap),
+    return await Mysql.execute(
+      ...Mysql.insert(`nt_group`, mapToDbColumn(args, groupDbMap)),
     )
   }
 
   async get(args) {
-    return await Mysql.select(
-      `SELECT nt_group_id AS id
+    return await Mysql.execute(
+      ...Mysql.select(
+        `SELECT nt_group_id AS id
         , parent_group_id AS parent_gid
         , name
-      FROM nt_group WHERE`,
-      mapToDbColumn(args, groupDbMap),
-    )
-  }
-
-  async getAdmin(args) {
-    return await Mysql.select(
-      `SELECT nt_group_id AS id
-      , name
-      , parent_group_id AS parent_gid
-      , deleted
-      FROM nt_group WHERE`,
-      mapToDbColumn(args, groupDbMap),
+        , deleted
+      FROM nt_group`,
+        mapToDbColumn(args, groupDbMap),
+      ),
     )
   }
 
@@ -46,30 +37,29 @@ class Group {
     const id = args.id
     delete args.id
     // Mysql.debug(1)
-    const r = await Mysql.update(
-      `UPDATE nt_group SET`,
-      `WHERE nt_group_id=${id}`,
-      mapToDbColumn(args, groupDbMap),
+    const r = await Mysql.execute(
+      ...Mysql.update(
+        `nt_group`,
+        `nt_group_id=${id}`,
+        mapToDbColumn(args, groupDbMap),
+      ),
     )
     // console.log(r)
     return r.changedRows === 1
   }
 
-  async delete(args, val) {
-    const g = await this.getAdmin(args)
-    if (g.length !== 1) return false
+  async delete(args) {
     await Mysql.execute(`UPDATE nt_group SET deleted=? WHERE nt_group_id=?`, [
-      val ?? 1,
-      g[0].id,
+      args.deleted ?? 1,
+      args.id,
     ])
     return true
   }
 
   async destroy(args) {
-    const g = await this.getAdmin(args)
-    if (g.length === 1) {
-      await Mysql.execute(`DELETE FROM nt_group WHERE nt_group_id=?`, [g[0].id])
-    }
+    return await Mysql.execute(
+      ...Mysql.delete(`nt_group`, { nt_group_id: args.id }),
+    )
   }
 }
 

lib/group.test.js

@@ -20,6 +20,7 @@ describe('group', function () {
       id: testCase.id,
       name: testCase.name,
       parent_gid: 0,
+      deleted: 0,
     })
   })
 
@@ -29,6 +30,7 @@ describe('group', function () {
       id: testCase.id,
       name: testCase.name,
       parent_gid: 0,
+      deleted: 0,
     })
   })
 
@@ -39,17 +41,18 @@ describe('group', function () {
         id: testCase.id,
         name: 'example.net',
         parent_gid: 0,
+        deleted: 0,
       },
     ])
     assert.ok(await Group.put({ id: testCase.id, name: testCase.name }))
   })
 
   it('deletes a group', async () => {
     assert.ok(await Group.delete({ id: testCase.id }))
-    let g = await Group.getAdmin({ id: testCase.id })
-    assert.equal(g[0].deleted, 1)
-    await Group.delete({ id: testCase.id }, 0) // restore
-    g = await Group.getAdmin({ id: testCase.id })
+    let g = await Group.get({ id: testCase.id, deleted: 1 })
+    assert.equal(g[0]?.deleted, 1)
+    await Group.delete({ id: testCase.id, deleted: 0 }) // restore
+    g = await Group.get({ id: testCase.id })
     assert.equal(g[0].deleted, 0)
   })
 })

lib/mysql.js

@@ -42,34 +42,26 @@ class Mysql {
     return rows
   }
 
-  async insert(query, params = {}) {
-    const skipExecute = params.skipExecute ?? false
-    delete params.skipExecute
-
-    query += `(${Object.keys(params).join(',')}) VALUES(${Object.keys(params).map(() => '?')})`
-
-    if (skipExecute) return query
-    return await this.execute(query, Object.values(params))
+  insert(table, params = {}) {
+    return [
+      `INSERT INTO ${table} (${Object.keys(params).join(',')}) VALUES(${Object.keys(params).map(() => '?')})`,
+      Object.values(params),
+    ]
   }
 
-  async select(query, params = {}) {
-    const skipExecute = params.skipExecute ?? false
-    delete params.skipExecute
-
-    const [queryWhere, paramsArray] = this.whereConditions(query, params)
-
-    if (skipExecute) return queryWhere
-    return await this.execute(queryWhere, paramsArray)
+  select(query, params = {}) {
+    return this.whereConditions(query, params)
   }
 
-  async update(query, where, params = {}) {
-    const skipExecute = params.skipExecute ?? false
-    delete params.skipExecute
-
-    query += ` ${Object.keys(params).join('=?,')}=? ${where}`
+  update(table, where, params = {}) {
+    return [
+      `UPDATE ${table} SET ${Object.keys(params).join('=?,')}=? WHERE ${where}`,
+      Object.values(params),
+    ]
+  }
 
-    if (skipExecute) return { q: query, p: Object.values(params) }
-    return await this.execute(query, Object.values(params))
+  delete(table, params) {
+    return this.whereConditions(`DELETE FROM ${table}`, params)
   }
 
   whereConditions(query, params) {
@@ -82,6 +74,7 @@ class Mysql {
       // Object to WHERE conditions
       let first = true
       for (const p in params) {
+        if (first) newQuery += ' WHERE'
         if (!first) newQuery += ' AND'
         newQuery += ` ${p}=?`
         paramsArray.push(params[p])
@@ -91,11 +84,6 @@ class Mysql {
     return [newQuery, paramsArray]
   }
 
-  async delete(query, params) {
-    const [queryWhere, paramsArray] = this.whereConditions(query, params)
-    return await this.execute(queryWhere, paramsArray)
-  }
-
   async disconnect(dbh) {
     const d = dbh || this.dbh
     if (_debug) console.log(`MySQL connection id ${d.connection.connectionId}`)

lib/mysql.test.js

@@ -20,57 +20,80 @@ describe('mysql', () => {
     })
   }
 
-  it('SQL: formats SELECT queries', async () => {
-    const r = await Mysql.select(`SELECT * FROM nt_user WHERE`, {
-      last_name: 'Test',
-      skipExecute: true,
-    })
-    assert.equal(r, `SELECT * FROM nt_user WHERE last_name=?`)
+  it('formats SELECT queries', () => {
+    assert.deepEqual(
+      Mysql.select(`SELECT * FROM nt_user`, {
+        last_name: 'Test',
+      }),
+      [`SELECT * FROM nt_user WHERE last_name=?`, ['Test']],
+    )
   })
 
-  it('SQL: formats INSERT queries', async () => {
-    const r = await Mysql.select(`INSERT INTO nt_user SET`, {
+  it('formats INSERT query', () => {
+    const r = Mysql.insert(`nt_user`, {
       first_name: 'uNite',
       last_name: 'Test',
-      skipExecute: true,
     })
-    assert.equal(r, `INSERT INTO nt_user SET first_name=? AND last_name=?`)
+    assert.deepEqual(r, [
+      `INSERT INTO nt_user (first_name,last_name) VALUES(?,?)`,
+      ['uNite', 'Test'],
+    ])
   })
 
-  it('SQL: formats UPDATE queries, 1', async () => {
-    const { q, p } = await Mysql.update(
-      `UPDATE nt_user SET`,
-      `WHERE nt_user_id=4096`,
-      { first_name: 'uNite', skipExecute: true },
-    )
-    assert.equal(q, `UPDATE nt_user SET first_name=? WHERE nt_user_id=4096`)
-    assert.deepEqual(p, ['uNite'])
+  describe('update', () => {
+    it('formats with one value', () => {
+      const r = Mysql.update(`nt_user`, `nt_user_id=4096`, {
+        first_name: 'uNite',
+      })
+      assert.deepEqual(r, [
+        `UPDATE nt_user SET first_name=? WHERE nt_user_id=4096`,
+        ['uNite'],
+      ])
+    })
+
+    it('formats with two values', () => {
+      const r = Mysql.update(`nt_user`, `nt_user_id=4096`, {
+        last_name: 'Teste',
+        is_admin: 1,
+      })
+      assert.deepEqual(r, [
+        `UPDATE nt_user SET last_name=?,is_admin=? WHERE nt_user_id=4096`,
+        ['Teste', 1],
+      ])
+    })
+
+    it('formats with three values', () => {
+      const r = Mysql.update(`nt_user`, `nt_user_id=4096`, {
+        first_name: 'Unit',
+        last_name: 'Test',
+        is_admin: 0,
+      })
+      assert.deepEqual(r, [
+        `UPDATE nt_user SET first_name=?,last_name=?,is_admin=? WHERE nt_user_id=4096`,
+        ['Unit', 'Test', 0],
+      ])
+    })
   })
 
-  it('SQL: formats UPDATE queries, 2', async () => {
-    const { q, p } = await Mysql.update(
-      `UPDATE nt_user SET`,
-      `WHERE nt_user_id=4096`,
-      { last_name: 'Teste', is_admin: 1, skipExecute: true },
-    )
-    assert.equal(
-      q,
-      `UPDATE nt_user SET last_name=?,is_admin=? WHERE nt_user_id=4096`,
-    )
-    assert.deepEqual(p, ['Teste', 1])
+  describe('delete', () => {
+    it('no params', () => {
+      assert.deepEqual(Mysql.delete(`nt_user`, {}), [`DELETE FROM nt_user`, []])
+    })
+
+    it('with params', () => {
+      assert.deepEqual(Mysql.delete(`nt_user`, { last_name: 'Test' }), [
+        `DELETE FROM nt_user WHERE last_name=?`,
+        ['Test'],
+      ])
+    })
   })
 
-  it('SQL: formats UPDATE queries, 3', async () => {
-    const { q, p } = await Mysql.update(
-      `UPDATE nt_user SET`,
-      `WHERE nt_user_id=4096`,
-      { first_name: 'Unit', last_name: 'Test', is_admin: 0, skipExecute: true },
-    )
-    assert.equal(
-      q,
-      `UPDATE nt_user SET first_name=?,last_name=?,is_admin=? WHERE nt_user_id=4096`,
-    )
-    assert.deepEqual(p, ['Unit', 'Test', 0])
+  it('executes formatted queries', async () => {
+    const [query, argsArray] = Mysql.select(`SELECT * FROM nt_options`)
+    const r = await Mysql.execute(query, argsArray)
+    assert.deepEqual(r[0].option_id, 1)
+
+    // await Mysql.execute(...Mysql.select(`SELECT * FROM nt_options`))
   })
 
   it('disconnects', async () => {