@blazedpath/commons 0.0.4

package/blz-hazelcast/lib/hazelcastCache.js

@@ -0,0 +1,234 @@
+const { Client } = require('hazelcast-client');
+const genericPool = require('generic-pool');
+
+// Connection Pool cache
+let poolsByName = {};
+
+const CACHE_TYPE = {
+    MAP: 'map',
+	LIST: 'list'
+};
+
+function createHazelcastClient(config) {
+    return {
+        mapGet: function(name, key) {
+            return send(config, name, CACHE_TYPE.MAP, 'get', key);
+        },
+        mapGetAll: function(name, keys) {
+            return send(config, name, CACHE_TYPE.MAP, 'getAll', keys);
+        },
+        mapSet: function(name, key, value, ttl) {
+            if (ttl) {
+                return send(config, name, CACHE_TYPE.MAP, 'set', key, value, ttl);
+            } else {
+                return send(config, name, CACHE_TYPE.MAP, 'set', key, value);
+            }
+        },
+        mapSetAll: function(name, data) {
+            return send(config, name, CACHE_TYPE.MAP, 'setAll', data);
+        },
+        mapDelete: function(name, key) {
+            return send(config, name, CACHE_TYPE.MAP, 'delete', key);
+        },
+        mapSetTtl: function(name, key, ttl) {
+            return send(config, name, CACHE_TYPE.MAP, 'setTtl', key, ttl);
+        },
+        mapGetEntryView: function(name, key) {
+            return send(config, name, CACHE_TYPE.MAP, 'getEntryView', key);
+        },
+        mapContainsKey: function(name, key) {
+            return send(config, name, CACHE_TYPE.MAP, 'containsKey', key);
+        },
+        mapKeySet: function(name) {
+            return send(config, name, CACHE_TYPE.MAP, 'keySet');
+        },
+        mapValues: async function(name) {
+            const values = await send(config, name, CACHE_TYPE.MAP, 'values');
+            return values.toArray();
+        },
+        mapEntrySet: function(name) {
+            return send(config, name, CACHE_TYPE.MAP, 'entrySet');
+        },
+        mapSize: function(name) {
+            return send(config, name, CACHE_TYPE.MAP, 'size');
+        },
+        mapClear: function(name) {
+            return send(config, name, CACHE_TYPE.MAP, 'clear');
+        },
+        mapDestroy: function(name) {
+            return send(config, name, CACHE_TYPE.MAP, 'destroy');
+        },
+        listGet: function(name, index) {
+            return send(config, name, CACHE_TYPE.LIST, 'get', index);
+        },
+        listAdd: function(name, element) {
+            return send(config, name, CACHE_TYPE.LIST, 'add', element);
+        },
+        listAddAt: function(name, index, element) {
+            return send(config, name, CACHE_TYPE.LIST, 'addAt', index, element);
+        },
+        listAddAll: function(name, elements) {
+            return send(config, name, CACHE_TYPE.LIST, 'addAll', elements);
+        },
+        listRemove: function(name, element) {
+            return send(config, name, CACHE_TYPE.LIST, 'remove', element);
+        },
+        listRemoveAt: function(name, index) {
+            return send(config, name, CACHE_TYPE.LIST, 'removeAt', index);
+        },
+        listContains: function(name, element) {
+            return send(config, name, CACHE_TYPE.LIST, 'contains', element);
+        },
+        listIndexOf: function(name, element) {
+            return send(config, name, CACHE_TYPE.LIST, 'indexOf', element);
+        },
+        listSize: function(name) {
+            return send(config, name, CACHE_TYPE.LIST, 'size');
+        },
+        listClear: function(name) {
+            return send(config, name, CACHE_TYPE.LIST, 'clear');
+        },
+        listDestroy: function(name) {
+            return send(config, name, CACHE_TYPE.LIST, 'destroy');
+        }
+    }
+}
+
+async function getConnection(config) {
+    if (!config.pool) {
+        return createConnection(config);
+    }
+    try {
+        return await getPool(config).acquire();
+    } catch (err) {
+        throw error('HazelcastPoolAcquireError', { connectionName: config.connectionName }, err);
+    }
+}
+
+function createConnection(config) {
+    let hz = null;
+    const lifecycleListener = (state) => {
+        if (state === 'DISCONNECTED') {
+            hz.active = false;
+        }
+    };
+
+    config.connectionOptions.lifecycleListeners = [lifecycleListener];
+
+    return Client.newHazelcastClient(config.connectionOptions)
+        .then((hazelcastClient) => {
+            hazelcastClient.pool = config.pool;
+            hazelcastClient.connectionName = config.connectionName;
+            hazelcastClient.active = true;
+            hz = hazelcastClient;
+            return hz;
+        })
+        .catch((err) => {
+            throw error('HazelcastConnectionError', { connectionName: config.connectionName }, err);
+        });
+}
+
+async function send(config, name, type, command, ...args) {
+    let connection = null;
+    try {
+        connection = await getConnection(config);
+        return await executeCommand(connection, name, type, command, ...args);
+    } catch (err) {
+        throw error('HazelcastError', null, err);
+    } finally {
+        if (connection) {
+            closeConnection(connection);
+        }
+    }
+}
+
+async function executeCommand(connection, name, type, command, ...args) {
+    const cache = await getCache(connection, name, type);
+    return cache[command](...args);
+}
+
+function getCache(connection, name, type) {
+    let cache = null;
+    switch (type) {
+        case CACHE_TYPE.MAP:
+            cache = connection.getMap(name);
+            break;
+        case CACHE_TYPE.LIST:
+            cache = connection.getList(name);
+            break;
+    }
+    return cache;
+}
+
+function closeConnection(connection) {
+    if (!connection.pool) {
+        return destroyConnection(connection);
+    } else {
+        return getPool({connectionName: connection.connectionName}).release(connection);
+    }
+}
+
+function destroyConnection(connection) {
+    connection.shutdown();
+    connection.active = false;
+    return Promise.resolve();
+}
+
+function getPool(config) {
+    let key = config.connectionName;
+    let pool = poolsByName[key];
+    if (pool) {
+        return pool;
+    }
+    else {
+        // Create pool using a factory object
+        const factory = {
+            create: async function() {
+                try {
+                    const connection = await createConnection(config);
+                    return connection;
+                } catch (err) {
+                    return await new Promise(function (resolve, reject) {
+                        setTimeout(() => {
+                            reject(err);
+                        }, config.poolRetryDelay);
+                    });
+                }
+            },
+            destroy: function(connection) {
+                return destroyConnection(connection);
+            },
+            validate: function(connection) {
+                return Promise.resolve(connection.active);
+            }
+        };
+
+        const opts = {
+            max: config.poolMax,
+            min: config.poolMin,
+            testOnBorrow: true,
+            acquireTimeoutMillis: config.poolAcquireTimeout || 10000
+            //autostart: false
+        };
+
+        pool = genericPool.createPool(factory, opts);
+        //pool.start();
+        pool.connectionName = config.connectionName;
+        poolsByName[key] = pool;
+        return pool;
+    }
+}
+
+function error(code, data, innerError) {
+    let err = new Error();
+    err.code = code;
+    if (data)
+        err.data = data;
+    if (innerError)
+        err.innerError = innerError;
+    return err;
+}
+
+module.exports = {
+    createHazelcastClient: createHazelcastClient
+}

