@stashfin/mysql2 1.2.16 → 1.3.1

package/index copy.d.ts

@@ -0,0 +1,17 @@
+import mysql, { RowDataPacket, PoolOptions, ResultSetHeader } from 'mysql2/promise';
+export interface MysqlConnectorOptions extends PoolOptions {
+}
+export declare class MysqlConnector {
+    private pool;
+    private credentials;
+    constructor(credentials: PoolOptions);
+    /** A random method to simulate a step before to get the class methods */
+    getConnection(): Promise<mysql.PoolConnection>;
+    queryRow<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T | undefined>;
+    queryRows<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;
+    queryArray<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;
+    executeResult(sql: string, values?: unknown[]): Promise<ResultSetHeader>;
+    insertData(tableName: string, data: Record<string, string | number>): Promise<ResultSetHeader>;
+    updateData(tableName: string, data: Record<string, any>, condition: string, conditionValues?: Array<string | number>): Promise<ResultSetHeader>;
+    close(): Promise<void>;
+}

package/index copy.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnector = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+//define class
+class MysqlConnector {
+    pool;
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.pool = promise_1.default.createPool(this.credentials);
+    }
+    /** A random method to simulate a step before to get the class methods */
+    getConnection() {
+        if (!this?.pool)
+            this.pool = promise_1.default.createPool(this.credentials);
+        return this.pool.getConnection();
+    }
+    async queryRow(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows[0] || undefined;
+    }
+    async queryRows(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows;
+    }
+    async queryArray(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query({
+            sql,
+            values,
+            rowsAsArray: true,
+        });
+        await connection.release();
+        return rows;
+    }
+    async executeResult(sql, values) {
+        const connection = await this.pool.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows;
+    }
+    async insertData(tableName, data) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const sql = `INSERT INTO ${tableName} (${keys.join(', ')}) VALUES (${keys
+            .map(() => '?')
+            .join(', ')})`;
+        return this.executeResult(sql, values);
+    }
+    async updateData(tableName, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, condition, conditionValues) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const sql = `UPDATE ${tableName} SET ${keys
+            .map((key) => `${key} = ?`)
+            .join(', ')} WHERE ${condition}`;
+        const finalValues = [...values, ...(conditionValues || [])];
+        return this.executeResult(sql, finalValues);
+    }
+    async close() {
+        await this.pool.end();
+    }
+}
+exports.MysqlConnector = MysqlConnector;

package/index.d.ts

