mysql2-core 0.2.4 → 0.3.1

package/src/index.ts

@@ -1,6 +1,6 @@
-import { Connection, createPool as createPool2, FieldPacket, format, Pool, PoolConnection, ResultSetHeader } from "mysql2"
+import { Connection, createPool as createPool2, FieldPacket, Pool, PoolConnection, ResultSetHeader } from "mysql2"
 import { buildToSave, buildToSaveBatch } from "./build"
-import { Attribute, Attributes, Manager, Statement, StringMap } from "./metadata"
+import { Attribute, Attributes, DB, Statement, StringMap, Transaction } from "./metadata"
 
 export * from "./build"
 export * from "./metadata"
@@ -8,6 +8,7 @@ export * from "./metadata"
 // tslint:disable-next-line:class-name
 export class resource {
   static string?: boolean
+  static multipleStatements?: boolean
 }
 export interface Config {
   host?: string | undefined
@@ -29,29 +30,96 @@ export function createPool(conf: Config): Pool {
   const pool = createPool2({ ...conf, rowsAsArray: true })
   return pool
 }
-
+export function getConnection(pool: Pool): Promise<PoolConnection> {
+  return new Promise<PoolConnection>((resolve, reject) => {
+    pool.getConnection((err, connection) => {
+      if (err) {
+        return reject(err)
+      }
+      return resolve(connection)
+    })
+  })
+}
+export function beginTransaction(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    connection.beginTransaction((err) => {
+      if (err) {
+        if (!rollbackIfError) {
+          return reject(err)
+        }
+        connection.rollback(() => {
+          return reject(err)
+        })
+      }
+      return resolve()
+    })
+  })
+}
+export function commit(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    connection.commit((err) => {
+      if (err) {
+        if (!rollbackIfError) {
+          return reject(err)
+        }
+        connection.rollback(() => {
+          return reject(err)
+        })
+      }
+      resolve()
+    })
+  })
+}
+export function rollback(connection: PoolConnection): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    connection.rollback((err) => {
+      if (err) {
+        return reject(err)
+      }
+      resolve()
+    })
+  })
+}
 // tslint:disable-next-line:max-classes-per-file
-export class PoolManager implements Manager {
-  constructor(public pool: Pool) {
+export class PoolManager implements DB {
+  constructor(protected pool: Pool) {
     this.param = this.param.bind(this)
-    this.exec = this.exec.bind(this)
-    this.execBatch = this.execBatch.bind(this)
+    this.execute = this.execute.bind(this)
+    this.executeBatch = this.executeBatch.bind(this)
     this.query = this.query.bind(this)
     this.queryOne = this.queryOne.bind(this)
-    this.execScalar = this.execScalar.bind(this)
+    this.executeScalar = this.executeScalar.bind(this)
     this.count = this.count.bind(this)
   }
   driver = "mysql"
   param(i: number): string {
     return "?"
   }
-  exec(sql: string, args?: any[], ctx?: any): Promise<number> {
+  beginTransaction(): Promise<Transaction> {
+    return new Promise<Transaction>((resolve, reject) => {
+      this.pool.getConnection((er0, connection) => {
+        if (er0) {
+          return reject(er0)
+        }
+        connection.beginTransaction((er1) => {
+          if (er1) {
+            connection.rollback(() => {
+              return reject(er1)
+            })
+          }
+          const tx = new PoolConnectionManager(connection)
+          return resolve(tx)
+        })
+      })
+    })
+  }
+  execute(sql: string, args?: any[], ctx?: any): Promise<number> {
     const p = ctx ? ctx : this.pool
-    return exec(p, sql, args)
+    return execute(p, sql, args)
   }
-  execBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
+  executeBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
     const p = ctx ? ctx : this.pool
-    return execBatch(p, statements, firstSuccess)
+    return executeBatch(p, statements, firstSuccess)
   }
   query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
     const p = ctx ? ctx : this.pool
@@ -61,58 +129,252 @@ export class PoolManager implements Manager {
     const p = ctx ? ctx : this.pool
     return queryOne(p, sql, args, m, bools)
   }
-  execScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T> {
+  executeScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T> {
     const p = ctx ? ctx : this.pool
-    return execScalar<T>(p, sql, args)
+    return executeScalar<T>(p, sql, args)
   }
   count(sql: string, args?: any[], ctx?: any): Promise<number> {
     const p = ctx ? ctx : this.pool
     return count(p, sql, args)
   }
 }
-export function execBatch(pool: Pool, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+// tslint:disable-next-line:max-classes-per-file
+export class PoolConnectionManager implements Transaction {
+  constructor(protected connection: PoolConnection) {
+    this.param = this.param.bind(this)
+    this.execute = this.execute.bind(this)
+    this.executeBatch = this.executeBatch.bind(this)
+    this.query = this.query.bind(this)
+    this.queryOne = this.queryOne.bind(this)
+    this.executeScalar = this.executeScalar.bind(this)
+    this.count = this.count.bind(this)
+  }
+  driver = "mysql"
+  param(i: number): string {
+    return "?"
+  }
+  commit(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.connection.commit((er3) => {
+        if (er3) {
+          return reject(er3)
+        }
+        return resolve()
+      })
+    })
+  }
+  rollback(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.connection.rollback((er3) => {
+        if (er3) {
+          return reject(er3)
+        }
+        return resolve()
+      })
+    })
+  }
+  execute(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const p = ctx ? ctx : this.connection
+    return execute(p, sql, args)
+  }
+  executeBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
+    const p = ctx ? ctx : this.connection
+    return executeBatchConnection(p, statements, firstSuccess)
+  }
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
+    const p = ctx ? ctx : this.connection
+    return query(p, sql, args, m, bools)
+  }
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T | null> {
+    const p = ctx ? ctx : this.connection
+    return queryOne(p, sql, args, m, bools)
+  }
+  executeScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T> {
+    const p = ctx ? ctx : this.connection
+    return executeScalar<T>(p, sql, args)
+  }
+  count(sql: string, args?: any[], ctx?: any): Promise<number> {
+    const p = ctx ? ctx : this.connection
+    return count(p, sql, args)
+  }
+}
+export async function executeBatch(pool: Pool, statements: Statement[], firstSuccess?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return Promise.resolve(0)
   } else if (statements.length === 1) {
-    return exec(pool, statements[0].query, statements[0].params)
+    return execute(pool, statements[0].query, statements[0].params)
   }
