@everneed/worker 1.0.0

package/index.js

@@ -0,0 +1,75 @@
+import postgres from "postgres"
+import mongoose from "mongoose"
+import { createClient } from  "redis"
+
+import rabbitmq from "./worker/rabbitmq.js"
+import pseudoEnv from "./pseudoenv.js"
+
+
+/* Postgres */
+        let postgresInstance = ()=>{}
+        postgresInstance.config = (object)=>{
+            // config({
+            //     ENV: value,
+            //     ...
+            // })
+            /* Param Validation */
+                    const allowed = new Set(["PG_HOST", "PG_PORT", "PG_DB", "PG_USER", "PG_PASSWORD", "PG_SCHEMA"])
+                    if(new Set(Object.keys(object)).difference(allowed).size){
+                        throw `illegal key on postgres.config(): Only ${Array.from(allowed).join(", ")} are allowed`
+                    }
+            /* Env Add Process */
+                    pseudoEnv.config(object)
+            /* Refresh Instance (force re-export) */
+                    postgresInstance = postgres({
+                        host: pseudoEnv.process.env.PG_HOST,
+                        port: pseudoEnv.process.env.PG_PORT,
+                        database: pseudoEnv.process.env.PG_DB,
+                        username: pseudoEnv.process.env.PG_USER,
+                        password: pseudoEnv.process.env.PG_PASSWORD,
+                        prepare: true,
+                    })
+        }
+/* mongoose */
+        let mongooseInstance = ()=>{}
+        mongooseInstance.config = (object)=>{
+            // config({
+            //     ENV: value,
+            //     ...
+            // })
+            /* Param Validation */
+                    const allowed = new Set(["MONGO_HOST", "MONGO_PORT", "MONGO_DATABASE"])
+                    if(new Set(Object.keys(object)).difference(allowed).size){
+                        throw `illegal key on mongoose.config(): Only ${Array.from(allowed).join(", ")} are allowed`
+                    }
+            /* Env Add Process */
+                    pseudoEnv.config(object)
+            /* Refresh Instance (force re-export) */
+                    mongooseInstance = await mongoose.connect(`mongodb://${pseudoEnv.process.env.MONGO_HOST}:${pseudoEnv.process.env.MONGO_PORT}/${pseudoEnv.process.env.MONGO_DATABASE}`)
+        }
+/* Redis */
+        let redisInstance = ()=>{}
+        redisInstance.config = async (object)=>{
+            // config({
+            //     ENV: value,
+            //     ...
+            // })
+            /* Param Validation */
+                    const allowed = new Set(["REDIS_USERNAME", "REDIS_PASSWORD", "REDIS_HOST", "REDIS_PORT"])
+                    if(new Set(Object.keys(object)).difference(allowed).size){
+                        throw `illegal key on redis.config(): Only ${Array.from(allowed).join(", ")} are allowed`
+                    }
+            /* Env Add Process */
+                    pseudoEnv.config(object)
+            /* Refresh Instance (force re-export) */
+                    redisInstance = await createClient(/* {
+                        url: `redis://${pseudoEnv.process.env.REDIS_USERNAME}:${pseudoEnv.process.env.REDIS_PASSWORD}@${pseudoEnv.process.env.REDIS_HOST}:${pseudoEnv.process.env.REDIS_PORT}`
+                    } */)
+                    .on("error", err => console.log("Redis Client Error", err))
+                    // .connect()
+        }
+
+export { rabbitmq } // preserve seperate-dir for example
+export { postgresInstance as postgres }
+// export { mongooseInstance as mongoose }
+export { redisInstance as redis }

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@everneed/worker",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/everneed/npm-worker.git"
+  },
+  "author": "everneed",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/everneed/npm-worker/issues"
+  },
+  "homepage": "https://github.com/everneed/npm-worker#readme",
+  "description": ""
+}

package/pseudoenv.js

@@ -0,0 +1,24 @@
+class Config {
+    process = {
+        env: {
+            // ENV_NAME: value,
+            // ...
+        }
+    }
+
+    config(envObject){
+        // for(const env of envObject){
+        //     this.process.env[env] = envObject[env]
+        // }
+
+        // this.process.env = {
+        //     ...this.process.env,
+        //     ...envObject
+        // }
+        Object.assign(this.process.env, envObject)
+    }
+}
+
+const pseudoEnv = new Config()
+
+export default pseudoEnv

package/worker/rabbitmq.js

