@everneed/worker 2.1.0 → 2.2.0

package/index.js

@@ -67,7 +67,7 @@ import pseudoEnv from "./pseudoenv.js"
                         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()
+                    .connect()
         }
 /* Socketio */
         let socketioInstance = ()=>{}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everneed/worker",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/worker/rabbitmq.js

@@ -3,12 +3,13 @@ import fs from "fs"
 import crypto from "crypto"
 import amqp from "amqplib/callback_api.js"
 import moment from "moment"
+import EventEmitter from "events"
 
 import pseudoEnv from "@everneed/worker/pseudoenv.js"
 import { createHmac } from "crypto"
 import { redis } from "@everneed/worker"
 import { ResponseCode } from "@everneed/responsecode"
-import  { pipe, switchPourStr, randomStr } from "@everneed/helper"
+import  { pipe, switchPourStr, randomStr, extractUserInfo } from "@everneed/helper"
 
 class VersionManager{
     #currentVer
@@ -181,9 +182,28 @@ class VersionManager{
 }
 const version = new VersionManager()
 version.init()
+const bus = new EventEmitter()
 
-export default {
-    config: function(object){
+class RabbitMQ{
+    connection = null
+    channel = null
+
+    async init(){
+        await new Promise((resolve, reject)=>{
+            amqp.connect(pseudoEnv.process.env.RABBIT_HOST, (error0, connection)=>{
+                if(error0){ throw error0 }
+                this.connection = connection
+        
+                this.connection.createChannel((error1, channel)=>{
+                    if (error1){ throw error1 }
+                    this.channel = channel
+
+                    resolve("continue")
+                })
+            })
+        })
+    }
+    config(object){
         // config({
         //     ENV: value,
         //     ...
@@ -205,105 +225,105 @@ export default {
                 }
         /* Env Add Process */
                 pseudoEnv.config(object)
-    },
-    start: function(){
-        /* 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 endpoint in main.default){
-                    /* Generate consumer */
-                    channel.assertQueue(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`, {
-                        durable: true
+    }
+    async start(){
+        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 endpoint in main.default){
+                /* Generate consumer */
+                this.channel.assertQueue(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`, {
+                    durable: false
+                })
+                this.channel.consume(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`, async (message)=>{
+                    const mqHeader = message.properties.headers
+                    const mqReq = await this.#decryptMessage({
+                        message: message.content.toString(),
+                        ...(mqHeader.auth && { token: mqHeader.auth.token }),
+                        ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
                     })
-                    channel.consume(`req/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`, async (message)=>{
-                        const mqHeader = message.properties.headers
-                        const mqReq = await this.decryptMessage({
-                            message: message.content.toString(),
-                            ...(mqHeader.auth && { token: mqHeader.auth.token }),
-                            ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
+                    const trueVersion = mqHeader.version ?
+                        version.trueVersion({
+                            endpoint: `/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`,
+                            version: mqHeader.version
                         })
-                        const trueVersion = mqHeader.version ?
-                            version.trueVersion({
-                                endpoint: `/${pseudoEnv.process.env.SVC_NAME}/${moduleSpace}/${endpoint}`,
-                                version: mqHeader.version
-                            })
-                        :
-                            version.latestVersion()
-
-                        const prep = {
-                            message: null
-                        }
+                    :
+                        version.latestVersion()
+                    const prep = {
+                        message: null
+                    }
+                    let timeoutCounter = false
+                    
+                    // Start Timeout Timer
+                    const timeout = setTimeout(()=>{ timeoutCounter = true }, main.default[endpoint].timeout || 10000)
 
-                        try{
-                            /* Active Endpoint Filter */
-                                    if(!main.default[endpoint].active){
-                                        const response = new ResponseCode()
-                                        response.pushCode("INVALID_ENDPOINT")
-                                        prep["message"] = await this.encryptMessage({
-                                            message: response.result
-                                        })
-                                        throw "invalid_endpoint"
-                                    }
-                            /* API enforce Auth */
-                                    if(main.default[endpoint].authentication){
-                                        if(!mqHeader.auth){
-                                            const response = new ResponseCode()
-                                            response.pushCode("NOT_AUTHENTICATED")
-                                            prep["message"] = await this.encryptMessage({
-                                                message: response.result
-                                            })
-                                            throw "not_authenticated"
-                                        }
+                    try{
+                        /* Active Endpoint Filter */
+                                if(!main.default[endpoint].active) throw "invalid_endpoint"
+                        /* API enforce Auth */
+                                if(main.default[endpoint].authentication){
+                                    if(!mqHeader.auth) throw "not_authenticated"
+                                }
+                        /* Main Process */
+                                const result = await main.default[endpoint].function[`v${trueVersion}`](mqHeader.auth || false, mqReq.payload)
+                                prep["message"] = await this.#encryptMessage({
+                                    message: result,
+                                    ...(mqHeader.auth && { token: mqHeader.auth.token }),
+                                    ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
+                                })
+                        /* Resolve */
+                                if(timeoutCounter) throw "timeout"
+                                else throw "finish"
+                    }
+                    catch(something){
+                        /* Imbue response code according to throw */
+                                if(something == "finish") clearTimeout(timeout)
+                                if(something != "finish" && mqReq.trip == "returning"){
+                                    const response = new ResponseCode()
+                                    switch(something){
+                                        case "invalid_endpoint": response.pushCode("INVALID_ENDPOINT")
+                                        break;
+                                        case "not_authenticated": response.pushCode("NOT_AUTHENTICATED")
+                                        break;
+                                        case "timeout": response.pushCode("HTTP_TIMEOUT")
+                                        break;
+                                        default: response.pushCode("MQ_ERROR")
+                                        break;
                                     }
-                            /* Main Process */
-                                    const result = await main.default[endpoint].function[`v${trueVersion}`](mqHeader.auth || false, mqReq.payload)
-                                    prep["message"] = await this.encryptMessage({
-                                        message: result,
+
+                                    prep["message"] = await this.#encryptMessage({
+                                        message: response.result,
                                         ...(mqHeader.auth && { token: mqHeader.auth.token }),
                                         ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
                                     })
-                                    
-                            throw "finish"
-                        }
-                        catch(something){
-                            if(mqReq.trip == "returning"){
-                                channel.sendToQueue(message.properties.replyTo, Buffer.from(prep.message), {
-                                    correlationId: message.properties.correlationId,
-                                    headers:{
-                                        ...(mqHeader.version && { version: mqHeader.version }),
-                                        ...(mqHeader.auth && { auth: mqHeader.auth })
-                                    },
-                                })
-                                channel.ack(message)
-                            }
-                        }
-                    },{
-                        noAck: false
-                    })
-                }
+                                }
+                        /* Returning Trip */
+                                if(mqReq.trip == "returning"){
+                                    this.channel.sendToQueue(message.properties.replyTo, Buffer.from(prep.message), {
+                                        headers:{
+                                            ...(mqHeader.version && { version: mqHeader.version }),
+                                            ...(mqHeader.auth && { auth: mqHeader.auth })
+                                        }
+                                    })
+                                }
+                        /* Ack Compose */
+                                if(something == "finish") this.channel.ack(message)
+                                else this.channel.nack(message, false, false)
+                    }
+                },{
+                    noAck: false
+                },(error, ok)=>{ if(error) throw error })
             }
-
-            // connection.close()
-        })
-    },
-    publish: function({topic, version, auth=null, trip="passby", data}){
+        }
+    }
+    publish({topic, version, auth=null, trip="passby", data}){
         /* Usage */
         // publish({
         //     topic: <topic start at svc :String>,
@@ -321,117 +341,103 @@ export default {
         
         const response = new ResponseCode()
         return new Promise(async (resolve, reject)=>{
-            /* RabbitMQ Engine */
-            amqp.connect(pseudoEnv.process.env.RABBIT_HOST, async (error0, connection)=>{
-                if(error0){ throw error0 }
-
-                try{
-                    /* Creates connection & channel */
-                            const channel = connection.createChannel((error1, channel)=>{
-                                if (error1){ throw error1 }
-                                return channel
-                            })
-                    
-                    /* Build payload structure */
-                    // like topic, address, etc.
-                            const userName = auth ? this.getUserInfo({tokenBody: auth.token.split(".")[0]}).userName : `guest${randomStr({length: 12})}`
-                            const prep = {
-                                topic: `req/${topic}`,
-                                message:{
-                                    trip: trip,
-                                    senderAddress: `${createHmac("sha256", userName).digest("hex").slice(0, 12)}${moment().utc().format("HHmmssSSS")}`,
-                                    payload: data
-                                }
+            try{  
+                /* Build payload structure */
+                // like topic, address, etc.
+                        const userName = auth ? extractUserInfo({token: auth.token}).userName : `guest${randomStr({length: 12})}`
+                        const prep = {
+                            topic: `req/${topic}`,
+                            message:{
+                                trip: trip,
+                                payload: data
                             }
-                    /* Validate Auth */                    
-                            if(auth){
-                                const validate = await this.publish({
-                                    topic: "authenthor/session/svVerifyToken",
-                                    trip: "returning",
-                                    data:{
-                                        token: auth.token,
-                                        userAgent: auth.userAgent,
-                                        noRefresh: true
-                                    }
-                                })
+                        }
+                        let senderAddress
+                /* Validate Auth */
+                        if(auth){
+                            const validate = await this.publish({
+                                topic: "authenthor/session/svVerifyToken",
+                                trip: "returning",
+                                data:{
+                                    token: auth.token,
+                                    userAgent: auth.userAgent,
+                                    noRefresh: true
+                                }
+                            })
 
-                                response.createNew(validate)
-                                if(response.checkError()) throw "abort"
-                                else response.reset()
+                            if(validate.checkError()){ 
+                                response.createNew(validate.result)
+                                throw "abort"
                             }
-                    /* Main publisher */
-                            const mqReq = await this.encryptMessage({
-                                message: prep.message,
-                                ...(auth && { token: auth.token }),
-                                ...(auth && { userAgent: auth.userAgent })
-                            })
-    
-                            channel.assertQueue(prep.topic, { durable: true })
-                            channel.sendToQueue(prep.topic, Buffer.from(mqReq), {
-                                headers:{
-                                    ...(version && { version: version }),
-                                    ...(auth && { auth: auth })
-                                },
-                                ...(trip == "returning" && { correlationId: prep.message.senderAddress }),
-                                ...(trip == "returning" && { replyTo: `res/${topic}` }),
-                            })
-    
-                    /* Resolvation According to Trip */
-                            if(trip == "returning"){
-                                /* Creates consumer for returning messages */
-                                channel.assertQueue(`res/${topic}`, { durable: true })
-                                channel.consume(`res/${topic}`, async (message)=>{
-                                    const mqRes = await this.decryptMessage({
-                                        message: message.content.toString(),
-                                        ...(auth && { token: auth.token }),
-                                        ...(auth && { userAgent: auth.userAgent })
-                                    })
-    
-                                    if(message.properties.correlationId == prep.message.senderAddress){
-                                        response.createNew(mqRes)
-                                        channel.ack(message)
-                                        setTimeout(()=>{
-                                            connection.close()
-                                        }, 500)
-                                        
-                                        resolve(response)
-                                    }
-                                }, {
-                                    noAck: false
+                        }
+                /* Prepare Listener */
+                        if(trip == "returning"){
+                            /* Creates consumer for returning messages */
+                            senderAddress = await new Promise((resolva, rejecta)=>{
+                                this.channel.assertQueue("", { exclusive: true, autoDelete: true }, (error, ok)=>{
+                                    resolva(ok.queue)
+                                })
+                            }) 
+                            /* Returning Message's Sub-Consumer */
+                            this.channel.consume(senderAddress, async (message)=>{
+                                const mqRes = await this.#decryptMessage({
+                                    message: message.content.toString(),
+                                    ...(auth && { token: auth.token }),
+                                    ...(auth && { userAgent: auth.userAgent })
                                 })
-                            }
-                            else if(trip == "passby"){
-                                response.pushCode("GENERAL_OK")
-                                
-                                setTimeout(()=>{
-                                    connection.close()
-                                }, 500)
 
+                                this.channel.ack(message)
+                                response.createNew(mqRes)
+                                this.channel.cancel(senderAddress)
                                 resolve(response)
-                            }
-                }
-                catch(something){
-                    response.createNew(response.result)
-                    if(something != "abort"){
-                        // err: other error
-                        response.pushCode("LOGIC_ERROR")
-                        response.pushTrace({code: "LOGIC_ERROR", trace: `Unexpected error on queue publisher`})
-                    }
-    
-                    resolve(response)
+                            }, {
+                                noAck: false,
+                                consumerTag: senderAddress
+                            },(error, ok)=>{ if(error) throw error })
+                        }
+                /* Main publisher */
+                        const mqReq = await this.#encryptMessage({
+                            message: prep.message,
+                            ...(auth && { token: auth.token }),
+                            ...(auth && { userAgent: auth.userAgent })
+                        })
+
+                        this.channel.assertQueue(prep.topic, {
+                            durable: false
+                        })
+                        this.channel.sendToQueue(prep.topic, Buffer.from(mqReq), {
+                            headers:{
+                                ...(version && { version: version }),
+                                ...(auth && { auth: auth })
+                            },
+                            ...(trip == "returning" && { replyTo: senderAddress })
+                        })
+                /* Non-returning Trip Resolvation */
+                        if(trip == "passby"){
+                            response.pushCode("GENERAL_OK")
+
+                            resolve(response)
+                        }
+            }
+            catch(something){
+                response.createNew(response.result)
+                if(something != "abort"){
+                    // err: other error
+                    response.pushCode("LOGIC_ERROR")
+                    response.pushTrace({code: "LOGIC_ERROR", trace: `Unexpected error on queue publisher`})
                 }
-                // connection.close()
-            })
+
+                resolve(response)
+            }
         })
-    },
-    encryptMessage: function({message, token=null, userAgent=null}){
+    }
+    #encryptMessage({message, token=null, userAgent=null}){
         return new Promise(async (resolve, reject)=>{
             /* Active Auth Session */
                     if(token && userAgent){
-                        const { userId } = this.getUserInfo({ tokenBody: token.split(".")[0] })
+                        const { userId } = extractUserInfo({ token: token })
                         const uaHash = crypto.hash("sha256", switchPourStr(userAgent, pseudoEnv.process.env.TOKEN_UA_SALT))
-                        await redis.connect().catch(error => {})
-                        const authKey = await redis.get(`auth:session:long:${userId}:${uaHash}`) 
+                        const authKey = await redis.get(`auth:session:long:${userId}:${uaHash}`)
                         const hash = crypto.hash("sha256", switchPourStr(authKey || "kontol", pseudoEnv.process.env.RABBIT_MESSAGE_SALT))
                         const key = hash.substring(0, 16)
                         const iv = hash.substring(48)
@@ -449,15 +455,14 @@ export default {
                         return resolve(encrypted)
                     }
         })
-    },
-    decryptMessage: function({message, token=null, userAgent=null}){
+    }
+    #decryptMessage({message, token=null, userAgent=null}){
         return new Promise(async (resolve, reject)=>{
             /* Active Auth Session */
                     if(token && userAgent){
-                        const { userId } = this.getUserInfo({ tokenBody: token.split(".")[0] })
+                        const { userId } = extractUserInfo({ token: token })
                         const uaHash = crypto.hash("sha256", switchPourStr(userAgent, pseudoEnv.process.env.TOKEN_UA_SALT))
-                        await redis.connect().catch(error => {})
-                        const authKey = await redis.get(`auth:session:long:${userId}:${uaHash}`) 
+                        const authKey = await redis.get(`auth:session:long:${userId}:${uaHash}`)
                         const hash = crypto.hash("sha256", switchPourStr(authKey || "kontol", pseudoEnv.process.env.RABBIT_MESSAGE_SALT))
                         const key = hash.substring(0, 16)
                         const iv = hash.substring(48)
@@ -475,25 +480,12 @@ export default {
                         return resolve(JSON.parse(decrypted))
                     }
         })
-    },
-    getUserInfo: function({tokenBody}){
-        return pipe(tokenBody)
-        .then(aes=>{
-            const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.TOKEN_KEY), Buffer.from(pseudoEnv.process.env.TOKEN_IV))
-            let decrypted = decipher.update(aes, "base64", "utf-8")
-            return decrypted += decipher.final("utf-8")
-        })
-        .then(json=> JSON.parse(json))
-        .then(circular=> circular.user)
-        .result // { userId, userName, displayName }
-    },
-    update: function(){
+    }
+    update(){
         version.update()
-    },
-    apiVer: function(){
-        return version.deprecatedVersion()+1
-    },
-    latestVer: function(){
-        return version.latestVersion()
     }
-}
+}
+
+const instance = new RabbitMQ()
+await instance.init()
+export default instance