Merge pull request #308 from TimelordUK/elec27

Elec27

Author: TimelordUK

.eslintrc

@@ -0,0 +1,33 @@
+module.exports = {
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "standard-with-typescript"
+  ],
+  parser: '@typescript-eslint/parser',
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  root: true,
+  rules: {
+    "@typescript-eslint/no-explicit-any":"off",
+    "@typescript-eslint/return-await": "off",
+    "@typescript-eslint/no-this-alias": "off",
+    "@typescript-eslint/no-var-requires": "off",
+    "@typescript-eslint/no-unused-vars": "off",
+    "@typescript-eslint/restrict-template-expressions": "off",
+    "@typescript-eslint/no-misused-promises": "off",
+    "@typescript-eslint/strict-boolean-expressions": "off",
+    "@typescript-eslint/consistent-type-assertions": "off",
+    "@typescript-eslint/no-extraneous-class": "off",
+    "@typescript-eslint/no-dynamic-delete": "off",
+    "no-this-assignment": "off",
+    "no-async-promise-executor": "off",
+    "valid-typeof": "off",
+    "@typescript-eslint/consistent-type-imports":"off",
+    "@typescript-eslint/ban-types":"off",
+    "@typescript-eslint/prefer-ts-expect-error":"off",
+    "@typescript-eslint/explicit-function-return-type":"off"
+  },
+};

.eslintrc.cjs

@@ -9,8 +9,8 @@
 1. *new* Ubuntu, Debian Node v18, v20 - install openssl 3.2 see WIKI
 1. docker images see WIKI
 1. *new* support always on encryption via tables and procedures.
-1. *new* support Node v20
-1. *new* support electron v24
+1. *new* support Node v20, v21
+1. *new* support electron v24, v25, v26
 1. *new* read numerics as strings - see WIKI
 1. Sybase Adaptive Server Enterprise support - see WIKI
 1. thread worker support - see WIKI

README.md

