@everneed/worker 2.0.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.0.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,143 +225,108 @@ 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({
-                            mode: mqHeader.mode,
-                            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({
-                                            mode: mqHeader.mode,
-                                            message: response.result
-                                        })
-                                        throw "invalid_endpoint"
-                                    }
-                            /* API enforce Auth */
-                                    if(main.default[endpoint].authentication){
-                                        if(!mqHeader.auth && mqHeader.mode != "auth"){
-                                            const response = new ResponseCode()
-                                            response.pushCode("NOT_AUTHENTICATED")
-                                            prep["message"] = await this.encryptMessage({
-                                                mode: mqHeader.mode,
-                                                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;
                                     }
-    
-                            /* With Auth */
-                                    if(mqHeader.auth && mqHeader.mode == "auth"){
-                                        const { token, userAgent } = mqHeader.auth
-                                        const auth = await this.verifyToken({
-                                            token: token,
-                                            userAgent: userAgent
-                                        })
-    
-                                        if(auth.checkError()){ // NOT_AUTHENTICATED || SESSION_EXPIRED
-                                            prep["message"] = await this.encryptMessage({
-                                                mode: mqHeader.mode,
-                                                message: auth.result
-                                            })
-                                        }
-                                        else{ // AUTHENTICATED || REFRESH_SESSION
-                                            const result = await main.default[endpoint].function[`v${trueVersion}`](mqHeader.auth, mqReq.payload)
-                                            const response = new ResponseCode(result)
-                                            if(auth.hasCode("REFRESH_SESSION")) response.pushRefresh(auth.result.data)
-                                            prep["message"] = await this.encryptMessage({
-                                                mode: mqHeader.mode,
-                                                message: response.result,
-                                                token: token,
-                                                userAgent: userAgent
-                                            })
+
+                                    prep["message"] = await this.#encryptMessage({
+                                        message: response.result,
+                                        ...(mqHeader.auth && { token: mqHeader.auth.token }),
+                                        ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
+                                    })
+                                }
+                        /* 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 })
                                         }
-                                    }
-                            /* Without Auth */
-                                    else{
-                                        const result = await main.default[endpoint].function[`v${trueVersion}`](false, mqReq.payload)
-                                        prep["message"] = await this.encryptMessage({
-                                            mode: mqHeader.mode,
-                                            message: 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:{
-                                        mode: mqHeader.mode,
-                                        ...(mqHeader.version && { version: mqHeader.version }),
-                                        ...(mqHeader.auth && { auth: mqHeader.auth })
-                                    },
-                                })
-                                channel.ack(message)
-                            }
-                        }
-                    },{
-                        noAck: false
-                    })
-                }
+                                    })
+                                }
+                        /* 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, mode="auth", auth=null, trip="passby", data}){
+        }
+    }
+    publish({topic, version, auth=null, trip="passby", data}){
         /* Usage */
         // publish({
         //     topic: <topic start at svc :String>,
-        //     mode: <"auth"|"no auth" :String>
         //     auth:{
         //         token: <auth token :String>,
         //         userAgent: <ua string :String>,
@@ -354,266 +339,153 @@ export default {
         // ex: req/cd6f01UjkB7E/rolling-tempat-duduk/class/getAll
         // ex: res/cd6f01UjkB7E/rolling-tempat-duduk/class/getAll
         
+        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 }
-
-                /* Creates connection & channel */
-                        const channel = connection.createChannel((error1, channel)=>{
-                            if (error1){ throw error1 }
-                            return channel
-                        })
-                
+            try{  
                 /* Build payload structure */
                 // like topic, address, etc.
-                        const userName = auth ? this.getUserInfo({tokenBody: auth.token.split(".")[0]}).userName : `guest${randomStr({length: 12})}`
+                        const userName = auth ? extractUserInfo({token: auth.token}).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
                             }
                         }
+                        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
+                                }
+                            })
+
+                            if(validate.checkError()){ 
+                                response.createNew(validate.result)
+                                throw "abort"
+                            }
+                        }
+                /* 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 })
+                                })
+
+                                this.channel.ack(message)
+                                response.createNew(mqRes)
+                                this.channel.cancel(senderAddress)
+                                resolve(response)
+                            }, {
+                                noAck: false,
+                                consumerTag: senderAddress
+                            },(error, ok)=>{ if(error) throw error })
+                        }
                 /* Main publisher */
