corebasic 1.0.0

package/index.js

@@ -0,0 +1,2 @@
+ 
+module.exports = require('./libs/app');

package/libs/ObjectId.js

@@ -0,0 +1,127 @@
+/*
+*
+* Copyright (c) 2011-2014- Justin Dearing (zippy1981@gmail.com)
+* Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+* and GPL (http://www.opensource.org/licenses/gpl-license.php) version 2 licenses.
+* This software is not distributed under version 3 or later of the GPL.
+*
+* Version 1.0.2
+*
+*/
+
+
+
+if (!document) var document = { cookie: '' }; // fix crashes on node
+
+/**
+ * Javascript class that mimics how WCF serializes a object of type MongoDB.Bson.ObjectId
+ * and converts between that format and the standard 24 character representation.
+*/
+var ObjectId = (function () {
+    var increment = Math.floor(Math.random() * (16777216));
+    var pid = Math.floor(Math.random() * (65536));
+    var machine = Math.floor(Math.random() * (16777216));
+
+    var setMachineCookie = function() {
+        var cookieList = document.cookie.split('; ');
+        for (var i in cookieList) {
+            var cookie = cookieList[i].split('=');
+            var cookieMachineId = parseInt(cookie[1], 10);
+            if (cookie[0] == 'mongoMachineId' && cookieMachineId && cookieMachineId >= 0 && cookieMachineId <= 16777215) {
+                machine = cookieMachineId;
+                break;
+            }
+        }
+        document.cookie = 'mongoMachineId=' + machine + ';expires=Tue, 19 Jan 2038 05:00:00 GMT;path=/';
+    };
+    if (typeof (localStorage) != 'undefined') {
+        try {
+            var mongoMachineId = parseInt(localStorage['mongoMachineId']);
+            if (mongoMachineId >= 0 && mongoMachineId <= 16777215) {
+                machine = Math.floor(localStorage['mongoMachineId']);
+            }
+            // Just always stick the value in.
+            localStorage['mongoMachineId'] = machine;
+        } catch (e) {
+            setMachineCookie();
+        }
+    }
+    else {
+        setMachineCookie();
+    }
+
+    function ObjId() {
+        if (!(this instanceof ObjectId)) {
+            return new ObjectId(arguments[0], arguments[1], arguments[2], arguments[3]).toString();
+        }
+
+        if (typeof (arguments[0]) == 'object') {
+            this.timestamp = arguments[0].timestamp;
+            this.machine = arguments[0].machine;
+            this.pid = arguments[0].pid;
+            this.increment = arguments[0].increment;
+        }
+        else if (typeof (arguments[0]) == 'string' && arguments[0].length == 24) {
+            this.timestamp = Number('0x' + arguments[0].substr(0, 8)),
+            this.machine = Number('0x' + arguments[0].substr(8, 6)),
+            this.pid = Number('0x' + arguments[0].substr(14, 4)),
+            this.increment = Number('0x' + arguments[0].substr(18, 6))
+        }
+        else if (arguments.length == 4 && arguments[0] != null) {
+            this.timestamp = arguments[0];
+            this.machine = arguments[1];
+            this.pid = arguments[2];
+            this.increment = arguments[3];
+        }
+        else {
+            this.timestamp = Math.floor(new Date().valueOf() / 1000);
+            this.machine = machine;
+            this.pid = pid;
+            this.increment = increment++;
+            if (increment > 0xffffff) {
+                increment = 0;
+            }
+        }
+    };
+    return ObjId;
+})();
+
+ObjectId.prototype.getDate = function () {
+    return new Date(this.timestamp * 1000);
+};
+
+ObjectId.prototype.toArray = function () {
+    var strOid = this.toString();
+    var array = [];
+    var i;
+    for(i = 0; i < 12; i++) {
+        array[i] = parseInt(strOid.slice(i*2, i*2+2), 16);
+    }
+    return array;
+};
+
+/**
+* Turns a WCF representation of a BSON ObjectId into a 24 character string representation.
+*/
+ObjectId.prototype.toString = function () {
+    if (this.timestamp === undefined
+        || this.machine === undefined
+        || this.pid === undefined
+        || this.increment === undefined) {
+        return 'Invalid ObjectId';
+    }
+
+    var timestamp = this.timestamp.toString(16);
+    var machine = this.machine.toString(16);
+    var pid = this.pid.toString(16);
+    var increment = this.increment.toString(16);
+    return '00000000'.substr(0, 8 - timestamp.length) + timestamp +
+           '000000'.substr(0, 6 - machine.length) + machine +
+           '0000'.substr(0, 4 - pid.length) + pid +
+           '000000'.substr(0, 6 - increment.length) + increment;
+};
+
+
+module.exports = {
+    ObjectId,
+}

package/libs/app.js

@@ -0,0 +1,11 @@
+
+
+let Elabase = require('./elabase')
+let Kafka = require('./kafka')
+let Utils = require('./utils')
+
+module.exports = {
+    Elabase,
+    Kafka,
+    Utils
+}