-  if (firstSuccess) {
-    return new Promise<number>((resolve, reject) => {
-      pool.getConnection((er0, connection) => {
-        if (er0) {
-          return reject(er0)
-        }
+  if (resource.multipleStatements) {
+    if (firstSuccess) {
+      return new Promise<number>((resolve, reject) => {
+        pool.getConnection((er0, connection) => {
+          if (er0) {
+            return reject(er0)
+          }
+          connection.beginTransaction((er1) => {
+            if (er1) {
+              connection.rollback(() => {
+                return reject(er1)
+              })
+            } else {
+              connection.execute<ResultSetHeader>(statements[0].query, toArray(statements[0].params), (er2a, results0) => {
+                if (er2a) {
+                  connection.rollback(() => {
+                    return reject(er2a)
+                  })
+                } else {
+                  if (results0 && results0.affectedRows === 0) {
+                    connection.commit((er3) => {
+                      if (er3) {
+                        connection.rollback(() => {
+                          return reject(er3)
+                        })
+                      }
+                    })
+                    return 0
+                  } else {
+                    const queries: string[] = []
+                    const params: any[] = []
+                    const l = statements.length
+                    for (let j = 1; j < l; j++) {
+                      const item = statements[j]
+                      if (item.query.endsWith(";")) {
+                        queries.push(item.query)
+                      } else {
+                        queries.push(item.query + ";")
+                      }
+                      if (item.params && item.params.length > 0) {
+                        for (const p of item.params) {
+                          params.push(p)
+                        }
+                      }
+                    }
+                    connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
+                      if (er2) {
+                        connection.rollback(() => {
+                          return reject(er2)
+                        })
+                      } else {
+                        connection.commit((er3) => {
+                          if (er3) {
+                            connection.rollback(() => {
+                              return reject(er3)
+                            })
+                          }
+                        })
+                        let c = 0
+                        c += results0.affectedRows + results.affectedRows
+                        return resolve(c)
+                      }
+                    })
+                  }
+                }
+              })
+            }
+          })
+        })
+      })
+    } else {
+      return new Promise<number>((resolve, reject) => {
+        pool.getConnection((er0, connection) => {
+          if (er0) {
+            return reject(er0)
+          }
+          connection.beginTransaction((er1) => {
+            if (er1) {
+              connection.rollback(() => {
+                return reject(er1)
+              })
+            } else {
+              const queries: string[] = []
+              const params: any[] = []
+              statements.forEach((item) => {
+                if (item.query.endsWith(";")) {
+                  queries.push(item.query)
+                } else {
+                  queries.push(item.query + ";")
+                }
+                if (item.params && item.params.length > 0) {
+                  for (const p of item.params) {
+                    params.push(p)
+                  }
+                }
+              })
+              connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
+                if (er2) {
+                  connection.rollback(() => {
+                    buildError(er2)
+                    return reject(er2)
+                  })
+                } else {
+                  connection.commit((er3) => {
+                    if (er3) {
+                      connection.rollback(() => {
+                        return reject(er3)
+                      })
+                    }
+                  })
+                  return resolve(results.affectedRows)
+                }
+              })
+            }
+          })
+        })
+      })
+    }
+  } else {
+    const connection = await getConnection(pool)
+    return executeBatchConnectionTx(connection, statements, firstSuccess)
+  }
+}
+export async function executeBatchConnectionTx(connection: PoolConnection, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+  if (!statements || statements.length === 0) {
+    return Promise.resolve(0)
+  } else if (statements.length === 1) {
+    return execute(connection, statements[0].query, statements[0].params)
+  }
+  if (resource.multipleStatements) {
+    if (firstSuccess) {
+      return new Promise<number>((resolve, reject) => {
         connection.beginTransaction((er1) => {
           if (er1) {
             connection.rollback(() => {
               return reject(er1)
             })
           } else {
-            let query0 = ""
-            const queries: string[] = []
-            const l = statements.length
-            for (let j = 0; j < l; j++) {
-              const item = statements[j]
-              if (j === 0) {
-                query0 = format(item.query, toArray(item.params))
-              } else {
-                if (item.query.endsWith(";")) {
-                  queries.push(format(item.query, toArray(item.params)))
-                } else {
-                  queries.push(format(item.query + ";", toArray(item.params)))
-                }
-              }
-            }
-            connection.execute<ResultSetHeader>(query0, (er2a, results0) => {
+            connection.execute<ResultSetHeader>(statements[0].query, toArray(statements[0].params), (er2a, results0) => {
               if (er2a) {
                 connection.rollback(() => {
                   return reject(er2a)
                 })
               } else {
                 if (results0 && results0.affectedRows === 0) {
+                  connection.commit((er3) => {
+                    if (er3) {
+                      connection.rollback(() => {
+                        return reject(er3)
+                      })
+                    }
+                  })
                   return 0
                 } else {
-                  connection.execute<ResultSetHeader>(queries.join(""), (er2, results) => {
+                  const queries: string[] = []
+                  const params: any[] = []
+                  const l = statements.length
+                  for (let j = 1; j < l; j++) {
+                    const item = statements[j]
+                    if (item.query.endsWith(";")) {
+                      queries.push(item.query)
+                    } else {
+                      queries.push(item.query + ";")
+                    }
+                    if (item.params && item.params.length > 0) {
+                      for (const p of item.params) {
+                        params.push(p)
+                      }
+                    }
+                  }
+                  connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
                     if (er2) {
                       connection.rollback(() => {
                         return reject(er2)
@@ -136,13 +398,8 @@ export function execBatch(pool: Pool, statements: Statement[], firstSuccess?: bo
           }
         })
       })
-    })
-  } else {
-    return new Promise<number>((resolve, reject) => {
-      pool.getConnection((er0, connection) => {
-        if (er0) {
-          return reject(er0)
-        }
+    } else {
+      return new Promise<number>((resolve, reject) => {
         connection.beginTransaction((er1) => {
           if (er1) {
             connection.rollback(() => {
@@ -150,14 +407,20 @@ export function execBatch(pool: Pool, statements: Statement[], firstSuccess?: bo
             })
           } else {
             const queries: string[] = []
+            const params: any[] = []
             statements.forEach((item) => {
               if (item.query.endsWith(";")) {
-                queries.push(format(item.query, toArray(item.params)))
+                queries.push(item.query)
               } else {
-                queries.push(format(item.query + ";", toArray(item.params)))
+                queries.push(item.query + ";")
+              }
+              if (item.params && item.params.length > 0) {
+                for (const p of item.params) {
+                  params.push(p)
+                }
               }
             })
-            connection.execute<ResultSetHeader>(queries.join(""), (er2, results) => {
+            connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
               if (er2) {
                 connection.rollback(() => {
                   buildError(er2)
@@ -177,7 +440,163 @@ export function execBatch(pool: Pool, statements: Statement[], firstSuccess?: bo
           }
         })
       })
-    })
+    }
+  } else {
+    if (firstSuccess) {
+      try {
+        await beginTransaction(connection, true)
+        let count = await execute(connection, statements[0].query, toArray(statements[0].params))
+        if (count === 0) {
+          commit(connection, true)
+          return 0
+        }
+        const l = statements.length
+
+        for (let j = 1; j < l; j++) {
+          const item = statements[j]
+          const c = await execute(connection, item.query, toArray(item.params))
+          count = count + c
+        }
+        commit(connection, true)
+        return count
+      } catch (err) {
+        rollback(connection)
+        throw err
+      }
+    } else {
+      try {
+        await beginTransaction(connection, true)
+        let count = 0
+        const l = statements.length
+        for (let j = 0; j < l; j++) {
+          const item = statements[j]
+          const c = await execute(connection, item.query, toArray(item.params))
+          count = count + c
+        }
+        commit(connection, true)
+        return count
+      } catch (err) {
+        rollback(connection)
+        throw err
+      }
+    }
+  }
+}
+export async function executeBatchConnection(connection: PoolConnection, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+  if (!statements || statements.length === 0) {
+    return Promise.resolve(0)
+  } else if (statements.length === 1) {
+    return execute(connection, statements[0].query, statements[0].params)
+  }
+  if (resource.multipleStatements) {
+    if (firstSuccess) {
+      return new Promise<number>((resolve, reject) => {
+        connection.execute<ResultSetHeader>(statements[0].query, toArray(statements[0].params), (er2a, results0) => {
+          if (er2a) {
+            return reject(er2a)
+          } else {
+            if (results0 && results0.affectedRows === 0) {
+              return 0
+            } else {
+              const queries: string[] = []
+              const params: any[] = []
+              const l = statements.length
+              for (let j = 1; j < l; j++) {
+                const item = statements[j]
+                if (item.query.endsWith(";")) {
+                  queries.push(item.query)
+                } else {
+                  queries.push(item.query + ";")
+                }
+                if (item.params && item.params.length > 0) {
+                  for (const p of item.params) {
+                    params.push(p)
+                  }
+                }
+              }
+              connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
+                if (er2) {
+                  return reject(er2)
+                } else {
+                  let c = 0
+                  c += results0.affectedRows + results.affectedRows
+                  return resolve(c)
+                }
+              })
+            }
+          }
+        })
+      })
+    } else {
+      return new Promise<number>((resolve, reject) => {
+        const queries: string[] = []
+        const params: any[] = []
+        statements.forEach((item) => {
+          if (item.query.endsWith(";")) {
+            queries.push(item.query)
+          } else {
+            queries.push(item.query + ";")
+          }
+          if (item.params && item.params.length > 0) {
+            for (const p of item.params) {
+              params.push(p)
+            }
+          }
+        })
+        connection.query<ResultSetHeader>(queries.join(""), toArray(params), (er2, results) => {
+          if (er2) {
+            connection.rollback(() => {
+              buildError(er2)
+              return reject(er2)
+            })
+          } else {
+            connection.commit((er3) => {
+              if (er3) {
+                connection.rollback(() => {
+                  return reject(er3)
+                })
+              }
+            })
+            return resolve(results.affectedRows)
+          }
+        })
+      })
+    }
+  } else {
+    if (firstSuccess) {
+      try {
+        let count = await execute(connection, statements[0].query, toArray(statements[0].params))
+        if (count === 0) {
+          return 0
+        }
+        const l = statements.length
+        try {
+          for (let j = 1; j < l; j++) {
+            const item = statements[j]
+            const c = await execute(connection, item.query, toArray(item.params))
+            count = count + c
+          }
+          return count
+        } catch (er1) {
+          throw er1
+        }
+      } catch (er0) {
+        throw er0
+      }
+    } else {
+      let count = 0
+      const l = statements.length
+      try {
+        for (let j = 0; j < l; j++) {
+          const item = statements[j]
+          const c = await execute(connection, item.query, toArray(item.params))
+          count = count + c
+        }
+        return count
+      } catch (err) {
+        throw err
+      }
+    }
   }
 }
 function buildError(err: any): any {
@@ -187,7 +606,7 @@ function buildError(err: any): any {
   return err
 }
 
-export async function exec(pool: Pool | PoolConnection, sql: string, args?: any[]): Promise<number> {
+export async function execute(pool: Pool | PoolConnection, sql: string, args?: any[]): Promise<number> {
   const p = toArray(args)
   return new Promise<number>((resolve, reject) => {
     return pool.execute<ResultSetHeader>(sql, p, (err, res) => {
@@ -229,7 +648,7 @@ export function queryOne<T>(pool: Pool | PoolConnection, sql: string, args?: any
     return r && r.length > 0 ? r[0] : null
   })
 }
-export function execScalar<T>(pool: Pool | PoolConnection, sql: string, args?: any[]): Promise<T> {
+export function executeScalar<T>(pool: Pool | PoolConnection, sql: string, args?: any[]): Promise<T> {
   return queryOne<T>(pool, sql, args).then((r) => {
     if (!r) {
       return null
@@ -241,7 +660,7 @@ export function execScalar<T>(pool: Pool | PoolConnection, sql: string, args?: a
 }
 
 export function count(pool: Pool | PoolConnection, sql: string, args?: any[]): Promise<number> {
-  return execScalar<number>(pool, sql, args)
+  return executeScalar<number>(pool, sql, args)
 }
 
 export function save<T>(
@@ -254,13 +673,13 @@ export function save<T>(
   i?: number,
 ): Promise<number> {
   const s = buildToSave(obj, table, attrs, ver, buildParam)
-  if (!s) {
+  if (!s.query) {
     return Promise.resolve(-1)
   }
   if (typeof pool === "function") {
     return pool(s.query, s.params)
   } else {
-    return exec(pool, s.query, s.params)
+    return execute(pool, s.query, s.params)
   }
 }
 export function saveBatch<T>(
@@ -275,7 +694,7 @@ export function saveBatch<T>(
   if (typeof pool === "function") {
     return pool(s)
   } else {
-    return execBatch(pool, s)
+    return executeBatch(pool, s)
   }
 }
 export function toArray(arr?: any[]): any[] {
@@ -470,7 +889,7 @@ export class StringService {
       arr.push("(?)")
     }
     const s = `insert ignore into ${this.table}(${this.column})values${arr.join(",")}`
-    return exec(this.pool, s, values)
+    return execute(this.pool, s, values)
   }
 }
 
@@ -489,7 +908,7 @@ export function version(attrs: Attributes): Attribute | undefined {
 export class MySQLWriter<T> {
   pool?: Pool | PoolConnection
   version?: string
-  exec?: (sql: string, args?: any[]) => Promise<number>
+  execute?: (sql: string, args?: any[]) => Promise<number>
   map?: (v: T) => T
   param?: (i: number) => string
   constructor(
@@ -502,7 +921,7 @@ export class MySQLWriter<T> {
   ) {
     this.write = this.write.bind(this)
     if (typeof pool === "function") {
-      this.exec = pool
+      this.execute = pool
     } else {
       this.pool = pool
     }
@@ -523,17 +942,17 @@ export class MySQLWriter<T> {
     }
     const stmt = buildToSave(obj2, this.table, this.attributes, this.version, this.param)
     if (stmt) {
-      if (this.exec) {
+      if (this.execute) {
         if (this.oneIfSuccess) {
-          return this.exec(stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
+          return this.execute(stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
         } else {
-          return this.exec(stmt.query, stmt.params)
+          return this.execute(stmt.query, stmt.params)
         }
       } else {
         if (this.oneIfSuccess) {
-          return exec(this.pool as any, stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
+          return execute(this.pool as any, stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
         } else {
-          return exec(this.pool as any, stmt.query, stmt.params)
+          return execute(this.pool as any, stmt.query, stmt.params)
         }
       }
     } else {
@@ -547,7 +966,7 @@ export class MySQLStreamWriter<T> {
   size = 0
   pool?: Pool
   version?: string
-  execBatch?: (statements: Statement[]) => Promise<number>
+  executeBatch?: (statements: Statement[]) => Promise<number>
   map?: (v: T) => T
   param?: (i: number) => string
   constructor(
@@ -561,7 +980,7 @@ export class MySQLStreamWriter<T> {
     this.write = this.write.bind(this)
     this.flush = this.flush.bind(this)
     if (typeof pool === "function") {
-      this.execBatch = pool
+      this.executeBatch = pool
     } else {
       this.pool = pool
     }
@@ -599,13 +1018,13 @@ export class MySQLStreamWriter<T> {
       const total = this.list.length
       const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.version, this.param)
       if (stmt) {
-        if (this.execBatch) {
-          return this.execBatch(stmt).then((r) => {
+        if (this.executeBatch) {
+          return this.executeBatch(stmt).then((r) => {
             this.list = []
             return total
           })
         } else {
-          return execBatch(this.pool as any, stmt).then((r) => {
+          return executeBatch(this.pool as any, stmt).then((r) => {
             this.list = []
             return total
           })
@@ -666,9 +1085,9 @@ export class MySQLBatchWriter<T> {
         }
       } else {
         if (this.oneIfSuccess) {
-          return execBatch(this.pool as any, stmts).then((ct) => stmts.length)
+          return executeBatch(this.pool as any, stmts).then((ct) => stmts.length)
         } else {
-          return execBatch(this.pool as any, stmts)
+          return executeBatch(this.pool as any, stmts)
         }
       }
     } else {