@blazedpath/commons 0.0.4

package/blz-math/index.js

@@ -0,0 +1,131 @@
+module.exports = {
+    abs: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.abs(value);
+    },
+    acos: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.acos(value);
+    },
+    asin: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.asin(value);
+    },
+    atan: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.atan(value);
+    },
+    atan2: function (valueX, valueY) {
+        if (valueX === null || valueX === undefined)
+            return null;
+        if (valueY === null || valueY === undefined)
+            return null;
+        return Math.atan(valueY, valueX);
+    },
+    ceil: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.ceil(value);
+    },
+    cos: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.cos(value);
+    },
+    cosh: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.cosh(value);
+    },
+    exp: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.exp(value);
+    },
+    floor: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.floor(value);
+    },
+    log: function (value, base) {
+        if (value === null || value === undefined)
+            return null;
+        if (base)
+            return Math.log(value) / Math.log(base);
+        else
+            return Math.log(value);
+    },
+    log10: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.log10(value);
+    },
+    pow: function (value, power) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.pow(value, power ? power : 0);
+    },
+    random: function () {
+        if (typeof window !== 'undefined') {
+            let crypto = window.crypto || window.msCrypto;
+            var array = new Uint32Array(2);
+            crypto.getRandomValues(array);
+            let mantissa = (array[0] * Math.pow(2, 20)) + (array[1] >>> 12);
+            return mantissa * Math.pow(2, -52);
+        }
+        else {
+            let crypto = require('crypto');
+            return crypto.randomBytes(4).readUInt32BE(0) / 4294967296;            
+        }
+    },
+    round: function (value, decimals) {
+        if (value === null || value === undefined)
+            return null;
+        if (decimals)
+            return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+        else
+            return Math.round(value);
+    },
+    sign: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.sign(value);
+    },
+    sin: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.sin(value);
+    },
+    sinh: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.sinh(value);
+    },
+    sqrt: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.sqrt(value);
+    },
+    tan: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.tan(value);
+    },
+    tanh: function (value) {
+        if (value === null || value === undefined)
+            return null;
+        return Math.tanh(value);
+    },
+    trunc: function (value, decimals) {
+        if (value === null || value === undefined)
+            return null;
+        if (decimals)
+            return Math.trunc(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+        else
+            return Math.trunc(value);
+    }
+};

package/blz-mongodb/index.js

