@blazedpath/commons 0.2.2 → 0.3.1

package/blz-math/index.js

@@ -1,131 +0,0 @@
-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

@@ -1,326 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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("``");
-    });
-});