@blazedpath/commons 0.0.4

package/blz-file/fileService.js

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

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

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

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

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

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

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