package/libs/elabase.js

@@ -0,0 +1,174 @@
+const axios = require('axios')
+
+
+module.exports = {
+    start,
+    insert,
+    update,
+    query,
+    remove
+}
+
+
+
+
+
+
+
+
+
+
+
+
+let Utils = {
+      isEmpty: function(arg) { return arg === "" || arg == undefined || !arg ? true : false },
+      requisites: { startElabase: function () { } }
+}
+
+let Events = {
+    send: function() { }
+}
+
+
+
+
+let url = "http://127.0.0.1"
+let port = 9401
+let api = 'execute'
+let fullurl = `${url}:${port}/${api}`
+
+
+let Elabase = {
+    Engine: {
+        Lmdb: 1,
+        Sled: 2,
+        Sanakirja: 3,
+    }
+}
+
+let engine = Elabase.Engine.Lmdb
+let internal = { 
+    db: undefined, 
+    engineName: engine === Elabase.Engine.Lmdb ? "lmdb" : (engine === Elabase.Engine.Sled ? "sled" : engine === Elabase.Engine.Sanakirja ? "sanakirja" : "lmdb")
+}
+
+let db = internal.db // default database
+
+function start(dbName) {
+    if (!Utils.isEmpty(dbName) && Utils.isEmpty(db)) {
+        internal.db = dbName
+        db = dbName
+        Utils.requisites.startElabase()
+    }
+}
+
+
+function insert(collection, value, _id) {
+    var arg = {
+        collection: collection,
+        insert: value
+    }
+    if (_id)
+        arg._id = _id
+
+    return new Promise((resolve, reject) => resolve())
+    .then(() => execute(arg))
+    .then(result => {
+        Events.send("Elabase.insert", { collection: collectionArray(collection), response: result })
+        return result
+    })
+}
+
+function query(collection, query) {
+    var arg = {
+        collection: collection,
+        query: query
+    }
+    return new Promise((resolve, reject) => resolve())
+    .then(() => execute(arg))
+}
+
+function collectionArray(col) {
+    var type = Object.prototype.toString.call(col)
+    if (type === '[object Array]') {
+        var newcol = []
+        for (var i in col) {
+            if (!Utils.isEmpty(col[i]))
+                newcol.push(col[i])
+        }
+        return newcol
+    } else if (type === '[object String]') {
+        if (!Utils.isEmpty(col))
+            return [col]
+    }
+    return []
+}
+
+
+function update(collection, query, update) {
+    var arg = {
+        collection: collection,
+        query: query,
+        update: update,
+    }
+    return new Promise((resolve, reject) => resolve())
+    .then(() => execute(arg))
+    .then (result => {
+        Events.send("Elabase.update", { collection: collectionArray(collection), response: result })
+        return result
+    })
+}
+
+function remove(collection, query) {
+    var arg = {
+        collection: collection,
+        query: query,
+        delete: true,
+    }
+    return new Promise((resolve, reject) => resolve())
+    .then(() => execute(arg))
+    .then(result => {
+        Events.send("Elabase.remove", { collection: collectionArray(collection), response: result })
+        return result
+    })
+}
+
+function execute(arg) {
+//         arg example
+//        {
+//            db: "sled-sandhra",
+//            collection: "staff",
+//            query: "[@][?name == 'Bilbo'] | [0]",
+//            insert: { "name": "Bilbo" },
+//            query: { "name": "Frodo"},
+//            update: { "$set": { "age": 21 } }
+
+//            _id: 1 // Optional. Used with insert
+//        }
+        arg.db = arg.db ?? db
+        arg.engine = arg.engine ?? internal.engineName
+
+
+        return axios
+        .post(fullurl, arg)
+        // .timeout(5000)
+        .then(result => {
+//                  console.log(res.status);
+//                  console.log(JSON.stringify(res.header, null, 4));
+//                  console.log(JSON.stringify(res.body, null, 4));
+
+                    return result.data
+                })
+//       .catch(err => { console.log(err.message); console.log(err.response); return err});
+}
+
+
+
+
+
+
+
+// Axios usage
+//--------------
+// const axios = require('axios')
+// axios.get('http://www.floatrates.com/daily/usd.json').then(data => console.log(data)).catch(error=> console.log(error))

package/libs/kafka.js

