@pi-r/mssql 0.6.6 → 0.7.0

package/README.md

@@ -1,10 +1,7 @@
-# @pi-r/mssql
+### @pi-r/mssql
 
-## Documentation
+https://e-mc.readthedocs.io/en/latest/db/mssql.html
 
-- [E-mc](https://e-mc.readthedocs.io/en/latest/db/mssql.html)
-- [squared](https://squared.readthedocs.io)
-
-## LICENSE
+### LICENSE
 
 MIT

package/client/index.js

@@ -57,7 +57,9 @@ function convertParameters(sql, params, output) {
                     }
                     const columns = value.columns;
                     if ((0, types_1.isArray)(columns)) {
-                        columns.forEach(col => col.type = convertType(sql, col.type, col.value, col.options || (col.options = {})));
+                        columns.forEach(col => {
+                            col.type = convertType(sql, col.type, col.value, col.options ||= {});
+                        });
                     }
                 }
                 this[output ? 'addOutputParameter' : 'addParameter'](name, type, value, options);
@@ -95,18 +97,18 @@ function convertType(sql, type, value, options) {
                 return sql.Int;
             }
             return sql.BigInt;
-        case 'string':
-            return sql.VarChar;
         case 'object':
             if (value instanceof Date) {
                 return sql.DateTime2;
             }
             if (Buffer.isBuffer(value)) {
-                options.length = Infinity;
+                if (Array.isArray(options)) {
+                    options.length = Infinity;
+                }
                 return sql.VarBinary;
             }
         default:
-            return sql.Null;
+            return sql.VarChar;
     }
 }
 function getPoolKey(credential) {
@@ -154,24 +156,24 @@ function setCredential(item) {
     }
     const errors = [];
     if (hostname) {
-        credential.server || (credential.server = hostname);
+        credential.server ||= hostname;
     }
     if (!credential.server) {
         errors.push('server');
     }
-    const auth = credential.authentication || (credential.authentication = { options: {} });
-    const authOptions = auth.options || (auth.options = {});
-    auth.type || (auth.type = 'default');
+    const auth = credential.authentication ||= { options: {} };
+    const authOptions = auth.options ||= {};
+    auth.type ||= 'default';
     if (database || port) {
-        const options = credential.options || (credential.options = {});
-        options.database || (options.database = database);
+        const options = credential.options ||= {};
+        options.database ||= database;
         if (port) {
-            options.port || (options.port = +port);
+            options.port ||= +port;
         }
     }
     if (username || password) {
-        authOptions.userName || (authOptions.userName = username);
-        authOptions.password || (authOptions.password = password);
+        authOptions.userName ||= username;
+        authOptions.password ||= password;
     }
     if (!authOptions.userName) {
         errors.push('authentication.options.userName');
@@ -221,16 +223,16 @@ function setCredential(item) {
     if (config) {
         const { min, max, idle, queue_idle } = config;
         if (min >= 0) {
-            poolConfig.min ?? (poolConfig.min = min);
+            poolConfig.min ??= min;
         }
         if (max > 0) {
-            poolConfig.max ?? (poolConfig.max = max);
+            poolConfig.max ??= max;
         }
         if (idle >= 0) {
-            poolConfig.idleTimeout ?? (poolConfig.idleTimeout = idle);
+            poolConfig.idleTimeout ??= idle;
         }
         if (queue_idle >= 0) {
-            poolConfig.acquireTimeout ?? (poolConfig.acquireTimeout = queue_idle);
+            poolConfig.acquireTimeout ??= queue_idle;
         }
     }
     const poolKey = getPoolKey(credential);
@@ -268,7 +270,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         parallel = !batch.some(item => item.parallel === false);
     }
     if (!parallel) {
-        outResult || (outResult = new Array(length));
+        outResult ||= new Array(length);
     }
     const caching = this.hasCache("mssql", sessionKey);
     const tasks = new Array(length);
@@ -359,7 +361,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
             continue;
         }
         item.transactionState = 1;
-        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("mssql", 'options', null, credential) && (0, types_1.asFunction)(item.streamRow) : item.streamRow;
+        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("mssql", 'options', credential) && (0, types_1.asFunction)(item.streamRow) : item.streamRow;
         const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
         let params = item.params, queryString = '';
         if (caching && ignoreCache !== true && !streamRow) {
@@ -461,26 +463,32 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     }
                     rows.push(result);
                 })
