v2.5.0

1. PR fix - thanks #251

2. pool extended with additional promises to match connection #246

export interface AggregatorPromises {
    query(sql: string, params?: any[], options?: QueryAggregatorOptions): Promise<QueryAggregatorResults>
    callProc(name: string, params?: any, options?: QueryAggregatorOptions): Promise<QueryAggregatorResults>
}

export interface PoolPromises extends AggregatorPromises {
    open(): Promise<Pool>
    close(): Promise<any>
    getUserTypeTable(name: string): Promise<Table>
    getTable(name: string): Promise<BulkTableMgr>
    getProc(name: string): Promise<ProcedureDefinition>
}

1. prepared statements with nvarchar(max) #248

2. prepared statement may cause node crash due to stack corruption.

3. use promise query to add missing column names

  it('select promise query with no column name', async function handler () {
    const r1 = await env.theConnection.promises.query('select 1,2 union select 3,4', [],
      { replaceEmptyColumnNames: true })
    console.log(JSON.stringify(r1.first, null, 0))
    expect(r1.first[0].Column0).is.equal(1)
    expect(r1.first[0].Column1).is.equal(2)
    expect(r1.first[1].Column0).is.equal(3)
    expect(r1.first[1].Column1).is.equal(4)
  })

1. significant refactor of test framework using bdd mocha, chai

call proc from connection pool (like connection)

 it('use pool to call proc', async function handler () {
    const pool = env.pool()
    await pool.open()
    const spName = 'test_sp_get_optional_p'
    const a = 10
    const b = 20
    const def = `alter PROCEDURE <name> (
      @a INT = ${a},
      @b INT = ${b},
      @plus INT out
      )
    AS begin
      -- SET XACT_ABORT ON;
      SET NOCOUNT ON;
      set @plus = @a + @b;
    end;
`
    await env.promisedCreate(spName, def)
    const expected = [
      0,
      a + b
    ]
    const o = {}
    const res = await pool.promises.callProc(spName, o)
    expect(res.output).to.be.deep.equal(expected)
    await pool.close()
  })

use bulk table manager on pool (like connection)

  it('use tableMgr on pool bulk insert varchar vector - exactly 4000 chars', async function handler () {
    const pool = env.pool(4)
    await pool.promises.open()
    const b = env.repeat('z', 4000)
    const helper = env.typeTableHelper('NVARCHAR(MAX)', pool)
    const expected = helper.getVec(10, i => b)
    const table = await helper.create()
    const promisedInsert = table.promises.insert
    const promisedSelect = table.promises.select

    await promisedInsert(expected)
    const res = await promisedSelect(expected)
    expect(res).to.be.deep.equals(expected)
    await pool.close()
  })

use tvp on pool (like connection)

  it('use pool for tvp insert', async function handler () {
    const pool = env.pool(4)
    await pool.promises.open()
    const tableName = 'TestTvp'
    const helper = env.tvpHelper(tableName, pool)
    const vec = helper.getExtendedVec(1)
    const table = await helper.create(tableName)
    table.addRowsFromObjects(vec)
    const tp = env.sql.TvpFromTable(table)
    const insertSql = helper.callProcWithTVpSql
    // 'exec insertTestTvp @tvp = ?;'
    await pool.promises.query(insertSql, [tp])
    // use a connection having inserted with pool
    const res = await pool.promises.query(`select * from ${tableName}`)
    expect(res.first).to.be.deep.equal(vec)
    await pool.close()
  })