@@ -1,4 +1,4 @@
-import mysql, { RowDataPacket, PoolOptions, ResultSetHeader } from 'mysql2/promise';
+import mysql, { RowDataPacket, PoolOptions, ResultSetHeader } from 'mysql2';
 export interface MysqlConnectorOptions extends PoolOptions {
 }
 export declare class MysqlConnector {
@@ -6,7 +6,7 @@ export declare class MysqlConnector {
     private credentials;
     constructor(credentials: PoolOptions);
     /** A random method to simulate a step before to get the class methods */
-    getConnection(): Promise<mysql.PoolConnection>;
+    getConnection(): mysql.Pool;
     queryRow<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T | undefined>;
     queryRows<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;
     queryArray<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;

package/index.js

@@ -4,48 +4,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlConnector = void 0;
-const promise_1 = __importDefault(require("mysql2/promise"));
+const mysql2_1 = __importDefault(require("mysql2"));
 //define class
 class MysqlConnector {
     pool;
     credentials;
     constructor(credentials) {
         this.credentials = credentials;
-        this.pool = promise_1.default.createPool(this.credentials);
+        this.pool = mysql2_1.default.createPool(this.credentials);
     }
     /** A random method to simulate a step before to get the class methods */
     getConnection() {
         if (!this?.pool)
-            this.pool = promise_1.default.createPool(this.credentials);
-        return this.pool.getConnection();
+            this.pool = mysql2_1.default.createPool(this.credentials);
+        return this.pool;
     }
     async queryRow(sql, values) {
-        const connection = await this.getConnection();
-        const [rows] = await connection.query(sql, values);
-        await connection.release();
-        return rows[0] || undefined;
+        const pool = this.getConnection();
+        return new Promise((resolve, reject) => {
+            pool.query(sql, values, function (err, results, fields) {
+                if (err)
+                    reject(err);
+                // Connection is automatically released when query resolves
+                else
+                    resolve(results[0] || undefined);
+            });
+        });
     }
     async queryRows(sql, values) {
-        const connection = await this.getConnection();
-        const [rows] = await connection.query(sql, values);
-        await connection.release();
-        return rows;
+        const pool = this.getConnection();
+        return new Promise((resolve, reject) => {
+            pool.query(sql, values, function (err, results, fields) {
+                // Connection is automatically released when query resolves
+                if (err)
+                    reject(err);
+                else
+                    resolve(results);
+            });
+        });
     }
     async queryArray(sql, values) {
-        const connection = await this.getConnection();
-        const [rows] = await connection.query({
-            sql,
-            values,
-            rowsAsArray: true,
+        const pool = this.getConnection();
+        return new Promise((resolve, reject) => {
+            pool.query({ sql, values, rowsAsArray: true }, function (err, results, fields) {
+                // Connection is automatically released when query resolves
+                if (err)
+                    reject(err);
+                else
+                    resolve(results);
+            });
         });
-        await connection.release();
-        return rows;
     }
     async executeResult(sql, values) {
-        const connection = await this.pool.getConnection();
-        const [rows] = await connection.query(sql, values);
-        await connection.release();
-        return rows;
+        const pool = this.getConnection();
+        return new Promise((resolve, reject) => {
+            pool.query(sql, values, function (err, results, fields) {
+                // Connection is automatically released when query resolves
+                if (err)
+                    reject(err);
+                else
+                    resolve(results || undefined);
+            });
+        });
     }
     async insertData(tableName, data) {
         const keys = Object.keys(data);

package/indexPromise.d.ts

@@ -0,0 +1,17 @@
+import mysql, { RowDataPacket, PoolOptions, ResultSetHeader } from 'mysql2/promise';
+export interface MysqlConnectorOptions extends PoolOptions {
+}
+export declare class MysqlConnector {
+    private pool;
+    private credentials;
+    constructor(credentials: PoolOptions);
+    /** A random method to simulate a step before to get the class methods */
+    getConnection(): Promise<mysql.PoolConnection>;
+    queryRow<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T | undefined>;
+    queryRows<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;
+    queryArray<T extends RowDataPacket>(sql: string, values?: Array<string | number>): Promise<T[]>;
+    executeResult(sql: string, values?: unknown[]): Promise<ResultSetHeader>;
+    insertData(tableName: string, data: Record<string, string | number>): Promise<ResultSetHeader>;
+    updateData(tableName: string, data: Record<string, any>, condition: string, conditionValues?: Array<string | number>): Promise<ResultSetHeader>;
+    close(): Promise<void>;
+}

package/indexPromise.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnector = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+//define class
+class MysqlConnector {
+    pool;
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.pool = promise_1.default.createPool(this.credentials);
+    }
+    /** A random method to simulate a step before to get the class methods */
+    getConnection() {
+        if (!this?.pool)
+            this.pool = promise_1.default.createPool(this.credentials);
+        return this.pool.getConnection();
+    }
+    async queryRow(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows[0] || undefined;
+    }
+    async queryRows(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows;
+    }
+    async queryArray(sql, values) {
+        const connection = await this.getConnection();
+        const [rows] = await connection.query({
+            sql,
+            values,
+            rowsAsArray: true,
+        });
+        await connection.release();
+        return rows;
+    }
+    async executeResult(sql, values) {
+        const connection = await this.pool.getConnection();
+        const [rows] = await connection.query(sql, values);
+        await connection.release();
+        return rows;
+    }
+    async insertData(tableName, data) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const sql = `INSERT INTO ${tableName} (${keys.join(', ')}) VALUES (${keys
+            .map(() => '?')
+            .join(', ')})`;
+        return this.executeResult(sql, values);
+    }
+    async updateData(tableName, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data, condition, conditionValues) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const sql = `UPDATE ${tableName} SET ${keys
+            .map((key) => `${key} = ?`)
+            .join(', ')} WHERE ${condition}`;
+        const finalValues = [...values, ...(conditionValues || [])];
+        return this.executeResult(sql, finalValues);
+    }
+    async close() {
+        await this.pool.end();
+    }
+}
+exports.MysqlConnector = MysqlConnector;

package/models/Loans.d.ts

@@ -25,7 +25,7 @@ export interface LoansTable {
     source?: 'app' | 'thirdparty' | null;
     ip?: string | null;
     approval_date?: Date | null;
-    disbursal_date?: Date | null;
+    disbursal_date?: string | null;
     closure_date?: Date | null;
     is_auto_processing?: number | null;
     remarks?: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stashfin/mysql2",
-  "version": "1.2.16",
+  "version": "1.3.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",