@@ -0,0 +1,142 @@
+const { Kafka } = require('kafkajs')
+
+let kafka, producer, admin
+
+let topicPrefix = ''
+
+function start(arg) {
+    topicPrefix = process.env.APP_DEPLOYMENT_NAME + '.'
+    kafka = new Kafka({
+        clientId: arg?.clientId ?? process.env.APP_DEPLOYMENT_NAME,
+        brokers: arg?.brokers ??  ['redpanda-0.redpanda.redpanda.svc.cluster.local:9093'],   // ['107.155.108.78:9092']     ['127.0.0.1:29092']
+        sasl: {
+            mechanism: 'SCRAM-SHA-512',
+            username: process.env.KAFKA_USERNAME,
+            password: process.env.KAFKA_PASSWORD
+        },
+    })
+    producer = kafka.producer({allowAutoTopicCreation: true})
+    admin = kafka.admin();
+}
+
+
+async function createTopic(topic, partition, replicas) {
+    topic = topicPrefix + topic
+    return await admin.createTopics({ topics: [{topic, numPartitions: partition ?? 1, replicationFactor: replicas ?? 1}] })
+}
+
+// ===========
+// Consumer
+// ===========
+
+let consumers = []
+
+const start_consumer = async function (topic, groupId, callback) {
+    const consumer = kafka.consumer({ groupId: groupId ? groupId : "" })
+    consumers.push(consumer)
+
+    await consumer.connect()
+    await consumer.subscribe({ topic: topic, fromBeginning: true })
+
+    await consumer.run({
+        eachMessage: async ({ topic, partition, message }) => {
+            // callback(topic, message.value.toString(), partition) // toString() returns array so won't parse if json.
+            callback(topic, JSON.parse(message.value), partition)
+        },
+    })
+}
+
+
+// ===========
+// Producer
+// ===========
+let producerInvoked = false
+const start_producer = async function (topic, message, key) {
+
+    let isJson = Object.prototype.toString.call(message) === '[object Object]' || Object.prototype.toString.call(message) === '[object Array]'
+
+    if (!producerInvoked) {
+        await producer.connect()
+        producerInvoked = true
+    }
+    let value = isJson ? JSON.stringify(message) : message
+    await producer.send({
+        topic: topic,
+        messages: [
+            key ? { key, value} : {value},
+        ],
+    })
+    // .then(console.log)
+    // .catch(e => console.error("[example/producer] " + e.message, e))
+    // await producer.disconnect()
+}
+
+
+
+// start_consumer('quickstart-events')
+// start_producer('quickstart-events', 'Hello KafkaJS user! Little')
+
+const receive = async function(topic, groupId, callback) {
+    topic = topicPrefix + topic
+    await start_consumer(topic, groupId, callback)
+}
+
+
+const send = async function(topic, message, key) {
+    topic = topicPrefix + topic
+    await start_producer(topic, message, key)
+}
+
+module.exports = {
+    start,
+    createTopic,
+    send,
+    receive,
+}
+
+
+
+// Usage
+// -------
+// send('quickstart-events', { name: 'Muneer', age: 30 })
+
+// receive('quickstart-events', function (topic, message) {
+//     console.log(message)
+// })
+
+
+
+
+
+
+
+const errorTypes = ['unhandledRejection', 'uncaughtException']
+const signalTraps = ['SIGTERM', 'SIGINT', 'SIGUSR2']
+
+errorTypes.forEach(type => {
+    process.on(type, async () => {
+        try {
+            console.log(`process.on ${type}`)
+            if (producer)
+                await producer.disconnect()
+            for (let i = 0; i < consumers.length; i++)
+                await consumers[i].disconnect()
+            process.exit(0)
+        } catch (_) {
+            process.exit(1)
+        }
+    })
+})
+
+signalTraps.forEach(type => {
+    process.once(type, async () => {
+        try {
+            if (producer)
+                await producer.disconnect()
+            for (let i = 0; i < consumers.length; i++)
+                await consumers[i].disconnect()
+        } finally {
+            process.kill(process.pid, type)
+        }
+    })
+})

package/libs/utils.js

@@ -0,0 +1,55 @@
+let ObjectId = require('./ObjectId')
+
+let pipeline = { execute: execute }
+
+module.exports = {
+    uid,
+    isEmpty,
+    parseFloatValue,
+    parseIntValue,
+    now,
+    pipeline,
+}
+
+function uid() {
+    return ObjectId.ObjectId()
+}
+
+function isEmpty(str) { // returns true for undefined
+    if(!str)
+        return true
+    return str.match(/\S/) ? false : true // matches a non space character
+}
+
+// --------------
+// Parse Numbers
+// --------------
+
+function parseFloatValue(val) {
+    return parseFloat(val) ? parseFloat(val) : 0
+}
+
+function parseIntValue(val) {
+    return parseInt(val) ? parseInt(val) : 0
+}
+
+function now() {
+    return new Date()
+}
+
+
+// ----------------
+// Pipeline Execute
+// ----------------
+
+
+function execute(pipeline, errfn) {
+    startPipeline(pipeline, 0, undefined, errfn)  
+}
+
+function startPipeline(pipeline, index, data, errfn) {
+    index = index == undefined ? 0 : index
+    if (index == pipeline.length)
+        return
+    pipeline[index](data).then(data => startPipeline(pipeline, index + 1, data)).catch(err => { if (errfn) errfn(err) } )
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "corebasic",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}