-                    .on('returnValue', (name, value) => (output || (output = {}))[name] = value)
+                    .on('returnValue', (name, value) => (output ||= {})[name] = value)
                     .on('done', rowCount => {
-                    if (resume && rowCount >= 0) {
-                        ++recordset;
+                    if (rowCount !== undefined) {
+                        if (resume && rowCount >= 0) {
+                            ++recordset;
+                        }
+                        resume = false;
                     }
-                    resume = false;
                 })
                     .on('doneProc', rowCount => {
-                    if (resume && rowCount >= 0) {
-                        ++recordset;
+                    if (rowCount !== undefined) {
+                        if (resume && rowCount >= 0) {
+                            ++recordset;
+                        }
+                        resume = false;
                     }
-                    resume = false;
                 })
                     .on('doneInProc', rowCount => {
-                    if (resume && rowCount >= 0) {
-                        ++recordset;
+                    if (rowCount !== undefined) {
+                        if (resume && rowCount >= 0) {
+                            ++recordset;
+                        }
+                        resume = false;
                     }
-                    resume = false;
                 })
-                    .on('error', err => error || (error = err));
+                    .on('error', err => error ||= err);
                 if (item.storedProc) {
                     client.callProcedure(request);
                 }
@@ -509,8 +517,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
     }
     return this.processRows(batch, tasks, {
         disconnect: () => {
-            clients.forEach(item => item.close());
-            pools.forEach(item => item.release());
+            clients.forEach(item => {
+                item.close();
+            });
+            pools.forEach(item => {
+                item.release();
+            });
         },
         parallel
     }, outResult);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/mssql",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "description": "MSSQL client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.8.7",
-    "@e-mc/types": "^0.8.7",
+    "@e-mc/db": "^0.9.0",
+    "@e-mc/types": "^0.9.0",
     "tedious": "^16.7.1",
     "tedious-connection-pool2": "^2.1.0"
   }

package/types/index.d.ts

@@ -2,17 +2,17 @@ import type { DbDataSource } from '@e-mc/types/lib/squared';
 
 import type { ExecuteAction, ServerAuth } from '@e-mc/types/lib/db';
 
-// @ts-ignore
-import type { ConnectionConfig, ParameterOptions, TediousType, TediousTypes } from 'tedious';
-// @ts-ignore
-import type { PoolConfig } from 'tedious-connection-pool';
+import type { ConnectionConfiguration, TYPES } from 'tedious';
+import type { DataType, ParameterData } from 'tedious/lib/data-type';
 
-export interface MSSQLDataSource extends DbDataSource<string, unknown, unknown, string | MSSQLCredential, string | PoolConfig>, ExecuteAction<MSSQLRequestParameters | MSSQLRequestWithOutputParameters> {
+import type { PoolConfig } from './pool';
+
+export interface MSSQLDataSource extends DbDataSource<string, unknown, unknown, MSSQLCredential, string | PoolConfig>, ExecuteAction<MSSQLRequestParameters | MSSQLRequestWithOutputParameters> {
     source: "mssql";
     storedProc?: boolean;
 }
 
-export interface MSSQLCredential extends ServerAuth, ConnectionConfig {}
+export interface MSSQLCredential extends ServerAuth, Omit<ConnectionConfiguration, "server"> {}
 
 export interface MSSQLRequestWithOutputParameters {
     input?: MSSQLRequestParameters;
@@ -22,8 +22,9 @@ export interface MSSQLRequestWithOutputParameters {
 export interface MSSQLRequestParameterValue {
     name?: string;
     value?: unknown;
-    type?: keyof TediousTypes | TediousType;
-    options?: ParameterOptions;
+    type?: DataType;
+    options?: ParameterData;
 }
 
-export type MSSQLRequestParameters = MSSQLRequestParameterValue[] | Record<string, Omit<MSSQLRequestParameterValue, "name">> | null;
+export type MSSQLRequestParameters = Null<MSSQLRequestParameterValue[] | ObjectMap<Omit<MSSQLRequestParameterValue, "name">>>;
+export type MSSQLDataType = keyof typeof TYPES;

package/types/pool.d.ts

@@ -0,0 +1,69 @@
+/* eslint @typescript-eslint/consistent-type-imports: "off" */
+
+import type { Connection, ConnectionConfiguration } from 'tedious';
+
+import type * as EventEmitter from 'events';
+
+declare class Pool extends EventEmitter {
+    /**
+     * Connection Pool constructor
+     * @param poolConfig the pool configuration
+     * @param connectionConfig the connection configuration
+     */
+    constructor(poolConfig: Pool.PoolConfig, connectionConfig: ConnectionConfiguration);
+
+    /**
+     * acquires a connection from the pool
+     * @param callback invoked when the connection is retrieved and ready
+     */
+    acquire(callback: (err: Error, connection: Pool.PooledConnection) => void): void;
+
+    /**
+     * closes opened connections
+     */
+    drain(): void;
+}
+
+declare namespace Pool {
+
+    export class PooledConnection extends Connection {
+        /**
+         * If the connection is issued from a connection pool returns the connection to the pool.
+         */
+        release(): void;
+    }
+
+    export interface PoolConfig {
+        /**
+         * Minimum concurrent connections
+         */
+        min?: number | undefined;
+
+        /**
+         * Maximum concurrent connections
+         */
+        max?: number | undefined;
+
+        /**
+         * Defines if logging is activated
+         */
+        log?: boolean | undefined;
+
+        /**
+         * Idle timeout
+         */
+        idleTimeout?: number | undefined;
+
+        /**
+         * Retry delay
+         */
+        retryDelay?: number | undefined;
+
+        /**
+         * Acquire timeout
+         */
+        acquireTimeout?: number | undefined;
+    }
+}
+
+export = Pool;