@nka212bg/backend-utils 0.1.44 → 0.1.45

package/db/dbUtils.js

@@ -1,17 +1,51 @@
-// HELPERS
-exports.stripString = (input) => {
+exports.sqlSanitize = (input, { backslashEscapes = false } = {}) => {
     if (!input) return input;
+    input = String(input);
 
-    return (
-        String(input)
-            // .replace(/([!@#$%^&*,/\\<>]| )+/g, " ")
-            .replace(/\/\*|\*\/| +/g, " ")
-            .replace(/(( +$)?(' *)( +$)?)+/g, "'")
-            .replace(/(( +$)?(" *)( +$)?)+/g, '"')
-            .replace(/\-+/g, "-")
-            .replace(/  +/g, "  ")
-            .trim()
-    );
+    let out = "";
+    let ended = false;
+
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        const next = input[i + 1];
+        const isComment = (ch == "-" && next == "-") || (ch == "/" && next == "*");
+        const isSpace = /\s/.test(ch);
+
+        if (ended && !isComment && !isSpace && ch != ";") throw "Multiple statements in sql";
+
+        if (ch == "'" || ch == '"' || ch == "`") {
+            let end = i + 1;
+            while (true) {
+                if (backslashEscapes && input[end] == "\\") {
+                    end += 2;
+                    continue;
+                }
+                if (end >= input.length) throw "Unclosed quote in sql";
+                if (input[end] == ch) {
+                    if (input[end + 1] != ch) break;
+                    end++; // doubled quote is an escaped quote
+                }
+                end++;
+            }
+            out += input.slice(i, end + 1);
+            i = end;
+        } else if (ch == "-" && next == "-") {
+            const end = input.indexOf("\n", i);
+            i = end == -1 ? input.length : end - 1;
+        } else if (ch == "/" && next == "*") {
+            const end = input.indexOf("*/", i + 2);
+            i = end == -1 ? input.length : end + 1;
+            if (!out.endsWith(" ")) out += " ";
+        } else if (ch == ";") {
+            ended = true;
+        } else if (isSpace) {
+            if (!out.endsWith(" ")) out += " ";
+        } else {
+            out += ch;
+        }
+    }
+
+    return out.trim();
 };
 
 exports.paramsSanitize = (params) => {
@@ -19,6 +53,11 @@ exports.paramsSanitize = (params) => {
     if (!Array.isArray(params)) params = [params];
 
     return params.map((param) => {
+        // blobs: Buffer, Uint8Array and other typed arrays, ArrayBuffer
+        if (Buffer.isBuffer(param)) return param;
+        if (ArrayBuffer.isView(param)) return Buffer.from(param.buffer, param.byteOffset, param.byteLength);
+        if (param instanceof ArrayBuffer) return Buffer.from(param);
+
         if (typeof param == "object" && param !== null) return JSON.stringify(param);
         if (typeof param == "boolean") return param ? 1 : 0;
         if (typeof param == "number") return param;

package/db/mysql2.js

@@ -1,4 +1,4 @@
-const { paramsSanitize, stripString } = require("./dbUtils");
+const { paramsSanitize } = require("./dbUtils");
 const { createPool } = require("mysql2");
 
 const pool = createPool({
@@ -16,7 +16,7 @@ exports.mysql = (sql, params) => {
     // (SELECT JSON_ARRAYAGG(JSON_OBJECT('CountryId', CountryID)) FROM country) AS Countries  // JSON_ARRAYAGG and JSON_OBJECT demos
     return new Promise((resolve) => {
         try {
-            sql = stripString(sql);
+            sql = String(sql ?? "").trim();
             if (!sql) throw "Missing sql";
 
             if (params?.length) {

package/db/sqlite3.js

@@ -1,7 +1,8 @@
-const { paramsSanitize, stripString } = require("./dbUtils");
+const { paramsSanitize } = require("./dbUtils");
 const sqlite3 = require("sqlite3").verbose();
 
 const dbs = {};
+const opening = {};
 let vacuumed = [];
 let day = new Date().getDate();
 
@@ -26,9 +27,10 @@ setInterval(() => {
 exports.sqlite = (dbName, sql, params = []) => {
     return new Promise(async (resolve) => {
         try {
-            sql = stripString(sql);
+            sql = String(sql ?? "").trim();
             if (!sql) throw "Missing sql";
-            const isWrite = /^(INSERT|DELETE|UPDATE)/i.test(sql);
+
+            const isWrite = /^(INSERT|DELETE|UPDATE|REPLACE)/i.test(sql);
             const queryPlaceholdersLength = (sql.match(/\?/g) || []).length; // [?]
 
             if (queryPlaceholdersLength < params.length) {
@@ -37,57 +39,65 @@ exports.sqlite = (dbName, sql, params = []) => {
                 params = params.concat(Array(queryPlaceholdersLength - params.length).fill(params[params.length - 1]));
             }
 
-            let dbError;
             if (!dbs[dbName]) {
-                let db;
-                await new Promise(async (resolve) => {
-                    db = new sqlite3.Database(dbName, (error) => {
-                        dbError = error;
+                // concurrent callers wait for the same opening, so only one connection is created
+                opening[dbName] ||= new Promise((resolve, reject) => {
+                    const db = new sqlite3.Database(dbName, (error) => {
+                        delete opening[dbName];
+                        if (error) return reject(error);
+
+                        // some db settings here
+                        db.run("pragma synchronous = normal");
+
+                        if (dbName.endsWith("/main.db")) {
+                            db.run("pragma temp_store = memory").run("pragma mmap_size = 3000000000");
+                        }
+
+                        dbs[dbName] = db;
                         resolve();
                     });
                 });
 
-                if (dbError) throw dbError;
-
-                db.time = Date.now();
-                dbs[dbName] = db;
+                await opening[dbName];
+            }
 
-                // some db settings here
-                dbs[dbName].run("pragma synchronous = normal");
+            // keep a local reference, the interval may delete dbs[dbName] before the callback runs
+            const db = dbs[dbName];
+            db.time = Date.now(); // last use, the interval closes it after 5 min idle
 
-                if (dbName.endsWith("/main.db")) {
-                    dbs[dbName].run("pragma temp_store = memory").run("pragma mmap_size = 3000000000");
+            db[isWrite ? "run" : "all"](sql, paramsSanitize(params), function (error, res) {
+                if (error) {
+                    printError(error);
+                    return resolve({ error });
                 }
-            }
-
-            dbs[dbName][isWrite ? "run" : "all"](sql, paramsSanitize(params), function (error, res) {
-                if (error) return resolve({ error });
 
                 !res?.length && (res = undefined);
                 const changes = this.changes;
 
-                if (/^INSERT/i.test(sql)) {
-                    const targetDB = /INTO\s(.*?) /i.exec(sql)[1];
+                if (/^(INSERT|REPLACE)/i.test(sql)) {
+                    const targetDB = /INTO\s+([^\s(]+)/i.exec(sql)?.[1];
                     const insertId = this.lastID;
-                    return dbs[dbName].all(`SELECT name FROM pragma_table_info(?) WHERE pk = 1 LIMIT 1`, [targetDB], function (error, insertData) {
-                        insertData = insertData?.[0] ? { [insertData[0].name]: insertId } : undefined;
+                    if (!targetDB) return resolve({ error, data: undefined, changes });
 
-                        resolve({ error, data: insertData, changes });
+                    // primary key name per table, cached on the connection so the pragma runs once per table
+                    db.pk ||= {};
+                    if (targetDB in db.pk) return resolve({ error, data: db.pk[targetDB] ? { [db.pk[targetDB]]: insertId } : undefined, changes });
+
+                    return db.all(`SELECT name FROM pragma_table_info(?) WHERE pk = 1 LIMIT 1`, [targetDB], function (error, insertData) {
+                        const pk = insertData?.[0]?.name;
+                        if (!error) db.pk[targetDB] = pk;
+
+                        resolve({ error, data: pk ? { [pk]: insertId } : undefined, changes });
                         printError(error);
                     });
                 } else {
                     resolve({ error, data: res, changes });
                     printError(error);
 
-                    if (/^DELETE/i.test(sql)) dbs[dbName].vacuum = true;
+                    if (/^DELETE/i.test(sql) && changes) db.vacuum = true;
                 }
             });
         } catch (error) {
-            try {
-                dbs[dbName].close();
-            } catch {}
-
-            delete dbs[dbName];
             resolve({ error, data: undefined });
             printError(error);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@nka212bg/backend-utils",
     "author": "nka212bg",
-    "version": "0.1.44",
+    "version": "0.1.45",
     "main": "index.js",
     "dependencies": {
         "@maxmind/geoip2-node": "^5.0.0",