@@ -1,19 +1,19 @@
 'use strict'
 
 class BasePromises {
-  op (f) {
+  async op (f) {
     return new Promise((resolve, reject) => {
       setImmediate(() => {
         try {
           f((err, v) => {
             if (err) {
-              setImmediate(() => reject(err))
+              setImmediate(() => { reject(err) })
             } else {
-              setImmediate(() => resolve(v))
+              setImmediate(() => { resolve(v) })
             }
           })
         } catch (e) {
-          setImmediate(() => reject(e))
+          setImmediate(() => { reject(e) })
         }
       })
     })

lib/base-promises.js

@@ -55,7 +55,7 @@ class PrivateConnection {
   open () {
     this.nf.validateParameters(this.validationParams(), this.parentFn)
     this.callback2 = this.callback2 || this.defaultCallback
-    this.native.open(this.connectObj, (e, c) => this.queueCb(e, c))
+    this.native.open(this.connectObj, (e, c) => { this.queueCb(e, c) })
   }
 
   decodeSqlServerVersion (connectionString) {
@@ -75,47 +75,47 @@ class ConnectionWrapperPromises extends BasePromises {
     this.aggregator = new utilModule.QueryAggregator(connection)
   }
 
-  callProc (name, params, options) {
+  async callProc (name, params, options) {
     return this.aggregator.callProc(name, params, options)
   }
 
-  query (sql, params, options) {
+  async query (sql, params, options) {
     return this.aggregator.query(sql, params, options)
   }
 
-  getTable (name) {
+  async getTable (name) {
     return this.op(cb => this.tm.getTable(name, cb))
   }
 
-  getProc (name) {
+  async getProc (name) {
     return this.op(cb => this.pm.getProc(name, cb))
   }
 
-  getUserTypeTable (type) {
+  async getUserTypeTable (type) {
     return this.op(cb => this.connection.getUserTypeTable(type, cb))
   }
 
-  cancel (q) {
+  async cancel (q) {
     return this.op(cb => this.connection.cancel(q, cb))
   }
 
-  close () {
+  async close () {
     return this.op(cb => this.connection.close(cb))
   }
 
-  prepare (sqlQuery) {
+  async prepare (sqlQuery) {
     return this.op(cb => this.connection.prepare(sqlQuery, cb))
   }
 
-  beginTransaction () {
+  async beginTransaction () {
     return this.op(cb => this.connection.beginTransaction(cb))
   }
 
-  commit () {
+  async commit () {
     return this.op(cb => this.connection.commit(cb))
   }
 
-  rollback () {
+  async rollback () {
     return this.op(cb => this.connection.rollback(cb))
   }
 }
@@ -146,7 +146,7 @@ class ConnectionWrapper {
   }
 
   getUserTypeTable (name, callback) {
-    return this.tables.getUserTypeTable(name, callback)
+    this.tables.getUserTypeTable(name, callback)
   }
 
   tableMgr () {
@@ -242,7 +242,7 @@ class ConnectionWrapper {
     }
 
     if (chunky.callback) {
-      return this.queryRawNotify(notify, queryOrObj, this.notifier.getChunkyArgs(chunky.params, (err, results, more) => {
+      this.queryRawNotify(notify, queryOrObj, this.notifier.getChunkyArgs(chunky.params, (err, results, more) => {
         setImmediate(() => {
           onQueryRaw(err, results, more)
         })
@@ -371,11 +371,11 @@ class ConnectionWrapper {
   }
 
   getTable (name, cb) {
-    return this.tables.getTable(name, cb)
+    this.tables.getTable(name, cb)
   }
 
   // returns a promise of aggregated results not a query
-  callprocAggregator (name, params, options) {
+  async callprocAggregator (name, params, options) {
     return this.promises.callProc(name, params, options)
   }
 }

lib/connection.js

@@ -177,7 +177,7 @@ const driverModule = ((() => {
       if (queryId >= 0) {
         this.workQueue.enqueue(driverCommandEnum.FREE_STATEMENT, () => {
           this.cppDriver.freeStatement(queryId,
-            () => this.raiseFree(queryId, notify, callback))
+            () => { this.raiseFree(queryId, notify, callback) })
         }, [])
       } else {
         this.raiseFree(queryId, notify, callback)
@@ -213,19 +213,19 @@ const driverModule = ((() => {
 
     beginTransaction (callback) {
       this.workQueue.enqueue(driverCommandEnum.BEGIN_TRANSACTION, () => {
-        this.cppDriver.beginTransaction(err => this.next(callback, err))
+        this.cppDriver.beginTransaction(err => { this.next(callback, err) })
       }, [])
     }
 
     rollback (callback) {
       this.workQueue.enqueue(driverCommandEnum.ROLLBACK, () => {
-        this.cppDriver.rollback(err => this.next(callback, err))
+        this.cppDriver.rollback(err => { this.next(callback, err) })
       }, [])
     }
 
     commit (callback) {
       this.workQueue.enqueue(driverCommandEnum.COMMIT, () => {
-        this.cppDriver.commit(err => this.next(callback, err))
+        this.cppDriver.commit(err => { this.next(callback, err) })
       }, [])
     }
 
@@ -266,7 +266,7 @@ const driverModule = ((() => {
 
     headPaused (notify, queryObj, params, cb) {
       const peek = this.workQueue.peek()
-      const paused = peek && peek.paused
+      const paused = peek?.paused
       if (paused) {
         const pausedNotify = peek.args[0]
         this.freeStatement(pausedNotify, () => {

lib/driver.js

@@ -10,7 +10,7 @@ const metaModule = (() => {
       this.file = file
     }
 
-    readFile (f) {
+    async readFile (f) {
       return new Promise((resolve, reject) => {
         fs.readFile(f, 'utf8', (err, contents) => {
           if (err) {
@@ -22,7 +22,7 @@ const metaModule = (() => {
       })
     }
 
-    resolve () {
+    async resolve () {
       return new Promise((resolve, reject) => {
         if (!this.resolvedSql) {
           const p = path.join(__dirname, 'queries', this.file)
@@ -38,7 +38,7 @@ const metaModule = (() => {
       })
     }
 
-    query (conn, mapFn) {
+    async query (conn, mapFn) {
       const inst = this
       return new Promise((resolve, reject) => {
         inst.resolve().then(sql => {
@@ -66,7 +66,7 @@ const metaModule = (() => {
       this.describeTable2014 = new FileReader('table_describe.2014.sql')
     }
 
-    getUserType (conn, userTypeName, mapFn) {
+    async getUserType (conn, userTypeName, mapFn) {
       return new Promise((resolve, reject) => {
         this.describeTableType.query(conn, mapFn).then(typeResults => {
           typeResults.forEach(col => {
@@ -82,15 +82,15 @@ const metaModule = (() => {
       })
     }
 
-    getProcedureDefinition (conn, procedureName, mapFn) {
+    async getProcedureDefinition (conn, procedureName, mapFn) {
       return this.describeProc.query(conn, mapFn)
     }
 
-    getServerVersionRes (conn) {
+    async getServerVersionRes (conn) {
       return this.describeServerVersion.query(conn)
     }
 
-    getTableDefinition (conn, majorVersion, mapFn) {
+    async getTableDefinition (conn, majorVersion, mapFn) {
       const target = majorVersion <= 2014 ? this.describeTable2014 : this.describeTable
       return target.query(conn, mapFn)
     }

lib/meta.js

@@ -35,7 +35,7 @@ const notifyModule = ((() => {
       this.se = se
     }
 
-    cancel (timeout) {
+    async cancel (timeout) {
       timeout = timeout || 5000
       const q = this.se
       let err
@@ -163,7 +163,7 @@ const notifyModule = ((() => {
 
     getChunkyArgs (paramsOrCallback, callback) {
       if ((typeof paramsOrCallback === 'object' &&
-          Array.isArray(paramsOrCallback) === true) &&
+          Array.isArray(paramsOrCallback)) &&
         typeof callback === 'function') {
         return new ChunkyArgs(paramsOrCallback, callback)
       }
@@ -177,7 +177,7 @@ const notifyModule = ((() => {
       }
 
       if ((typeof paramsOrCallback === 'object' &&
-          Array.isArray(paramsOrCallback) === true) &&
+          Array.isArray(paramsOrCallback)) &&
         callback === undefined) {
         return new ChunkyArgs(paramsOrCallback, null)
       }

lib/notifier.js

@@ -361,7 +361,7 @@ const poolModule = (() => {
           pause.unshift(add.pop())
         }
         if (start !== pause.length) {
-          setImmediate(() => crank())
+          setImmediate(() => { crank() })
         }
       }
 
@@ -413,7 +413,7 @@ const poolModule = (() => {
         return new PoolWorkItem(commandId++, sql, paramsOrCallback, callback, notifier, workType, chunk(paramsOrCallback, callback, workType))
       }
 
-      function checkClosedPromise () {
+      async function checkClosedPromise () {
         return new Promise((resolve, reject) => {
           if (closed) {
             reject(closedError)
@@ -456,26 +456,26 @@ const poolModule = (() => {
         return submit(sql, paramsOrCallback, callback, workTypeEnum.PROC)
       }
 
-      function getUserTypeTable (name) {
+      async function getUserTypeTable (name) {
         // the table mgr will submit query into pool as if it's a connection
-        return checkClosedPromise().then(() => tableMgr.promises.getUserTypeTable(name))
+        return checkClosedPromise().then(async () => tableMgr.promises.getUserTypeTable(name))
       }
 
-      function getTable (name) {
-        return checkClosedPromise().then(() => tableMgr.promises.getTable(name))
+      async function getTable (name) {
+        return checkClosedPromise().then(async () => tableMgr.promises.getTable(name))
       }
 
-      function getProc (name) {
-        return checkClosedPromise().then(() => procedureManager.promises.getProc(name))
+      async function getProc (name) {
+        return checkClosedPromise().then(async () => procedureManager.promises.getProc(name))
       }
 
       // returns a promise of aggregated results not a query
-      function callprocAggregator (name, params, options) {
-        return checkClosedPromise().then(() => aggregator.callProc(name, params, options))
+      async function callprocAggregator (name, params, options) {
+        return checkClosedPromise().then(async () => aggregator.callProc(name, params, options))
       }
 
-      function queryAggregator (sql, params, options) {
-        return checkClosedPromise().then(() => aggregator.query(sql, params, options))
+      async function queryAggregator (sql, params, options) {
+        return checkClosedPromise().then(async () => aggregator.query(sql, params, options))
       }
 
       function enqueue (item) {
@@ -566,7 +566,7 @@ const poolModule = (() => {
                 connectionOptions(c)
                 checkin('grow', getDescription(c))
               },
-              e => {
+              async e => {
                 --pendingCreates
                 return Promise.reject(e)
               }

lib/pool.js

@@ -2,12 +2,12 @@ const { utilModule } = require('./util')
 const { BasePromises } = require('./base-promises')
 
 class PreparedStatementPromises extends BasePromises {
-  query (params, options) {
+  async query (params, options) {
     const q = this.prepared.preparedQuery(params)
     return this.aggregator.queryPrepared(q, options)
   }
 
-  free () {
+  async free () {
     return this.op(cb => this.prepared.free(cb))
   }