-                        const mqReq = await this.encryptMessage({
-                            mode: mode,
+                        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), {
+                        this.channel.assertQueue(prep.topic, {
+                            durable: false
+                        })
+                        this.channel.sendToQueue(prep.topic, Buffer.from(mqReq), {
                             headers:{
                                 ...(version && { version: version }),
-                                mode: mode,
                                 ...(auth && { auth: auth })
                             },
-                            ...(trip == "returning" && { correlationId: prep.message.senderAddress }),
-                            ...(trip == "returning" && { replyTo: `res/${topic}` }),
+                            ...(trip == "returning" && { replyTo: senderAddress })
                         })
+                /* Non-returning Trip Resolvation */
+                        if(trip == "passby"){
+                            response.pushCode("GENERAL_OK")
 
-                /* Resolvation According to Trip */
-                        if(trip == "returning"){
-                            /* Creates consumer for returning messages */
-                            channel.assertQueue(`res/${topic}`, { durable: true })
-                            channel.consume(`res/${topic}`, async (message)=>{
-                                /* Differentiate normal flow with refresh session flow */
-                                const sessionRefresh = ()=>{
-                                    const response = new ResponseCode(message.content.toString())
-                                    if(response.hasCode("REFRESH_SESSION")) return true
-                                    else return false
-                                }
-                                const mqRes = await this.decryptMessage({
-                                    mode: mode,
-                                    message: message.content.toString(),
-                                    ...((auth && !sessionRefresh()) && { token: auth.token }),
-                                    ...((auth && sessionRefresh()) && { token: message.content.toString().data.token }),
-                                    ...(auth && { userAgent: auth.userAgent })
-                                })
-
-                                if(message.properties.correlationId == prep.message.senderAddress){
-                                    resolve(mqRes)
-                                    channel.ack(message)
-                                    setTimeout(()=>{
-                                        connection.close()
-                                    }, 500)
-                                }
-                            }, {
-                                noAck: false
-                            })
-                        }
-                        else if(trip == "passby"){
-                            resolve("sent")
-                            
-                            setTimeout(()=>{
-                                connection.close()
-                            }, 500)
-                        }
-
-                // connection.close()
-            })
-        })
-    },
-    encryptMessage: function({mode="auth", message, token=null, userAgent=null}){
-        return new Promise(async (resolve, reject)=>{
-            if(mode == "auth"){
-                /* Active Auth Session */
-                        if(token && userAgent){
-                            const { userId } = this.getUserInfo({ tokenBody: token.split(".")[0] })
-                            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 hash = crypto.hash("sha256", switchPourStr(authKey, pseudoEnv.process.env.RABBIT_MESSAGE_SALT))
-                            const key = hash.substring(0, 16)
-                            const iv = hash.substring(48)
-
-                            const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
-                            let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
-                            encrypted += cipher.final("base64")
-                            return resolve(encrypted)
-                        }
-                /* No Auth */
-                        else{
-                            const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
-                            let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
-                            encrypted += cipher.final("base64")
-                            return resolve(encrypted)
+                            resolve(response)
                         }
             }
-            else if(mode == "no auth"){
-                /* Unchecked Token (Illegal/Refresh) */
-                        if(token){
-                            const {key, iv} = pipe(token)
-                            .then(token=> token.split(".")[0])
-                            .then(tokenBody=> this.getUserInfo({tokenBody: tokenBody}))
-                            .then(({userName, userId, displayName})=>{
-                                return switchPourStr(
-                                    userName,
-                                    pseudoEnv.process.env.RABBIT_MESSAGE_KEY,
-                                    userId,
-                                    pseudoEnv.process.env.RABBIT_MESSAGE_IV,
-                                    displayName,
-                                )
-                            })
-                            .then(mixWord=> crypto.hash("sha256", mixWord))
-                            .then(hash=>{
-                                return {
-                                    key: hash.substring(0, 16),
-                                    iv: hash.substring(48)
-                                }
-                            })
-                            .result
-
-                            const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
-                            let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
-                            encrypted += cipher.final("base64")
-                            return resolve(encrypted)
-                        }
-                /* No Auth */
-                        else{
-                            const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
-                            let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
-                            encrypted += cipher.final("base64")
-                            return resolve(encrypted)
-                        }
-            }
-        })
-    },
-    decryptMessage: function({mode="auth", message, token=null, userAgent=null}){
-        return new Promise(async (resolve, reject)=>{
-            if(mode == "auth"){
-                /* Active Auth Session */
-                        if(token && userAgent){
-                            const { userId } = this.getUserInfo({ tokenBody: token.split(".")[0] })
-                            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 hash = crypto.hash("sha256", switchPourStr(authKey, pseudoEnv.process.env.RABBIT_MESSAGE_SALT))
-                            const key = hash.substring(0, 16)
-                            const iv = hash.substring(48)
-
-                            const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
-                            let decrypted = decipher.update(message, "base64", "utf-8")
-                            decrypted += decipher.final("utf-8")
-                            return resolve(JSON.parse(decrypted))
-                        }
-                /* No Auth */
-                        else{
-                            const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
-                            let decrypted = decipher.update(message, "base64", "utf-8")
-                            decrypted += decipher.final("utf-8")
-                            return resolve(JSON.parse(decrypted))
-                        }
-            }
-            else if(mode == "no auth"){
-                /* Unchecked Token (Illegal/Refresh) */
-                        if(token){
-                            const {key, iv} = pipe(token)
-                            .then(token=> token.split(".")[0])
-                            .then(tokenBody=> this.getUserInfo({tokenBody: tokenBody}))
-                            .then(({userName, userId, displayName})=>{
-                                return switchPourStr(
-                                    userName,
-                                    pseudoEnv.process.env.RABBIT_MESSAGE_KEY,
-                                    userId,
-                                    pseudoEnv.process.env.RABBIT_MESSAGE_IV,
-                                    displayName,
-                                )
-                            })
-                            .then(mixWord=> crypto.hash("sha256", mixWord))
-                            .then(hash=>{
-                                return {
-                                    key: hash.substring(0, 16),
-                                    iv: hash.substring(48)
-                                }
-                            })
-                            .result
-
-                            const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
-                            let decrypted = decipher.update(message, "base64", "utf-8")
-                            decrypted += decipher.final("utf-8")
-                            return resolve(JSON.parse(decrypted))
-                        }
-                /* No Auth */
-                        else{
-                            const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
-                            let decrypted = decipher.update(message, "base64", "utf-8")
-                            decrypted += decipher.final("utf-8")
-                            return resolve(JSON.parse(decrypted))
-                        }
-            }
-        })
-    },
-    verifyToken: function({token, userAgent}){
-        const response = new ResponseCode()
-        return new Promise(async (resolve, reject)=>{
-            try{                
-                await this.publish({
-                    topic: "authenthor/session/svVerifyToken",
-                    mode: "no auth",
-                    trip: "returning",
-                    data:{
-                        token: token,
-                        userAgent: userAgent
-                    }
-                })
-                .then(apiRes=>{
-                    response.createNew(apiRes)
-                    throw "abort"
-                })
-            }
             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 ${pseudoEnv.process.env.SVC_DISPLAY} svCreateToken() function`})
+                    response.pushTrace({code: "LOGIC_ERROR", trace: `Unexpected error on queue publisher`})
                 }
 
                 resolve(response)
             }
         })
-    },
-    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")
+    }
+    #encryptMessage({message, token=null, userAgent=null}){
+        return new Promise(async (resolve, reject)=>{
+            /* Active Auth Session */
+                    if(token && userAgent){
+                        const { userId } = extractUserInfo({ token: token })
+                        const uaHash = crypto.hash("sha256", switchPourStr(userAgent, pseudoEnv.process.env.TOKEN_UA_SALT))
+                        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)
+
+                        const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
+                        let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
+                        encrypted += cipher.final("base64")
+                        return resolve(encrypted)
+                    }
+            /* No Auth */
+                    else{
+                        const cipher = crypto.createCipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
+                        let encrypted = cipher.update(JSON.stringify(message), "utf-8", "base64")
+                        encrypted += cipher.final("base64")
+                        return resolve(encrypted)
+                    }
         })
-        .then(json=> JSON.parse(json))
-        .then(circular=> circular.user)
-        .result // { userId, userName, displayName }
-    },
-    update: function(){
+    }
+    #decryptMessage({message, token=null, userAgent=null}){
+        return new Promise(async (resolve, reject)=>{
+            /* Active Auth Session */
+                    if(token && userAgent){
+                        const { userId } = extractUserInfo({ token: token })
+                        const uaHash = crypto.hash("sha256", switchPourStr(userAgent, pseudoEnv.process.env.TOKEN_UA_SALT))
+                        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)
+
+                        const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(key), Buffer.from(iv))
+                        let decrypted = decipher.update(message, "base64", "utf-8")
+                        decrypted += decipher.final("utf-8")
+                        return resolve(JSON.parse(decrypted))
+                    }
+            /* No Auth */
+                    else{
+                        const decipher = crypto.createDecipheriv("aes-128-cbc", Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_KEY), Buffer.from(pseudoEnv.process.env.RABBIT_MESSAGE_IV))
+                        let decrypted = decipher.update(message, "base64", "utf-8")
+                        decrypted += decipher.final("utf-8")
+                        return resolve(JSON.parse(decrypted))
+                    }
+        })
+    }
+    update(){
         version.update()
-    },
-    apiVer: function(){
-        return version.deprecatedVersion()+1
-    },
-    latestVer: function(){
-        return version.latestVersion()
     }
-}
+}
+
+const instance = new RabbitMQ()
+await instance.init()
+export default instance