@@ -0,0 +1,159 @@
+import path from "path"
+import fs from "fs"
+import amqp from "amqplib/callback_api.js"
+import moment from "moment"
+
+import pseudoEnv from "@everneed/worker/pseudoenv.js"
+import { createHmac } from "crypto"
+
+export default {
+    config: (object)=>{
+        // config({
+        //     ENV: value,
+        //     ...
+        // })
+        /* Param Validation */
+                const allowed = new Set(["SVC_NAME", "RABBIT_HOST"])
+                if(new Set(Object.keys(object)).difference(allowed).size){
+                    throw `illegal key on rabbitmq.config(): Only ${Array.from(allowed).join(", ")} are allowed`
+                }
+        /* Env Add Process */
+                pseudoEnv.config(object)
+    },
+    start: ()=>{
+        /* RabbitMQ Engine */
+        amqp.connect(pseudoEnv.process.env.RABBIT_HOST, async (error0, connection)=>{
+            if(error0) throw error0
+
+            /* Initiate header variables */
+            const channel = connection.createChannel((error1, channel)=>{
+                if (error1){ throw error1 }
+
+                return channel
+            })
+            const rabbitmqGateway = fs.readdirSync(path.join(process.cwd(), "/src/mq-gateway/"))
+            /* Generate consumer */
+            // iterating every files in /src/mq-gateway
+            // and its function to be built as rabbitmq
+            // subscriber (consumer)
+            for(const file of rabbitmqGateway){
+                const moduleSpace = file.slice(0, -3)
+                const main = await import(`file://${path.join(process.cwd(), `/src/mq-gateway/${moduleSpace}`)}.js`)
+                // const main = await import(`#@/mq-gateway/${moduleSpace}.js`)
+                
+                for(const functName in main.default){
+                    /* Generate consumer */
+                    channel.assertQueue(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${functName}`, {
+                        durable: true
+                    })
+                    channel.consume(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${functName}`, async (message)=>{
+                        const mqReq = pipe(message)
+                            .then(message=> JSON.parse(message.content))
+                            .then(mqReq=> nullCleanser(mqReq))
+                            .result
+
+                        const result = await main.default[functName](mqReq.payload)
+
+                        if(mqReq.trip == "returning"){
+                            channel.sendToQueue(message.properties.replyTo, Buffer.from(JSON.stringify(result)), {
+                                correlationId: message.properties.correlationId
+                            })
+                            channel.ack(message)
+                        }
+                    },{
+                        noAck: false
+                    })
+                }
+            }
+
+            // connection.close()
+        })
+    },
+    publish: ({topic, userName, trip = "passby", data})=>{
+        /* Usage */
+        // publish({
+        //     topic: <topic start at svc :String>,
+        //     userName: <userName or guest :String>,
+        //     trip: <"returning"|"passby" :String>,
+        //     data: <message :String>
+        // })
+    
+        // topic: <req|res>/<short sha username + random string>/<svc>/<endpoint>
+        // ex: req/cd6f01UjkB7E/rolling-tempat-duduk/class/get-all
+        // ex: res/cd6f01UjkB7E/rolling-tempat-duduk/class/get-all
+        
+        return new Promise(async (resolve, reject)=>{
+            /* RabbitMQ Engine */
+            amqp.connect(pseudoEnv.process.env.RABBIT_HOST, (error0, connection)=>{
+                if(error0){ throw error0 }
+
+                /* Creates connection & channel */
+                const channel = connection.createChannel((error1, channel)=>{
+                    if (error1){ throw error1 }
+                    
+                    return channel
+                })
+                
+                /* Build payload structure */
+                // like topic, address, etc.
+                const prep = {
+                    topic: `req/${topic}`,
+                    message:{
+                        trip: trip,
+                        senderAddress: `${createHmac("sha256", userName).digest("hex").slice(0, 6)}${moment().utc().format("HHmmssSSS")}`,
+                        payload: data
+                    }
+                }
+                
+                if(trip == "returning"){
+                    /* Reshape topic into response shape */
+                    let resTopic = `res/${topic}`
+            
+                    /* Creates consumer for returning messages */
+                    channel.assertQueue(resTopic, {
+                        durable: true
+                    })
+                    channel.consume(resTopic, (message)=>{
+                        const mqRes = JSON.parse(message.content.toString())
+
+                        if(message.properties.correlationId == prep.message.senderAddress){
+                            resolve(mqRes)
+                            channel.ack(message)
+                            setTimeout(()=>{
+                                connection.close()
+                            }, 500)
+                        }
+                    }, {
+                        noAck: false
+                    })
+
+                    /* Main publisher (with correlation id) */
+                    channel.assertQueue(prep.topic,{
+                        durable: true
+                    })
+                    channel.sendToQueue(prep.topic, Buffer.from(JSON.stringify(prep.message)), {
+                        correlationId: prep.message.senderAddress,
+                        replyTo: resTopic
+                    })
+                }
+                else if(trip == "passby"){
+                    /* Main publisher */
+                    // pushes without senderAddress
+                    prep.message["senderAddress"] = null
+                    
+                    channel.assertQueue(prep.topic,{
+                        durable: true
+                    })
+                    channel.sendToQueue(prep.topic, Buffer.from(JSON.stringify(prep.message)))
+                    resolve("sent")
+                    
+                    setTimeout(()=>{
+                        connection.close()
+                    }, 500)
+                }
+
+                // connection.close()
+            })
+        })
+    },
+}