@blazedpath/commons 0.2.2 → 0.3.1

package/blz-hazelcast/lib/hazelcastCache.js

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

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

@@ -1,11 +0,0 @@
-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   
-    }
-};