package/blz-iterable/index.js

@@ -0,0 +1,446 @@
+module.exports = {
+    errorUndefinedArgument: function( argName ) {
+        const err = new Error();
+        err.code = 'UndefinedArgument';
+        err.data = { argName: argName };
+        return err;
+    },
+    compare: function( value1, value2 ) { // TODO: Sort require for objects
+        if( value1 === null && value2 === null ) return 0;
+        if( value1 === null && value2 !== null ) return -1;
+        if( value1 !== null && value2 === null ) return 1;
+
+        const value1Type = toString.call( value1 );
+        const value2Type = toString.call( value2 );
+        let value1ToCompare = null;
+        let value2ToCompare = null;
+        if ((value1Type === '[object String]' && value2Type === '[object String]') ||
+            (value1Type === '[object Number]' && value2Type === '[object Number]')) {
+            value1ToCompare = value1;
+            value2ToCompare = value2;
+        }
+        else if( value1Type === '[object Boolean]' && value2Type === '[object Boolean]' ) {
+            value1ToCompare = value1 ? 1 : 0;
+            value2ToCompare = value2 ? 1 : 0;
+        }
+        else if( value1Type === '[object Date]' && value2Type === '[object Date]' ) {
+            value1ToCompare = value1.getTime();
+            value2ToCompare = value2.getTime();
+        }
+        else if( value1Type === '[object Object]' && value2Type === '[object Object]' ) {
+            value1ToCompare = JSON.stringify( value1 );
+            value2ToCompare = JSON.stringify( value2 );
+        }
+        else if( value1Type === '[object Array]' && value2Type === '[object Array]' ) {
+            let result = this.compare( value1.length, value2.length );
+            if( result !== 0 )
+                return result;
+            for( let i = 0; i < value1.length; ++i ) {
+                const item1 = value1[ i ];
+                const item2 = value2[ i ];
+                result = this.compare( item1, item2 );
+                if( result !== 0 )
+                    return result;
+            }
+            return 0;
+        }
+        else {
+            const getValueToCompare = ( valueType, value ) => {
+                switch( valueType ) {
+                    case '[object String]'  : return value
+                    case '[object Number]'  : return value.toString()
+                    case '[object Boolean]' : return value ? '1' : '0'
+                    case '[object Date]'    : return value.toJSON()
+                    default                 : return value.toString()
+                }
+
+            }
+
+            value1ToCompare = getValueToCompare( value1Type, value1 )
+            value2ToCompare = getValueToCompare( value2Type, value2 )
+        }
+
+        if( value1ToCompare === value2ToCompare ) return 0;
+        else if( value1ToCompare < value2ToCompare ) return -1;
+        else if( value1ToCompare > value2ToCompare ) return 1;
+        else return null;
+
+    },
+    all: function( list, fnCondition ) {
+        if( list === null ) return false;
+
+        for( let i = 0; i < list.length; ++i ) {
+            const item = list[ i ];
+            if( !(fnCondition( item )) )
+                return false;
+        }
+        return true;
+    },
+    any: function( list, fnCondition ) {
+        if( list === null ) return false;
+
+        for( let i = 0; i < list.length; ++i ) {
+            const item = list[ i ];
+            if( fnCondition( item ) )
+                return true;
+        }
+        return false;
+    },
+    avg: function( list, fnSelection ) {
+        if( list === null ) return null;
+
+        let totalSum = 0;
+        let totalCount = 0;
+        if( fnSelection ) {
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                const value = fnSelection( item );
+                if( value !== null ) {
+                    totalSum += value;
+                    totalCount++;
+                }
+            }
+        }
+        else {
+            for( let i = 0; i < list.length; ++i ) {
+                const value = list[ i ];
+                if( value !== null ) {
+                    totalSum += value;
+                    totalCount++;
+                }
+            }
+        }
+        return totalSum / totalCount;
+    },
+    concatList: function() {
+        if( arguments.length === 0 ) return null
+        if( arguments.length === 1 && arguments[ 0 ] === null ) return null
+        return Array.from( arguments ).filter( list => list !== null ).flat()
+    },
+    count: function( list ) {
+        if( list === null ) return null;
+        return list.length;
+    },
+    distinct: function( list, fnSelection ) {
+        if( list === null ) return null;
+
+        const resultArray = [];
+        if( fnSelection ) {
+            const keys = [];
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                const key = fnSelection( item );
+                if( keys.indexOf( key ) === -1 ) {
+                    keys.push( key );
+                    resultArray.push( item );
+                }
+            }
+        }
+        else {
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                if( resultArray.indexOf( item ) === -1 )
+                    resultArray.push( item );
+            }
+        }
+        return resultArray;
+    },
+    elementAt: function( list, index ) {
+        if( list === null ) return null
+
+        const result = list[ index ]
+        return result === undefined ? null : result
+    },
+    getSelections: function( list, fnSelection ) {
+        if( !fnSelection ) return list
+
+        const selections = new Array( list.length )
+        for( let i = 0; i < list.length; ++i ) {
+            selections[ i ] = fnSelection( list[ i ] )
+        }
+        return selections
+    },
+    except: function( listA, listB, fnSelection ) {
+        if( listA === null ) return null
+        if( listB === null ) return listA.slice()
+
+        const selectionsA = this.getSelections( listA, fnSelection )
+        const selectionsB = this.getSelections( listB, fnSelection )
+
+        const resultArray = [];
+        for( let i = 0; i < listA.length; ++i ) {
+            let except = false
+            for( let j = 0; j < listB.length; ++j ) {
+                if( this.compare( selectionsA[ i ], selectionsB[ j ] ) === 0 ) {
+                    except = true
+                    break
+                }
+            }
+            if( !except ) resultArray.push( listA[ i ] )
+        }
+        return resultArray;
+    },
+    findAll: function( list, fnCondition ) {
+        if( list === null ) return null;
+
+        const resultArray = [];
+        for( let i = 0; i < list.length; ++i ) {
+            const item = list[ i ];
+            if( fnCondition( item ) )
+                resultArray.push( item );
+        }
+        return resultArray;
+    },
+    findFirstInternal: function( list, fnCondition ) {
+        if( list === null ) return null
+
+        for( let i = 0; i < list.length; ++i ) {
+            const item = list[ i ]
+            if( fnCondition( item ) )
+                return { item, index: i }
+        }
+
+        return { item: null, index: -1 }
+    },
+    findFirst: function( list, fnCondition ) {
+        const result = this.findFirstInternal( list, fnCondition )
+        return result === null ? null : result.item
+    },
+    findIndex: function( list, fnCondition ) {
+        const result = this.findFirstInternal( list, fnCondition )
+        return result === null ? null : result.index
+    },
+    findLastInternal: function( list, fnCondition ) {
+        if( list === null ) return null
+
+        for( let i = ( list.length - 1 ); i > -1; i-- ) {
+            const item = list[ i ]
+            if( fnCondition( item ) )
+                return { item, index: i }
+        }
+        return { item: null, index: -1 }
+    },
+    findLast: function( list, fnCondition ) {
+        const result = this.findLastInternal( list, fnCondition )
+        return result === null ? null : result.item
+    },
+    findLastIndex: function( list, fnCondition ) {
+        const result = this.findLastInternal( list, fnCondition )
+        return result === null ? null : result.index
+    },
+    first: function( list ) {
+        if( list === null ) return null;
+        return list.length > 0 ? list[ 0 ] : null;
+    },
+    flat: function( list, depth ) {
+        if( list === null ) return null
+        return list.flat( depth )
+    },
+    includes: function( list, searchElement, fromIndex ) {
+        if( list === null ) return false
+        return list.includes( searchElement, fromIndex )
+    },
+    insertAt: function( list, index, elements ) {
+        if( list === null ) return null
+        if( elements === null ) return list.slice()
+        const copiedList = list.slice()
+        copiedList.splice( index, 0, ...elements )
+        return copiedList
+    },
+    intersect: function( listA, listB, fnSelection ) {
+        if( listA === null ) return null;
+        if( listB === null ) return null;
+
+        const selectionsA = this.getSelections( listA, fnSelection )
+        const selectionsB = this.getSelections( listB, fnSelection )
+
+        const resultArray = [];
+        for( let i = 0; i < listA.length; ++i ) {
+            let include = false;
+            for( let j = 0; j < listB.length; j++ ) {
+                if( this.compare( selectionsA[ i ], selectionsB[ j ] ) === 0 )
+                    include = true;
+            }
+            if( include )
+                resultArray.push( listA[ i ] );
+        }
+        return resultArray;
+    },
+    last: function( list ) {
+        if( list === null ) return null;
+        return list.length > 0 ? list[ list.length - 1 ] : null;
+    },
+    max: function( list, fnSelection ) {
+        if( list === null ) return null;
+
+        let max = null;
+        if( fnSelection ) {
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                const value = fnSelection( item );
+                if( max === null || this.compare( value, max ) > 0 )
+                    max = value;
+            }
+        }
+        else {
+            for( let i = 0; i < list.length; ++i ) {
+                const value = list[ i ];
+                if( max === null || this.compare( value, max ) > 0 )
+                    max = value;
+            }
+        }
+        return max;
+    },
+    min: function( list, fnSelection ) {
+        if( list === null ) return null;
+
+        let min = null;
+        if( fnSelection ) {
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                const value = fnSelection( item );
+                if( min === null || this.compare( value, min ) < 0 )
+                    min = value;
+            }
+        }
+        else {
+            for( let i = 0; i < list.length; ++i ) {
+                const value = list[ i ];
+                if( min === null || this.compare( value, min ) < 0 )
+                    min = value;
+            }
+        }
+        return min;
+    },
+    removeAt: function( list, index, deleteCount ) {
+        if( list === null ) return null
+        const copiedList = list.slice()
+        copiedList.splice( index, deleteCount )
+        return copiedList
+    },
+    reverse: function( list ) {
+        if( list === null ) return null
+        return list.slice().reverse()
+    },
+    skip: function( list, count ) {
+        if( list === null ) return null
+        return list.slice( count )
+    },
+    skipWhile: function( list, fnCondition ) {
+        if( list === null ) return null
+
+        for( let i = 0; i < list.length; ++i ) {
+            if( !fnCondition( list[ i ] ) ) {
+                return list.slice( i )
+            }
+        }
+        return []
+    },
+    slice: function( list, start, end ) {
+        if( list === null ) return null
+        return list.slice( start, end )
+    },
+    sortInternal: function( { list, fnSelection, compareFunctionWithFnSelection, compareFunction } ) {
+
+        if( list === null ) return null
+
+        if( !fnSelection ) return list.slice().sort( compareFunction )
+
+        const unsorted = new Array( list.length )
+        for( let i = 0; i < list.length; ++i ) {
+            unsorted[ i ] = { index: i, compareValue: fnSelection( list[ i ] ) }
+        }
+
+        const sorted = unsorted.sort( compareFunctionWithFnSelection );
+
+        const resultArray = new Array( sorted.length )
+        for( let i = 0; i < sorted.length; ++i ) {
+            resultArray[ i ] = list[ sorted[ i ].index ]
+        }
+
+        return resultArray;
+    },
+    sort: function( list, fnSelection ) {
+        return this.sortInternal( {
+            list,
+            fnSelection,
+            compareFunctionWithFnSelection: function( a, b ) { return this.compare( a.compareValue, b.compareValue ) }.bind( this ),
+            compareFunction: function( a, b ) { return this.compare( a, b ) }.bind( this )
+        } )
+    },
+    sortDescending: function( list, fnSelection ) {
+        return this.sortInternal( {
+            list,
+            fnSelection,
+            compareFunctionWithFnSelection: function( a, b ) { return this.compare( b.compareValue, a.compareValue ); }.bind( this ),
+            compareFunction: function( a, b ) { return this.compare( b, a ); }.bind( this )
+        } )
+    },
+    sum: function( list, fnSelection ) {
+        if( list === null ) return null;
+        let sum = 0;
+        if( fnSelection ) {
+            for( let i = 0; i < list.length; ++i ) {
+                const item = list[ i ];
+                const value = fnSelection( item );
+                if( value !== null )
+                    sum += value;
+            }
+        }
+        else {
+            for( let i = 0; i < list.length; ++i ) {
+                const value = list[ i ];
+                if( value !== null )
+                    sum += value;
+            }
+        }
+        return sum;
+    },
+    take: function( list, count ) {
+        if( list === null ) return null
+        return list.slice( 0, count )
+    },
+    takeWhile: function( list, fnCondition ) {
+        if( list === null ) return null;
+
+        let i;
+        for( i = 0; i < list.length; ++i ) {
+            if( !fnCondition( list[ i ] ) ) {
+                break
+            }
+        }
+        return list.slice( 0, i );
+    },
+    union: function( listA, listB, fnSelection ) {
+        if( listA === null && listB === null ) return null
+        if( listA === null ) return listB.slice()
+        if( listB === null ) return listA.slice()
+
+        if( !fnSelection ) {
+            return [ ...new Set( listA.concat( listB ) ) ]
+        }
+
+        const resultArray = []
+        const keys = []
+
+        for( let i = 0; i < listA.length; ++i ) {
+            const item = listA[ i ]
+            const key = fnSelection( item )
+            if( keys.indexOf( key ) === -1 ) {
+                keys.push( key )
+                resultArray.push( item )
+            }
+        }
+
+        for( let i = 0; i < listB.length; ++i ) {
+            const item = listB[ i ]
+            const key = fnSelection( item )
+            if( keys.indexOf( key ) === -1 ) {
+                keys.push( key )
+                resultArray.push( item )
+            }
+        }
+
+        return resultArray;
+    }
+};

package/blz-json-schema/index.js

@@ -0,0 +1,11 @@
+const validate = require('jsonschema').validate;
+
+module.exports = {
+    jsonSchemaValidate: function (data, schema) {
+        if (schema === undefined || schema === null)
+            throw new Error('schema undefined')
+        let result = validate(data, schema)
+        result.valid = (result.errors.length === 0)
+        return result   
+    }
+};