@everneed/worker 1.0.2 → 1.2.0

package/index.js

@@ -1,6 +1,7 @@
 import postgres from "postgres"
 import mongoose from "mongoose"
 import { createClient } from  "redis"
+import { io } from "socket.io-client"
 
 import rabbitmq from "./worker/rabbitmq.js"
 import pseudoEnv from "./pseudoenv.js"
@@ -68,8 +69,26 @@ import pseudoEnv from "./pseudoenv.js"
                     .on("error", err => console.log("Redis Client Error", err))
                     // .connect()
         }
+/* Socketio */
+        let socketioInstance = ()=>{}
+        socketioInstance.config = (object)=>{
+                // config({
+                //     ENV: value,
+                //     ...
+                // })
+                /* Param Validation */
+                        const allowed = new Set(["WEBSOCKET_HOST", "WEBSOCKET_PORT"])
+                        if(new Set(Object.keys(object)).difference(allowed).size){
+                                throw `illegal key on socketio.config(): Only ${Array.from(allowed).join(", ")} are allowed`
+                        }
+                /* Env Add Process */
+                        pseudoEnv.config(object)
+                /* Refresh Instance (force re-export) */
+                        socketioInstance = io(`ws://${pseudoEnv.process.env.WEBSOCKET_HOST}:${pseudoEnv.process.env.WEBSOCKET_PORT}/`)
+        }
 
 export { rabbitmq } // preserve seperate-dir for example
 export { postgresInstance as postgres }
 // export { mongooseInstance as mongoose }
 export { redisInstance as redis }
+export { socketioInstance as socketio }

package/package.json

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

package/worker/rabbitmq.js

@@ -1,26 +1,40 @@
 import path from "path"
 import fs from "fs"
