@blazedpath/commons 0.2.2 → 0.3.1

package/blz-file/fileService.js

@@ -1,205 +0,0 @@
-const fs = require('fs');
-const path =  require('path')
-const readline = require('readline');
-class FileService {
-
-  join(paths) {
-    if (!paths) {
-      throw new Error("paths is required");
-    }
-    return path.join(...paths)
-  }
-
-  async append(filePath,content) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    if (!content) {
-      throw new Error("content is required");
-    }
-    const fullPath = this.resolvePath(filePath) 
-    await this.createDirIfNotExists(fullPath)
-    await fs.promises.appendFile(fullPath, content);
-  }
-
-  async read(filePath) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    const fullPath = this.resolvePath(filePath)    
-    return fs.promises.readFile(fullPath, "utf-8");
-  }
-
-  async appendLines(filePath, lines, start) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    if (!lines) {
-      throw new Error("lines is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    await this.createDirIfNotExists(fullPath)
-    if (start !== undefined && start !== null) {
-      const currentContent = await fs.promises.readFile(fullPath, "utf-8");
-      const currentLines = currentContent.split('\n');
-      currentLines.splice(start, 0, ...lines);      
-      await fs.promises.writeFile(fullPath, currentLines.join('\n')+'\n');
-    } else {
-      await fs.promises.appendFile(fullPath, lines.join('\n')+'\n');        
-    }
-  }
-
-  async readLines(filePath, start, count) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    let lines = []
-    if (start !== undefined && start !== null) {
-      lines = await this._read(fullPath, start, count );
-    } else {
-      lines = (await fs.promises.readFile(fullPath, "utf-8")).split('\n')
-    }
-    return lines.filter(l => l === undefined || l === null || l.trim() !== '')
-  }
-
-  createLineIterable(filePath) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    const fileStream = fs.createReadStream(fullPath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity,
-    });
-
-    return {
-      [Symbol.iterator]() {
-        return {
-          next() {
-            const line = rl[Symbol.iterator]().next().value;
-            return { value: line, done: line === undefined };
-          },
-        };
-      },
-    };
-  }
-
-  async remove(filePath) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    await fs.promises.unlink(fullPath);
-  }
-
-  async exists(sourcePath) {
-    if (!sourcePath) {
-      throw new Error("sourcePath is required");
-    }
-    try {
-      await fs.promises.access(sourcePath);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      } else {
-        throw error;
-      }
-    }
-  }
- 
-  async lines(filePath) {
-    if (!filePath) {
-      throw new Error("path is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    return this._lines(fullPath);
-  }
-  async size(filePath) {
-    if (!filePath) {
-      throw new Error("filePath is required");
-    }
-    const fullPath = this.resolvePath(filePath)
-    const statistics = await fs.promises.stat(fullPath)
-    return statistics.size
-  }
-
-  async _read(filePath, start, count) {
-    return new Promise((resolve, reject) => {
-      const reader = readline.createInterface({
-        input: fs.createReadStream(filePath),
-        crlfDelay: Infinity,
-      });
-
-      let lines = [];
-      let lineCount = 0;
-
-      reader.on("line", (line) => {
-        if (lineCount >= start && (!count || lines.length < count)) {
-          lines.push(line);
-        }
-        lineCount++;
-      });
-
-      reader.on("close", () => {
-        resolve(lines);
-      });
-
-      reader.on("error", (error) => {
-        reject(error);
-      });
-    });
-  }
-
- 
-
-
-
-  async _lines(filePath) {
-    return new Promise((resolve, reject) => {
-        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-        let lineCount = 0;
-    
-        stream.on('data', (chunk) => {
-          lineCount += (chunk.match(/\n/g) || []).length;
-        });
-    
-        stream.on('end', () => {
-          resolve(lineCount + 1)
-        });
-    
-        stream.on('error', (error) => {
-          reject(error);
-        });
-      });
-  }
-
-  async createDirIfNotExists (sourcePath) {
-		const fullPath = this.resolvePath(sourcePath)
-    const dirPath = path.dirname(fullPath);
-    const exists = await this.exists(dirPath)
-		if (exists) { return }
-		return new Promise((resolve, reject) => {
-			fs.mkdir(dirPath, { recursive: true }, err => err ? reject(err) : resolve())
-		})
-	}
-
-  resolvePath (sourcePath) {
-    if (!sourcePath) {
-      throw new Error("sourcePath is required");
-    }
-		const _source = sourcePath.trim()
-		if (_source.startsWith('.')) {
-			return path.join(process.cwd(), sourcePath)
-		}
-		if (_source.startsWith('~')) {
-			return _source.replace('~', process.env.HOME)
-		}
-		return sourcePath
-	}
-}
-const fileService = new FileService()
-exports = module.exports =  fileService
-exports.default = fileService

package/blz-file/index.js

@@ -1,94 +0,0 @@
-const fileService = require('./fileService.js')
-const path =  require('path')
-module.exports = typeof module.exports === "undefined" ? {} : module.exports;
-
-/**
- * Join parts of path
- * @param {list(string)} paths - parts of path
- * @return {string} - Path joined
- */
-module.exports.pathJoin = async function( paths ) {
-    if (!paths) {
-        throw new Error("paths is required");
-    }
-    return path.join(...paths)
-}
-
-/**
- * Append data to File
- * @param {string} path - path of file
- * @param {string} content - content of file
- * @return {any}
- */
-module.exports.fileAppend = async function( path, content ) {
-    await fileService.append(path,content)
-}
-/**
- * Read file request
- * @param {string} path - Path of file
- * @return {FileReadResponse}
- */
-module.exports.fileRead = async function( path ) {
-    return fileService.read(path)
-}
-
-/**
- * Append lines to file
- * @param {string} path - Path of file
- * @param {list(string)} lines - lines to append
- * @param {integer} [start] - position to start append
- * @return {any}
- */
-module.exports.fileAppendLines = async function( path, lines, start ) {
-    await fileService.appendLines(path,lines, start)
-}
-/**
- * Read lines form file
- * @param {string} path - Path of file
- * @param {integer} [start] - Start position to read
- * @param {integer} [count] - Count lines to read
- * @return {any}
- */
-module.exports.fileReadLines = async function( path, start, count ) {
-    return fileService.readLines(path,start, count)
-}
-
-/**
- * Create iterable to read lines from file
- * @param {string} path - Path of file
- * @return {any}
- */
-module.exports.fileCreateLineIterable = async function( path ) {
-    return fileService.createLineIterable(path)
-}
-
-
-/**
- * File exists
- * @param {string} path - path of file
- * @return {boolean}
- */
-module.exports.fileExists = async function( path ) {
-    return fileService.exists(path)
-}
-/**
- * Lines of file
- * @param {string} path - path of file
- * @return {integer}
- */
-module.exports.fileLines = async function( path ) {
-    return fileService.lines(path)
-}
-/**
- * File Size
- * @param {string} path - path of file
- * @return {integer}
- */
-module.exports.fileSize = async function( path ) {
-    return fileService.size(path)
-}
-
-module.exports.fileRemove = async function( path ) {
-    return fileService.remove(path)
-}
-

package/blz-file/index.test.js

@@ -1,31 +0,0 @@
-const app = require('./index')
-const path = require('path')
-const examplePath = path.join(__dirname, 'example.dat')
-const { v4: uuidv4 } = require('uuid');
-
-describe("FileService", () => {
-  test('Size',async() => {
-    const result = await app.fileSize(examplePath)
-    expect(2841450).toStrictEqual(result)
-  })
-  test('Lines',async () => {
-    const result = await app.fileLines(examplePath)
-    expect(2546).toStrictEqual(result)
-  })
-  test('Read and append lines',async () => {    
-    const content= await app.fileRead(examplePath)
-    const targetFilePath = path.join(__dirname, 'example_'+uuidv4()+'.dat')
-    await app.fileAppend(targetFilePath,content)
-    const chunk1 = await app.fileReadLines(examplePath,0,2)
-    const chunk2 = await app.fileReadLines(examplePath,2,1)
-    const targetFile2Path = path.join(__dirname, 'example2_'+uuidv4()+'.dat')
-    await app.fileAppendLines(targetFile2Path,chunk2) 
-    await app.fileAppendLines(targetFile2Path,chunk1,0) 
-    const chunk3 = JSON.stringify(await app.fileReadLines(examplePath,0,3))
-    const content2 = JSON.stringify(await app.fileReadLines(targetFile2Path))
-    await app.fileRemove(targetFilePath)
-    await app.fileRemove(targetFile2Path)
-    expect(true).toStrictEqual(chunk3 === content2)
-  })  
-})
-

package/blz-file/lab.js

@@ -1,33 +0,0 @@
-const fileService = require('./fileService.js')
-const { v4: uuidv4 } = require('uuid');
-const path = require('path')
-
-const lab = async () => {
-    const pathFile = path.join(__dirname, 'example.dat')
-    console.log('size: ' + await fileService.size(pathFile))
-    console.log('lines: ' + await fileService.lines(pathFile))
-
-   const content= await fileService.read(pathFile)
-   const targetFilePath = path.join(__dirname, 'example_'+uuidv4()+'.dat')
-   await fileService.append(targetFilePath,content)
-
-   const chunk1 = await fileService.readLines(pathFile,0,2)
-   const chunk2 = await fileService.readLines(pathFile,2,1)
-   const targetFile2Path = path.join(__dirname, 'example2_'+uuidv4()+'.dat')
-   await fileService.appendLines(targetFile2Path,chunk2) 
-   await fileService.appendLines(targetFile2Path,chunk1,0) 
-
-   const chunk3 = JSON.stringify(await fileService.readLines(pathFile,0,3))
-   const content2 = JSON.stringify(await fileService.readLines(targetFile2Path))
-   if (chunk3 === content2) {
-       console.log('content is equal')
-   }
-    else {
-         console.log('content is not equal')
-    }
-
-    await fileService.remove(targetFilePath)
-    await fileService.remove(targetFile2Path)
-}
-
-lab()

package/blz-hazelcast/index.js

@@ -1,189 +0,0 @@
-const hazelcastCache = require('./lib/hazelcastCache.js');
-const { UsernamePasswordCredentials } = require('./lib/credentials.js');
-const { usernamePasswordCredentialsFactory } = require('./lib/credentialsFactory.js');
-const fs = require('fs-extra');
-
-// Hazelcast Client cache
-let hazelcastClients = {};
-
-// Gets a Hazelcast Client by connection name
-function getOrCreateHazelcastClient(connection) {
-    let hazelcastClient = hazelcastClients[connection.name];
-    if (hazelcastClient) {
-        return hazelcastClient;
-    }
-
-    let options = {
-        connectionName: connection.name,
-        connectionOptions: {
-            properties: {
-                'hazelcast.logging.level': 'OFF',
-                'hazelcast.client.heartbeat.interval': connection.poolKeepAlive || 10000
-            }
-        },
-        pool: true,
-        poolMin: connection.poolMin,
-        poolMax: connection.poolMax,
-        poolKeepAlive: connection.poolKeepAlive,
-        poolAcquireTimeout: connection.poolAcquireTimeout,
-        poolRetryDelay: connection.poolRetryDelay
-    };
-    if (connection.clusterName != null) {
-        options.connectionOptions.clusterName = connection.clusterName;
-    }
-    if (connection.members != null || connection.discoveryToken != null || connection.tls) {
-        options.connectionOptions.network = {};
-    }
-    if (connection.members != null) {
-        options.connectionOptions.network.clusterMembers = ensureMembers(connection.members);
-    }
-    if (connection.discoveryToken != null) {
-        options.connectionOptions.network.hazelcastCloud = { discoveryToken: connection.discoveryToken };
-    }
-    if (connection.tls) {
-        options.connectionOptions.network.ssl = { enabled: true };
-        if (connection.key || connection.cert || connection.ca || connection.servername || connection.rejectUnauthorized) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties = {};
-        }
-        if (connection.key) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties.keyPath = fs.readFileSync(connection.key);
-        }
-        if (connection.cert) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties.certPath = fs.readFileSync(connection.cert);
-        }
-        if (connection.ca) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties.caPath = fs.readFileSync(connection.ca);
-        }
-        if (connection.servername) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties.servername = connection.servername;
-        }
-        if (!connection.rejectUnauthorized) {
-            options.connectionOptions.network.ssl.sslOptionsFactoryProperties.rejectUnauthorized = false;
-        }
-    }
-    if (connection.user != null) {
-        options.connectionOptions.serialization = {
-            portableFactories: {
-                1: usernamePasswordCredentialsFactory
-            }
-        },
-        options.connectionOptions.customCredentials = new UsernamePasswordCredentials(connection.user, connection.password, connection.endpoint);
-    }
-    hazelcastClient = hazelcastCache.createHazelcastClient(options);
-    hazelcastClients[connection.name] = hazelcastClient;
-    return hazelcastClient;
-}
-
-function ensureMembers(members) {
-    if (members) {
-        if (!Array.isArray(members)) {
-            if (typeof (members) === 'string') {
-                return members.split(',')
-            }
-        }
-    }
-    return members;
-}
-
-module.exports = {
-    hazelcastMapGet: function (connection, name, key) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapGet(name, key);
-    },
-    hazelcastMapGetAll:function (connection, name, keys) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapGetAll(name, keys);
-    },
-    hazelcastMapSet: function (connection, name, key, value, ttl) {
-        let hazelcastClient =  getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapSet(name, key, value, ttl);
-    },
-    hazelcastMapSetAll: function (connection, name, data) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapSetAll(name, data);
-    },
-    hazelcastMapDelete: function (connection, name, key) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapDelete(name, key);
-    },
-    hazelcastMapSetTtl: function (connection, name, key, ttl) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapSetTtl(name, key, ttl);
-    },
-    hazelcastMapGetEntryView: function (connection, name, key) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapGetEntryView(name, key);
-    },
-    hazelcastMapContainsKey: function (connection, name, key) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapContainsKey(name, key);
-    },
-    hazelcastMapKeySet: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapKeySet(name);
-    },
-    hazelcastMapValues: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapValues(name);
-    },
-    hazelcastMapEntrySet: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapEntrySet(name);
-    },
-    hazelcastMapSize: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapSize(name);
-    },
-    hazelcastMapClear: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapClear(name);
-    },
-    hazelcastMapDestroy: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.mapDestroy(name);
-    },
-    hazelcastListGet: function (connection, name, index) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listGet(name, index);
-    },
-    hazelcastListAdd: function (connection, name, element) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listAdd(name, element);
-    },
-    hazelcastListAddAt: function (connection, name, index, element) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listAddAt(name, index, element);
-    },
-    hazelcastListAddAll: function (connection, name, elements) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listAddAll(name, elements);
-    },
-    hazelcastListRemove: function (connection, name, element) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listRemove(name, element);
-    },
-    hazelcastListRemoveAt: function (connection, name, index) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listRemoveAt(name, index);
-    },
-    hazelcastListContains: function (connection, name, element) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listContains(name, element);
-    },
-    hazelcastListIndexOf: function (connection, name, element) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listIndexOf(name, element);
-    },
-    hazelcastListSize: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listSize(name);
-    },
-    hazelcastListClear: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listClear(name);
-    },
-    hazelcastListDestroy: function (connection, name) {
-        let hazelcastClient = getOrCreateHazelcastClient(connection);
-        return hazelcastClient.listDestroy(name);
-    }
-};

package/blz-hazelcast/lib/credentials.js

@@ -1,25 +0,0 @@
-'use strict';
-
-class UsernamePasswordCredentials {
-    constructor(username, password, endpoint) {
-        this.username = username;
-        this.password = password;
-        this.endpoint = endpoint;
-        this.factoryId = 1;
-        this.classId = 1;
-    }
-
-    readPortable(reader) {
-        this.username = reader.readString('username');
-        this.endpoint = reader.readString('password');
-        this.password = reader.readString('endpoint');
-    }
-
-    writePortable(writer) {
-        writer.writeString('username', this.username);
-        writer.writeString('password', this.password);
-        writer.writeString('endpoint', this.endpoint);
-    }
-}
-
-exports.UsernamePasswordCredentials = UsernamePasswordCredentials;

package/blz-hazelcast/lib/credentialsFactory.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const UsernamePasswordCredentials = require('./credentials');
-
-function usernamePasswordCredentialsFactory(classId) {
-    if (classId === 1) {
-        return new UsernamePasswordCredentials();
-    }
-    return null;
-}
-
-exports.usernamePasswordCredentialsFactory = usernamePasswordCredentialsFactory;