mysql2-core 0.3.9 → 0.5.1

package/src/index.ts

@@ -1,6 +1,6 @@
 import { Connection, createPool as createPool2, FieldPacket, Pool, PoolConnection, ResultSetHeader } from "mysql2"
 import { Pool as PromisePool } from "mysql2/promise"
-import { buildToSave, buildToSaveBatch, param } from "./build"
+import { buildToSave, buildToSaveBatch, metadata, param } from "./build"
 import { Attribute, Attributes, DB, Statement, StringMap, Transaction } from "./metadata"
 
 export * from "./build"
@@ -40,32 +40,24 @@ export function getConnection(pool: Pool): Promise<PoolConnection> {
     })
   })
 }
-export function beginTransaction(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+export function beginTransaction(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
-    connection.beginTransaction((err) => {
-      if (err) {
-        if (!rollbackIfError) {
-          return reject(err)
-        }
-        return connection.rollback(() => {
-          return reject(err)
-        })
+    connection.beginTransaction((beginError) => {
+      if (beginError) {
+        connection.release()
+        return reject(beginError)
       }
       return resolve()
     })
   })
 }
-export function commit(connection: PoolConnection, rollbackIfError?: boolean): Promise<void> {
+export function commit(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     connection.commit((err) => {
       if (err) {
-        if (!rollbackIfError) {
-          return reject(err)
-        }
-        return connection.rollback(() => {
-          return reject(err)
-        })
+        return reject(err)
       }
+      connection.release()
       return resolve()
     })
   })
@@ -73,6 +65,7 @@ export function commit(connection: PoolConnection, rollbackIfError?: boolean): P
 export function rollback(connection: PoolConnection): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     connection.rollback((err) => {
+      connection.release()
       if (err) {
         return reject(err)
       }
@@ -103,39 +96,31 @@ export class PoolManager implements DB {
         }
         connection.beginTransaction((beginError) => {
           if (beginError) {
-            return connection.rollback(() => {
-              connection.release()
-              return reject(beginError)
-            })
+            connection.release()
+            return reject(beginError)
           }
           return resolve(new PoolConnectionManager(connection))
         })
       })
     })
   }
-  execute(sql: string, args?: any[], ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.pool
-    return execute(p, sql, args)
+  execute(sql: string, args?: any[]): Promise<number> {
+    return execute(this.pool, sql, args)
   }
-  executeBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.pool
-    return executeBatch(p, statements, firstSuccess)
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
+    return executeBatch(this.pool, statements, requireFirstAffected)
   }
-  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]> {
-    const p = ctx ? ctx : this.pool
-    return query(p, sql, args, m, bools)
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
+    return query(this.pool, sql, args, m, bools)
   }