+import crypto from "crypto"
 import amqp from "amqplib/callback_api.js"
 import moment from "moment"
 
 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"
 
 export default {
-    config: (object)=>{
+    config: function(object){
         // config({
         //     ENV: value,
         //     ...
         // })
         /* Param Validation */
-                const allowed = new Set(["SVC_NAME", "RABBIT_HOST"])
+                const allowed = new Set([
+                    "SVC_NAME",
+                    "SVC_DISPLAY",
+                    "RABBIT_HOST",
+                    "RABBIT_MESSAGE_KEY",
+                    "RABBIT_MESSAGE_IV",
+                    "RABBIT_MESSAGE_SALT",
+                    "TOKEN_UA_SALT",
+                    "TOKEN_KEY",
+                    "TOKEN_IV"
+                ])
                 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: ()=>{
+    start: function(){
         /* RabbitMQ Engine */
         amqp.connect(pseudoEnv.process.env.RABBIT_HOST, async (error0, connection)=>{
             if(error0) throw error0
@@ -47,15 +61,64 @@ export default {
                         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 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 prep = {
+                            message: null
+                        }
+                        
+                        /* With Auth */
+                                if(main.default[functName].authentication){
+                                    if(!mqHeader.auth){
+                                        const response = new ResponseCode()
+                                        response.pushCode("NOT_AUTHENTICATED")
+                                        this.encryptMessage({
+                                            message: response
+                                        })
+                                        return
+                                    }
+                                    
+                                    const { token, userAgent } = mqHeader.auth
+                                    const auth = await this.verifyToken({
+                                        token: token,
+                                        userAgent: userAgent
+                                    })
 
-                        const result = await main.default[functName](mqReq.payload)
+                                    if(auth.checkError()){ // NOT_AUTHENTICATED || SESSION_EXPIRED
+                                        prep["message"] = await this.encryptMessage({
+                                            message: auth.result,
+                                            token: token,
+                                            userAgent: userAgent
+                                        })
+                                    }
+                                    else{ // AUTHENTICATED || REFRESH_SESSION
+                                        const result = await main.default[functName](mqHeader.auth, mqReq.payload)
+                                        prep["message"] = await this.encryptMessage({
+                                            message: {
+                                                ...result,
+                                                ...(auth.hasCode("REFRESH_SESSION") && auth.result.data)
+                                            },
+                                            token: token,
+                                            userAgent: userAgent
+                                        })
+                                    }
+                                }
 
+                        /* Without Auth */
+                                else{
+                                    const result = await main.default[functName](false, mqReq.payload)
+                                    prep["message"] = await this.encryptMessage({
+                                        message: result,
+                                        ...(mqHeader.auth && { token: mqHeader.auth.token }),
+                                        ...(mqHeader.auth && { userAgent: mqHeader.auth.userAgent })
+                                    })
+                                }
                         if(mqReq.trip == "returning"){
-                            channel.sendToQueue(message.properties.replyTo, Buffer.from(JSON.stringify(result)), {
+                            channel.sendToQueue(message.properties.replyTo, Buffer.from(prep.message), {
                                 correlationId: message.properties.correlationId
                             })
                             channel.ack(message)
@@ -69,91 +132,187 @@ export default {
             // connection.close()
         })
     },
-    publish: ({topic, userName, trip = "passby", data})=>{
+    publish: function({topic, auth=null, trip="passby", data}){
         /* Usage */
         // publish({
         //     topic: <topic start at svc :String>,
-        //     userName: <userName or guest :String>,
+        //     auth:{
+        //         token: <auth token :String>,
+        //         userAgent: <ua string :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
+        // ex: req/cd6f01UjkB7E/rolling-tempat-duduk/class/getAll
+        // ex: res/cd6f01UjkB7E/rolling-tempat-duduk/class/getAll
         
         return new Promise(async (resolve, reject)=>{
             /* RabbitMQ Engine */
-            amqp.connect(pseudoEnv.process.env.RABBIT_HOST, (error0, connection)=>{
+            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
-                })
+                        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())
+                        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
+                            }
+                        }
+                /* Main publisher */
+                        const mqReq = await this.encryptMessage({
+                            message: prep.message,
+                            ...(auth && { token: auth.token }),
+                            ...(auth && { userAgent: auth.userAgent })
+                        })
 
-                        if(message.properties.correlationId == prep.message.senderAddress){
-                            resolve(mqRes)
-                            channel.ack(message)
+                        channel.assertQueue(prep.topic, { durable: true })
+                        channel.sendToQueue(prep.topic, Buffer.from(mqReq), {
+                            ...(trip == "returning" && { correlationId: prep.message.senderAddress }),
+                            ...(trip == "returning" && { replyTo: `res/${topic}` }),
+                            ...(auth && { headers:{auth: auth} })
+                        })
+
+                /* 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){
+                                    resolve(mqRes)
+                                    channel.ack(message)
+                                    setTimeout(()=>{
+                                        connection.close()
+                                    }, 500)
+                                }
+                            }, {
+                                noAck: false
+                            })
+                        }
+                        else if(trip == "passby"){
+                            resolve("sent")
+                            
                             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()
             })
         })
     },
+    encryptMessage: function({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 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}`) 
+                        await redis.quit()
+                        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(nullCleanser(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(nullCleanser(message)), "utf-8", "base64")
+                        encrypted += cipher.final("base64")
+                        return resolve(encrypted)
+                    }
+        })
+    },
+    decryptMessage: function({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 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}`) 
+                        await redis.quit()
+                        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(nullCleanser(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(nullCleanser(JSON.parse(decrypted)))
+                    }
+        })
+    },
+    verifyToken: function({token, userAgent}){
+        const response = new ResponseCode()
+        return new Promise(async (resolve, reject)=>{
+            try{                
+                await this.publish({
+                    topic: "authentor/session/svVerifyToken",
+                    trip: "returning",
+                    auth:{
+                        token: token,
+                        userAgent: userAgent,
+                    },
+                    data:{
+                        token: token,
+                        userAgent: userAgent
+                    }
+                })
+                .then(apiRes=>{
+                    response.createNew(apiRes)
+                    throw "abort"
+                })
+            }
+            catch(something){
+                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`})
+                }
+
+                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")
+        })
+        .then(json=> JSON.parse(json))
+        .then(circular=> circular.user)
+        .result // { userId, userName, displayName }
+    },
 }