@@ -0,0 +1,326 @@
+const { MongoClient, ObjectId } = require('mongodb');
+const Fs = require('fs-extra');
+const AsyncRetry = require('async-retry');
+
+let mongodbConnections = {};
+
+let getMongodbConnection = async function (connection) {
+    let mongodbConnection = mongodbConnections[connection.name];
+    if (mongodbConnection === null || mongodbConnection === undefined) {
+        let mongoConfig = {};
+        // [MONGODB DRIVER] Warning: useUnifiedTopology is a deprecated option: useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version
+        // mongoConfig.useUnifiedTopology = true;
+        if (connection.ssl) {
+            mongoConfig.ssl = true;            
+            if (connection.sslCert)
+                mongoConfig.sslCert = await convertFileArg(connection.sslCert);
+            if (connection.sslCrl)
+                mongoConfig.tlsCRLFile = await convertFileArg(connection.sslCrl);
+            if (connection.sslKey)
+                mongoConfig.tlsCertificateKeyFile = await convertFileArg(connection.sslKey);
+            if (connection.sslPass)
+                mongoConfig.tlsCertificateKeyFilePassword = connection.sslPass;
+            if (connection.sslValidate)
+                mongoConfig.sslValidate = true;
+        }
+        if (connection.tls) {
+            mongoConfig.tls = true;
+            if (connection.tlsCaFile)
+                mongoConfig.tlsCAFile = connection.tlsCaFile;
+            if (connection.caFile)
+                mongoConfig.tlsCAFile = connection.caFile;
+            if (connection.tlsCertificateFile)
+                mongoConfig.tlsCertificateFile = await convertFileArg(connection.tlsCertificateFile);
+            if (connection.tlsCertificateKeyFile)
+                mongoConfig.tlsCertificateKeyFile = await convertFileArg(connection.tlsCertificateKeyFile);
+            if (connection.tlsCertificateKeyFilePassword)
+                mongoConfig.tlsCertificateKeyFilePassword = connection.tlsCertificateKeyFilePassword;
+        }
+        // start connect mongo with retry
+        let mongoClient = null;
+        if (connection.useRetries){
+            await AsyncRetry(async () => {
+                mongoClient = new MongoClient(connection.url, mongoConfig);
+                try {
+                  await mongoClient.connect();
+                } catch (err) {
+                  console.error('Error connecting to MongoDB:', err);
+                  throw err; // This will trigger a retry
+                } finally {
+                }
+            }, {
+                retries: connection.retryCount,
+                minTimeout: connection.minRetryInterval * 1000,
+                maxTimeout: connection.maxRetryInterval * 1000,
+              });
+        } else {
+            mongoClient = await MongoClient.connect(connection.url, mongoConfig);
+        }
+        mongodbConnection = mongoClient.db(connection.databaseName);
+        mongodbConnections[connection.name] = mongodbConnection;
+    }
+    return mongodbConnection;
+};
+
+let convertFileArg = async function (fileArg) {
+    if (fileArg) {
+        let fileArgParts = fileArg.split(',');
+        if (fileArgParts.length === 1) {
+            return await Fs.readFile(fileArgParts[0], 'utf-8');
+        }
+        else if (fileArgParts.length > 1) {
+            let promises = [];
+            for (let i = 0; i < fileArgParts.length; i++) {
+                let fileArgPart = fileArgParts[0];
+                promises.push(Fs.readFile(fileArgParts[i], 'utf-8'));
+            }
+            return await Promise.all(promises);
+        }
+    }
+    return null;
+};
+
+let convertFromMongodb = function (value) {
+    if (value) {
+        let strType = toString.call(value);
+        if (strType === '[object Object]') {
+            if (value._bsontype && value._bsontype === 'ObjectID') {
+                let result = {};
+                result['$oid'] = value.toHexString();
+                return result;
+            }
+            for (let prop in value) {
+                value[prop] = convertFromMongodb(value[prop]);
+            }
+        }
+        else if (strType === '[object Array]') {
+            for (let i = 0; i < value.length; i++) {
+                value[i] = convertFromMongodb(value[i]);
+            }
+        }        
+    }
+    return value;
+};
+
+let convertToMongodb = function (value) {
+    if (value) {
+        let strType = toString.call(value);
+        if (strType === '[object Object]') {
+            if (value['$oid'])
+                return new ObjectId(value['$oid']);
+            for (let prop in value) {
+                value[prop] = convertToMongodb(value[prop]);
+            }
+        }
+        else if (strType === '[object Array]') {
+            for (let i = 0; i < value.length; i++) {
+                value[i] = convertToMongodb(value[i]);
+            }
+        }
+    }
+    return value;
+};
+
+let mongodbAggregate = async function (connection, collectionName, pipeline, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbCursor = await mongodbConnection.collection(collectionName).aggregate(convertToMongodb(pipeline), options);
+    if (mongodbCursor)
+        return await mongodbCursor.map(function (mongoDbDoc) { return convertFromMongodb(mongoDbDoc); }).toArray();
+    return null;
+};
+
+let mongodbBulkWrite = async function (connection, collectionName, operations, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).bulkWrite(convertToMongodb(operations), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbCountDocuments = async function (connection, collectionName, query, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).countDocuments(convertToMongodb(query), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbCreateIndex = async function (connection, collectionName, fieldOrSpec, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).createIndex(convertToMongodb(fieldOrSpec), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbDeleteMany = async function (connection, collectionName, filter, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).deleteMany(convertToMongodb(filter), options);
+    let result = convertFromMongodb(mongodbResult);
+    return result.deletedCount;
+};
+
+let mongodbDeleteOne = async function (connection, collectionName, filter, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).deleteOne(convertToMongodb(filter), options);
+    let result = convertFromMongodb(mongodbResult);
+    return result.deletedCount;
+};
+
+let mongodbDistinct = async function (connection, collectionName, key, query, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).distinct(key, convertToMongodb(query), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbDrop = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).drop(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbDropIndex = async function (connection, collectionName, indexName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).dropIndex(indexName, options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbDropIndexes = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).dropIndexes(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbFind = async function (connection, collectionName, query, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbCursor = await mongodbConnection.collection(collectionName).find(convertToMongodb(query), options);
+    if (mongodbCursor){
+        const list = await mongodbCursor.map(function (mongoDbDoc) { return convertFromMongodb(mongoDbDoc); }).toArray();
+        return list;
+    }
+    return [];
+};
+
+let mongodbFindOne = async function (connection, collectionName, query, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).findOne(convertToMongodb(query), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbGeoHaystackSearch = async function (connection, collectionName, x, y, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).geoHaystackSearch(x, y, options);
+    if (mongodbResult && mongodbResult.results) {
+        let finalResults = [];
+        for (let i = 0; i < mongodbResult.results.length; i++)
+            finalResults.push(convertFromMongodb(mongodbResult.results[i]));
+        return finalResults;
+    }
+    return [];
+};
+
+let mongodbIndexExists = async function (connection, collectionName, indexName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).indexExists(indexName, options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbInsertMany = async function (connection, collectionName, docs, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).insertMany(convertToMongodb(docs), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbInsertOne = async function (connection, collectionName, doc, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).insertOne(convertToMongodb(doc), options);
+    let result = convertFromMongodb(mongodbResult);
+    return result.insertedId;
+};
+
+let mongodbIsCapped = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).isCapped(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbListIndexes = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbCursor = await mongodbConnection.collection(collectionName).listIndexes(options);
+    if (mongodbCursor)
+        return await mongodbCursor.map(function (mongoDbDoc) { return convertFromMongodb(mongoDbDoc); }).toArray();
+    return [];
+};
+
+let mongodbOptions = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).options(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbReIndex = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).reIndex(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbReplaceOne = async function (connection, collectionName, filter, replacement, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).replaceOne(convertToMongodb(filter), convertToMongodb(replacement), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbStats = async function (connection, collectionName, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).stats(options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbUpdateMany = async function (connection, collectionName, filter, update, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).updateMany(convertToMongodb(filter), convertToMongodb(update), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbUpdateOne = async function (connection, collectionName, filter, update, options) {
+    let mongodbConnection = await getMongodbConnection(connection);
+    let mongodbResult = await mongodbConnection.collection(collectionName).updateOne(convertToMongodb(filter), convertToMongodb(update), options);
+    return convertFromMongodb(mongodbResult);
+};
+
+let mongodbConnectionHealthCheck = async function (connection) {
+    try {
+        let mongodbConnection = (mongodbConnections[connection.name]) ?? await getMongodbConnection(connection)
+        const collections = await mongodbConnection.listCollections().toArray(); // Get all collections
+
+        if (collections.length > 0) {
+            return { status: "ok", message: "Connected, and collections readable." };
+        } else {
+            return { status: "ok", message: "Connected, but no collections readable." };
+        }
+    } catch (error) {
+        return { status: "error", message: error.message };
+    }
+}
+
+module.exports = {
+    mongodbAggregate: mongodbAggregate,
+    mongodbBulkWrite: mongodbBulkWrite,
+    mongodbCountDocuments: mongodbCountDocuments,
+    mongodbCreateIndex: mongodbCreateIndex,
+    mongodbDeleteMany: mongodbDeleteMany,
+    mongodbDeleteOne: mongodbDeleteOne,
+    mongodbDistinct: mongodbDistinct,
+    mongodbDrop: mongodbDrop,
+    mongodbDropIndex: mongodbDropIndex,
+    mongodbDropIndexes: mongodbDropIndexes,
+    mongodbFind: mongodbFind,
+    mongodbFindOne: mongodbFindOne,
+    mongodbGeoHaystackSearch: mongodbGeoHaystackSearch,
+    mongodbIndexExists: mongodbIndexExists,
+    mongodbInsertMany: mongodbInsertMany,
+    mongodbInsertOne: mongodbInsertOne,
+    mongodbIsCapped: mongodbIsCapped,
+    mongodbListIndexes: mongodbListIndexes,
+    mongodbOptions: mongodbOptions,
+    mongodbReIndex: mongodbReIndex,
+    mongodbReplaceOne: mongodbReplaceOne,
+    mongodbStats: mongodbStats,
+    mongodbUpdateMany: mongodbUpdateMany,
+    mongodbUpdateOne: mongodbUpdateOne,
+    mongodbConnectionHealthCheck: mongodbConnectionHealthCheck
+};

package/blz-rds/__test__/scape.test.js

@@ -0,0 +1,58 @@
+const { rdsEscape, rdsEscapeId } = require('../index.js');
+
+describe('rdsEscape', () => {
+    test("should escape a string with a single quote", () => {
+        const input = "O'Reilly";
+        const output = rdsEscape(input);
+        expect(output).toBe("'O\\'Reilly'");
+    });
+
+    test("should escape an empty string", () => {
+        const input = "";
+        const output = rdsEscape(input);
+        expect(output).toBe("''");
+    });
+
+    test("should escape null as NULL", () => {
+        const input = null;
+        const output = rdsEscape(input);
+        expect(output).toBe("NULL");
+    });
+
+    test("should escape a number as string", () => {
+        const input = 42;
+        const output = rdsEscape(input);
+        expect(output).toBe("42");
+    });
+
+    test("should escape booleans correctly", () => {
+        expect(rdsEscape(true)).toBe("true");
+        expect(rdsEscape(false)).toBe("false");
+    });
+});
+
+describe('rdsEscapeId', () => {
+    test("should escape an identifier containing backticks", () => {
+        const input = "user`name";
+        const output = rdsEscapeId(input);
+        expect(output).toBe("`user``name`");
+    });
+
+    test("should escape multiple identifiers (array)", () => {
+        const input = ['users', 'name'];
+        const output = rdsEscapeId(input);
+        expect(output).toBe("`users`, `name`");
+    });
+
+    test("should escape identifiers with special characters", () => {
+        const input = "order;DROP TABLE users";
+        const output = rdsEscapeId(input);
+        expect(output).toBe("`order;DROP TABLE users`");
+    });
+
+    test("should escape empty string as ``", () => {
+        const input = "";
+        const output = rdsEscapeId(input);
+        expect(output).toBe("``");
+    });
+});