-  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T | null> {
-    const p = ctx ? ctx : this.pool
-    return queryOne(p, sql, args, m, bools)
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T | null> {
+    return queryOne(this.pool, sql, args, m, bools)
   }
-  executeScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T | null> {
-    const p = ctx ? ctx : this.pool
-    return executeScalar<T>(p, sql, args)
+  executeScalar<T>(sql: string, args?: any[]): Promise<T | null> {
+    return executeScalar<T>(this.pool, sql, args)
   }
-  count(sql: string, args?: any[], ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.pool
-    return count(p, sql, args)
+  count(sql: string, args?: any[]): Promise<number> {
+    return count(this.pool, sql, args)
   }
 }
 // tslint:disable-next-line:max-classes-per-file
@@ -149,6 +134,7 @@ export class PoolConnectionManager implements Transaction {
     this.queryOne = this.queryOne.bind(this)
     this.executeScalar = this.executeScalar.bind(this)
     this.count = this.count.bind(this)
+    this.release = this.release.bind(this)
   }
   driver = "mysql"
   param(i: number): string {
@@ -158,10 +144,7 @@ export class PoolConnectionManager implements Transaction {
     return new Promise<void>((resolve, reject) => {
       this.connection.commit((err) => {
         if (err) {
-          return this.connection.rollback(() => {
-            this.release()
-            return reject(err)
-          })
+          return reject(err)
         }
         this.release()
         return resolve()
@@ -186,32 +169,26 @@ export class PoolConnectionManager implements Transaction {
     this.released = true
     this.connection.release()
   }
-  execute(sql: string, args?: any[], ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.connection
-    return execute(p, sql, args)
+  execute(sql: string, args?: any[]): Promise<number> {
+    return execute(this.connection, sql, args)
   }
-  executeBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.connection
-    return executeBatchConnection(p, statements, firstSuccess)
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
+    return executeBatchConnection(this.connection, statements, requireFirstAffected)
   }
-  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)
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]> {
+    return query(this.connection, 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)
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T | null> {
+    return queryOne(this.connection, sql, args, m, bools)
   }
-  executeScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T | null> {
-    const p = ctx ? ctx : this.connection
-    return executeScalar<T>(p, sql, args)
+  executeScalar<T>(sql: string, args?: any[]): Promise<T | null> {
+    return executeScalar<T>(this.connection, sql, args)
   }
-  count(sql: string, args?: any[], ctx?: any): Promise<number> {
-    const p = ctx ? ctx : this.connection
-    return count(p, sql, args)
+  count(sql: string, args?: any[]): Promise<number> {
+    return count(this.connection, sql, args)
   }
 }
-export async function executeBatch(pool: Pool, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+export async function executeBatch(pool: Pool, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
@@ -219,31 +196,29 @@ export async function executeBatch(pool: Pool, statements: Statement[], firstSuc
     return execute(pool, statements[0].query, statements[0].params)
   }
   const connection = await getConnection(pool)
-  try {
-    return await executeBatchConnectionTx(connection, statements, firstSuccess)
-  } finally {
-    connection.release()
-  }
+  return await executeBatchConnectionTx(connection, statements, requireFirstAffected)
 }
-export async function executeBatchConnectionTx(connection: PoolConnection, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+export async function executeBatchConnectionTx(connection: PoolConnection, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
   if (statements.length === 1) {
-    return execute(connection, statements[0].query, statements[0].params)
+    const count = await execute(connection, statements[0].query, statements[0].params)
+    connection.release()
+    return count
   }
-  await beginTransaction(connection, true)
+  await beginTransaction(connection)
   try {
     let count = 0
 
     if (resource.multipleStatements) {
-      if (firstSuccess) {
+      if (requireFirstAffected) {
         const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
         count = firstCount
 
         if (firstCount === 0) {
-          await commit(connection, true)
+          await commit(connection)
           return 0
         }
         const remaining = statements.slice(1)
@@ -252,12 +227,12 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
         count = await executeMultipleStatements(connection, statements)
       }
     } else {
-      const start = firstSuccess ? 1 : 0
-      if (firstSuccess) {
+      const start = requireFirstAffected ? 1 : 0
+      if (requireFirstAffected) {
         const firstCount = await execute(connection, statements[0].query, statements[0].params)
         count = firstCount
         if (firstCount === 0) {
-          await commit(connection, true)
+          await commit(connection)
           return 0
         }
       }
@@ -267,7 +242,7 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
       }
     }
 
-    await commit(connection, true)
+    await commit(connection)
 
     return count
   } catch (err) {
@@ -276,12 +251,12 @@ export async function executeBatchConnectionTx(connection: PoolConnection, state
     } catch {
       // Preserve the original error.
     }
-
-    throw buildError(err)
+    buildError(err)
+    throw err
   }
 }
 
-export async function executeBatchConnection(connection: PoolConnection, statements: Statement[], firstSuccess?: boolean): Promise<number> {
+export async function executeBatchConnection(connection: PoolConnection, statements: Statement[], requireFirstAffected?: boolean): Promise<number> {
   if (!statements || statements.length === 0) {
     return 0
   }
@@ -291,7 +266,7 @@ export async function executeBatchConnection(connection: PoolConnection, stateme
   }
 
   if (resource.multipleStatements) {
-    if (firstSuccess) {
+    if (requireFirstAffected) {
       const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
       if (firstCount === 0) {
@@ -305,9 +280,9 @@ export async function executeBatchConnection(connection: PoolConnection, stateme
   }
 
   let count = 0
-  const start = firstSuccess ? 1 : 0
+  const start = requireFirstAffected ? 1 : 0
 
-  if (firstSuccess) {
+  if (requireFirstAffected) {
     const firstCount = await execute(connection, statements[0].query, statements[0].params)
 
     count = firstCount
@@ -437,25 +412,6 @@ export function count(pool: Pool | PoolConnection, sql: string, args?: any[]): P
   return executeScalar<number>(pool, sql, args).then((res) => (res !== null ? res : 0))
 }
 
-export function save<T>(pool: Pool | PoolConnection | ((sql: string, args?: any[]) => Promise<number>), obj: T, table: string, attrs: Attributes, ver?: string, buildParam?: (i: number) => string): Promise<number> {
-  const s = buildToSave(obj, table, attrs, ver, buildParam)
-  if (!s.query) {
-    return Promise.resolve(-1)
-  }
-  if (typeof pool === "function") {
-    return pool(s.query, s.params)
-  } else {
-    return execute(pool, s.query, s.params)
-  }
-}
-export function saveBatch<T>(pool: Pool | ((statements: Statement[]) => Promise<number>), objs: T[], table: string, attrs: Attributes, ver?: string, buildParam?: (i: number) => string): Promise<number> {
-  const s = buildToSaveBatch(objs, table, attrs, ver, buildParam)
-  if (typeof pool === "function") {
-    return pool(s)
-  } else {
-    return executeBatch(pool, s)
-  }
-}
 export function toArray(arr?: any[]): any[] {
   if (!arr || arr.length === 0) {
     return []
@@ -646,20 +602,12 @@ export class StringAdapter {
     return execute(this.pool, s, values)
   }
 }
+export const StringRepository = StringAdapter
+export const StringService = StringAdapter
 
-export function version(attrs: Attributes): Attribute | undefined {
-  const ks = Object.keys(attrs)
-  for (const k of ks) {
-    const attr = attrs[k]
-    if (attr.version) {
-      attr.name = k
-      return attr
-    }
-  }
-  return undefined
-}
 // tslint:disable-next-line:max-classes-per-file
 export class MySQLWriter<T> {
+  protected keys: Attribute[]
   protected version?: string
   protected param?: (i: number) => string
   constructor(
@@ -672,10 +620,9 @@ export class MySQLWriter<T> {
   ) {
     this.write = this.write.bind(this)
     this.param = buildParam ? buildParam : param
-    const x = version(attributes)
-    if (x) {
-      this.version = x.name
-    }
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(obj: T): Promise<number> {
     if (!obj) {
@@ -685,7 +632,7 @@ export class MySQLWriter<T> {
     if (this.map) {
       obj2 = this.map(obj)
     }
-    const stmt = buildToSave(obj2, this.table, this.attributes, this.version, this.param)
+    const stmt = buildToSave(obj2, this.table, this.attributes, this.keys, this.version, this.param)
     if (stmt.query) {
       if (this.oneIfSuccess) {
         return execute(this.pool, stmt.query, stmt.params).then((ct) => (ct > 0 ? 1 : 0))
@@ -698,8 +645,9 @@ export class MySQLWriter<T> {
   }
 }
 // tslint:disable-next-line:max-classes-per-file
-export class MySQLStreamWriter<T> {
+export class BufferedBatchWriter<T> {
   protected list: T[] = []
+  protected keys: Attribute[]
   protected version?: string
   protected param?: (i: number) => string
   constructor(
@@ -713,10 +661,9 @@ export class MySQLStreamWriter<T> {
     this.write = this.write.bind(this)
     this.flush = this.flush.bind(this)
     this.param = buildParam ? buildParam : param
-    const x = version(attributes)
-    if (x) {
-      this.version = x.name
-    }
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(obj: T): Promise<number> {
     if (!obj) {
@@ -739,37 +686,36 @@ export class MySQLStreamWriter<T> {
     if (!this.list || this.list.length === 0) {
       return Promise.resolve(0)
     } else {
-      const total = this.list.length
-      const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.version, this.param)
+      const stmt = buildToSaveBatch(this.list, this.table, this.attributes, this.keys, this.version, this.param)
       if (stmt.length > 0) {
         return executeBatch(this.pool as any, stmt).then((r) => {
           this.list = []
-          return total
+          return r
         })
       } else {
+        this.list = []
         return Promise.resolve(0)
       }
     }
   }
 }
 // tslint:disable-next-line:max-classes-per-file
-export class MySQLBatchWriter<T> {
+export class BatchWriter<T> {
+  protected keys: Attribute[]
   protected version?: string
   protected param?: (i: number) => string
   constructor(
     protected pool: Pool,
     protected table: string,
     protected attributes: Attributes,
-    protected oneIfSuccess?: boolean,
     protected map?: (v: T) => T,
     buildParam?: (i: number) => string,
   ) {
     this.write = this.write.bind(this)
     this.param = buildParam ? buildParam : param
-    const x = version(attributes)
-    if (x) {
-      this.version = x.name
-    }
+    const m = metadata(attributes)
+    this.keys = m.keys
+    this.version = m.version
   }
   write(objs: T[]): Promise<number> {
     if (!objs || objs.length === 0) {
@@ -783,13 +729,9 @@ export class MySQLBatchWriter<T> {
         list.push(obj2)
       }
     }
-    const stmts = buildToSaveBatch(list, this.table, this.attributes, this.version, this.param)
+    const stmts = buildToSaveBatch(list, this.table, this.attributes, this.keys, this.version, this.param)
     if (stmts.length > 0) {
-      if (this.oneIfSuccess) {
-        return executeBatch(this.pool, stmts).then((ct) => stmts.length)
-      } else {
-        return executeBatch(this.pool, stmts)
-      }
+      return executeBatch(this.pool, stmts)
     } else {
       return Promise.resolve(0)
     }
@@ -903,38 +845,38 @@ export class Exporter<T> {
     const reader = this.connection.query(stmt.query, stmt.params)
     let er: any
     let i = 0
-    let k = 0
+    let j = 0
     reader.on("error", (err) => (er = err))
     // (D2) WRITE ROW-BY-ROW
     if (this.map) {
       reader.on("result", async (row: any) => {
         ++i
-        k++
+        j++
         this.connection.pause()
         const obj = mapOne<T>(row, this.map)
         const data = this.format(obj)
         this.write(data)
         this.connection.resume()
-        if (k >= this.progressSize) {
+        if (j >= this.progressSize) {
           if (this.logInfo) {
             this.logInfo(`Progress: ${i} records processed of file '${this.filename}'`)
           }
-          k = 0
+          j = 0
         }
       })
     } else {
       reader.on("result", async (row: any) => {
         ++i
-        k++
+        j++
         this.connection.pause()
         const data = this.format(row as T)
         this.write(data)
         this.connection.resume()
-        if (k >= this.progressSize) {
+        if (j >= this.progressSize) {
           if (this.logInfo) {
             this.logInfo(`Progress: ${i} records processed of file '${this.filename}'`)
           }
-          k = 0
+          j = 0
         }
       })
     }
@@ -981,37 +923,37 @@ export class ExportService<T> {
     let er: any
     reader.on("error", (err) => (er = err))
     let i = 0
-    let k = 0
+    let j = 0
     // (D2) WRITE ROW-BY-ROW
     if (this.map) {
       reader.on("result", async (row: any) => {
         ++i
-        k++
+        j++
         this.connection.pause()
         const obj = mapOne<T>(row, this.map)
         const data = this.formatter.format(obj)
         this.writer.write(data)
         this.connection.resume()
-        if (k >= this.progressSize) {
+        if (j >= this.progressSize) {
           if (this.logInfo) {
             this.logInfo(`Progress: ${i} records processed of file '${this.filename}'`)
           }
-          k = 0
+          j = 0
         }
       })
     } else {
       reader.on("result", async (row: any) => {
         ++i
-        k++
+        j++
         this.connection.pause()
         const data = this.formatter.format(row as T)
         this.writer.write(data)
         this.connection.resume()
-        if (k >= this.progressSize) {
+        if (j >= this.progressSize) {
           if (this.logInfo) {
             this.logInfo(`Progress: ${i} records processed of file '${this.filename}'`)
           }
-          k = 0
+          j = 0
         }
       })
     }

package/src/metadata.ts

@@ -9,12 +9,12 @@ export interface Statement {
 export interface Executor {
   driver: string
   param(i: number): string
-  execute(sql: string, args?: any[], ctx?: any): Promise<number>
-  executeBatch(statements: Statement[], firstSuccess?: boolean, ctx?: any): Promise<number>
-  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T[]>
-  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[], ctx?: any): Promise<T | null>
-  executeScalar<T>(sql: string, args?: any[], ctx?: any): Promise<T | null>
-  count(sql: string, args?: any[], ctx?: any): Promise<number>
+  execute(sql: string, args?: any[]): Promise<number>
+  executeBatch(statements: Statement[], requireFirstAffected?: boolean): Promise<number>
+  query<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T[]>
+  queryOne<T>(sql: string, args?: any[], m?: StringMap, bools?: Attribute[]): Promise<T | null>
+  executeScalar<T>(sql: string, args?: any[]): Promise<T | null>
+  count(sql: string, args?: any[]): Promise<number>
 }
 export interface Transaction extends Executor {
   commit(): Promise<void>