rpc-mq 1.0.0

package/client.d.ts

@@ -0,0 +1,23 @@
+import type { ChannelModel, RPCClient } from './types';
+type Client = {
+    name: string;
+    uuid?: string;
+    secretKey?: string;
+};
+type MetaData = {
+    client: Client;
+} & Record<string, any>;
+type RPCClientProps = {
+    connection: ChannelModel;
+    metadata?: MetaData;
+    metadataInterceptor?: CallableFunction;
+};
+/**
+ * Initialize the rpc client and ready to be called to call
+ * server procedure
+ * @param {string} service - rpc server name to call to
+ * @param {MessageQueue} props - The Message Queue connection configuration
+ * @return {makeRequest} callback - The make request callback
+ */
+export default function initRpcClient(service: string, props: RPCClientProps): RPCClient;
+export {};

package/client.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = initRpcClient;
+/* eslint-disable no-console */
+const crypto_1 = require("crypto");
+const decodeResult = (content) => {
+    const { result } = JSON.parse(content);
+    return result;
+};
+const getMetadata = (props) => {
+    const { metadata, ...restProps } = props;
+    const withMetadata = metadata || false;
+    try {
+        if (!withMetadata)
+            return Promise.resolve({});
+        const isFun = typeof metadata === 'function';
+        const result = isFun
+            ? metadata(restProps)
+            : metadata;
+        const isPromise = result instanceof Promise;
+        if (isPromise)
+            return result.then((pResult) => pResult);
+        return Promise.resolve(result);
+    }
+    catch (error) {
+        const { message } = error;
+        return Promise.reject({ ...error, message });
+    }
+};
+const closeChannel = (channel) => {
+    const channelInitialized = channel || false;
+    if (!channelInitialized)
+        return false;
+    channel.close();
+    return true;
+};
+const waitForResponse = (props) => {
+    const { channel, resolve, reject, queue, service, correlationId } = props;
+    let hasReceived = false;
+    channel.consume(queue.queue, (message) => {
+        if (message.properties.correlationId === correlationId) {
+            hasReceived = true;
+            const result = decodeResult(message.content.toString());
+            try {
+                if (!(result || false))
+                    return resolve(result);
+                const { error = false } = result;
+                if (error)
+                    return reject(result);
+                return resolve(result);
+            }
+            catch {
+                return resolve(result);
+            }
+            finally {
+                closeChannel(channel);
+            }
+        }
+    }, { noAck: true });
+    setTimeout(() => {
+        if (!hasReceived) {
+            closeChannel(channel);
+            reject(new Error(`- [rpc-client] Request to ${service} timeout`));
+        }
+    }, 1000 * 5);
+};
+const consume = (props, procedure, ...params) => {
+    const { channel, queue, service, metadata, metadataInterceptor } = props;
+    const correlationId = (0, crypto_1.randomUUID)();
+    return new Promise((resolve, reject) => {
+        const metadataProps = { metadata, service, procedure, params };
+        getMetadata(metadataProps)
+            .then((cleanMetadata) => {
+            const intercepted = metadataInterceptor || false;
+            if (!intercepted)
+                return cleanMetadata;
+            return metadataInterceptor(cleanMetadata);
+        })
+            .then((metadataData) => {
+            waitForResponse({
+                channel, resolve, reject,
+                queue, service, correlationId,
+            });
+            const metadata = { ...metadataData, correlationId };
+            const data = JSON.stringify({ procedure, params, metadata });
+            channel.sendToQueue(service, Buffer.from(data), {
+                correlationId,
+                replyTo: queue.queue,
+            });
+        })
+            .catch((error) => {
+            closeChannel(channel);
+            const { message } = error;
+            reject({ message, code: 'UNKNOWN_ERROR', status: 400, ...error });
+        });
+    });
+};
+const initRequest = (props, procedure, ...params) => {
+    const { connection, service, metadata, metadataInterceptor } = props;
+    return connection.createChannel()
+        .then((channel) => {
+        console.log('[RPC Client] Channel is created.');
+        return channel
+            .assertQueue('', {
+            exclusive: true,
+            autoDelete: true,
+        })
+            .then((queue) => {
+            const consumeProps = { channel, service, queue, metadata, metadataInterceptor };
+            return consume(consumeProps, procedure, ...params);
+        });
+    });
+};
+/**
+ * Initialize the rpc client and ready to be called to call
+ * server procedure
+ * @param {string} service - rpc server name to call to
+ * @param {MessageQueue} props - The Message Queue connection configuration
+ * @return {makeRequest} callback - The make request callback
+ */
+function initRpcClient(service, props) {
+    const { connection, metadata, metadataInterceptor } = props;
+    return (procedure, ...params) => {
+        const reqProps = { connection, service, metadata, metadataInterceptor };
+        return initRequest(reqProps, procedure, ...params);
+    };
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export { default as client } from './client';
+export { default as server } from './server';
+export * from './types';

package/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.server = exports.client = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "client", { enumerable: true, get: function () { return __importDefault(client_1).default; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "server", { enumerable: true, get: function () { return __importDefault(server_1).default; } });
+__exportStar(require("./types"), exports);

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "rpc-mq",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc --build",
+    "test": "jest --roots=./__test__",
+    "start:dev": "tsc --build -f ./tsconfig.json -w",
+    "test:dev": "npm run test -- --watchAll",
+    "dev": "npm run build -- -w",
+    "jsdoc": "npm run build && jsdoc build/**/* -d jsdoc",
+    "eslint": "eslint src --ext .ts"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/server/handler.d.ts

@@ -0,0 +1,3 @@
+type Handlers = Record<string, CallableFunction>;
+export default function getHandler(handlers: Handlers | any, props: any): Handlers;
+export {};

package/server/handler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getHandler;
+let singleton;
+function getHandler(handlers, props) {
+    if (singleton || false)
+        return singleton;
+    /* eslint-disable-next-line no-console */
+    console.log('[INFO] Registering RPC handlers...');
+    const isFunction = handlers instanceof Function;
+    if (!isFunction) {
+        singleton = handlers;
+        return singleton;
+    }
+    singleton = handlers(props);
+    return singleton;
+}

package/server/index.d.ts

@@ -0,0 +1,32 @@
+import type { ChannelModel } from 'amqplib';
+import { type Channel } from '../types';
+import { type Middleware } from './middleware';
+import type { CallProps } from './type';
+type ConsumeProps = {
+    channel: Channel;
+    queueName: string;
+    handlers: any;
+    middlewares?: any;
+};
+/**
+ * Starts consuming the message queue. This just
+ * consumes on specific queueue (queueName)
+ * @param {ConsumeProps} props - Consuming properties
+ * @return Proise
+ */
+export declare const startConsuming: (props: ConsumeProps) => Promise<import("amqplib").Replies.Consume>;
+type RPCServer = {
+    middlewares?: Middleware[];
+    connection: ChannelModel;
+    logger?: any;
+};
+type Handler = Record<string, CallableFunction>;
+type HandlerWrapper = (_props: CallProps) => Handler;
+/**
+ * Starts the Consumer of RabbitMQ
+ * @param {string} service - String to rpc server name
+ * @param {Record<string, unknown>} exposedServices - The exposed functions to be called
+ * @param {MessageQueue} config - The message queue connection configuration
+ */
+export default function startRpcServer(service: string, exposedServices: Handler | HandlerWrapper, props: RPCServer): Promise<import("amqplib").Replies.Consume>;
+export {};

package/server/index.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startConsuming = void 0;
+exports.default = startRpcServer;
+const middleware_1 = __importDefault(require("./middleware"));
+const storage_1 = __importDefault(require("../storage"));
+const logger_1 = __importDefault(require("./logger"));
+const handler_1 = __importDefault(require("./handler"));
+let loggerPrv;
+/**
+ * Tries to execute the requested function
+ * and returns the value back to the client.
+ * @param {callback} handler - Callback function of the called function
+ * @param {any[]} params - Function parameters
+ * @return any | error
+ */
+const execute = (handler, params) => {
+    try {
+        const result = handler(...params);
+        const isPromise = result instanceof Promise;
+        if (isPromise)
+            return result;
+        return Promise.resolve(result);
+    }
+    catch (error) {
+        const { message } = error;
+        return Promise.resolve({ ...error, error: true, message });
+    }
+};
+const sendResponse = (props, result) => {
+    const { channel, properties, metadata, params, procedure } = props;
+    const loggerProps = { result, metadata, params, procedure };
+    (0, logger_1.default)(loggerPrv, loggerProps);
+    channel.sendToQueue(properties.replyTo, Buffer.from(JSON.stringify({ result })), { correlationId: properties.correlationId });
+};
+const sendErrorResponse = (props, errorRes) => sendResponse(props, errorRes);
+/**
+ * Starts consuming the message queue. This just
+ * consumes on specific queueue (queueName)
+ * @param {ConsumeProps} props - Consuming properties
+ * @return Proise
+ */
+const startConsuming = (props) => {
+    const { channel, queueName, handlers: pHandlers, middlewares = [] } = props;
+    return channel.consume(queueName, (message) => {
+        const { procedure, params, metadata: resHeaders } = JSON.parse(message.content.toString());
+        const { properties } = message;
+        const metadata = (0, storage_1.default)(resHeaders);
+        const handlers = (0, handler_1.default)(pHandlers, { metadata });
+        const handler = handlers[procedure] || false;
+        const resProps = { channel, metadata, params, procedure, properties };
+        if (!handler) {
+            const notFoundMsg = {
+                error: true,
+                status: 404,
+                message: `Function/Procedure [${procedure}] does not exist`,
+                code: 'PROCEDURE_NOT_FOUND',
+            };
+            sendErrorResponse(resProps, notFoundMsg);
+            channel.ack(message);
+            return true;
+        }
+        return (0, middleware_1.default)(middlewares, { procedure, params, metadata })
+            .then(() => execute(handler, params))
+            .then((promiseResult) => sendResponse(resProps, promiseResult))
+            .catch((error) => {
+            const errorMsg = {
+                error: true,
+                message: error.message,
+                status: error.status || 400,
+                code: error.code || 'UNKNOWN_ERROR',
+            };
+            return sendErrorResponse(resProps, errorMsg);
+        })
+            .finally(() => {
+            channel.ack(message);
+        });
+    });
+};
+exports.startConsuming = startConsuming;
+/**
+ * Starts the Consumer of RabbitMQ
+ * @param {string} service - String to rpc server name
+ * @param {Record<string, unknown>} exposedServices - The exposed functions to be called
+ * @param {MessageQueue} config - The message queue connection configuration
+ */
+function startRpcServer(service, exposedServices, props) {
+    const { connection, middlewares, logger } = props;
+    loggerPrv = logger || false;
+    return connection.createChannel()
+        .then((channel) => {
+        channel.assertQueue(service, { durable: false });
+        channel.prefetch(1);
+        return (0, exports.startConsuming)({
+            channel,
+            middlewares,
+            queueName: service,
+            handlers: exposedServices,
+        });
+    });
+}

package/server/logger.d.ts

@@ -0,0 +1 @@
+export default function loggerCallback(logger: any, props: any): boolean;

package/server/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+/* esltin-disable console.log */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loggerCallback;
+const encode = (params) => {
+    const content = JSON.stringify(params || []);
+    return Buffer.from(content).toString('base64');
+};
+function writeLog(props) {
+    return new Promise((resolve) => {
+        const { procedure, metadata, result } = props;
+        const { client = {}, correlationId } = metadata.get();
+        const info = [
+            '[REQUEST-LOG]',
+            `[${(((result === null || result === void 0 ? void 0 : result.error) || false) ? 'FAILED' : 'SUCCESS')}]`,
+            procedure,
+            `client/${client.name || 'N/A'}`,
+            `correlation/${correlationId}`,
+        ];
+        /* eslint-disable-next-line no-console */
+        console.log(info.join(' '));
+        resolve(true);
+    });
+}
+function loggerCallback(logger, props) {
+    const { result, params, procedure, metadata } = props;
+    writeLog({ procedure, metadata, result });
+    const hasLogger = logger || false;
+    if (!hasLogger)
+        return false;
+    const { correlationId, client = {} } = metadata.get();
+    const encodedParams = encode(params);
+    const logInfo = {
+        error: (result === null || result === void 0 ? void 0 : result.error) || false,
+        procedure,
+        params: encodedParams,
+        correlation: correlationId,
+        client: client.name || 'N/A',
+    };
+    logger().log(logInfo, { severity: 'request-log' });
+    return true;
+}

package/server/middleware.d.ts

@@ -0,0 +1,10 @@
+import type { Storage } from '../storage';
+import type { CallProps } from './type';
+export type Middleware = (_props: CallProps) => any | void;
+type MiddlewaresExecutor = {
+    procedure: string;
+    params: any;
+    metadata: Storage;
+};
+export default function executeMiddlewares(middlewares: Middleware[] | undefined, props: MiddlewaresExecutor): any;
+export {};

package/server/middleware.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = executeMiddlewares;
+function executeHell(callbacks, props) {
+    if (callbacks.length === 0)
+        return {};
+    const [callback, ...rest] = callbacks;
+    const isPromise = callback instanceof Promise;
+    const handler = isPromise
+        ? callback(props)
+        : Promise.resolve(callback(props));
+    return handler
+        .then((result = {}) => {
+        if (rest.length === 0)
+            return result;
+        return executeHell(rest, props);
+    });
+}
+function initializerMiddleware() {
+    return Promise.resolve(true);
+}
+function executeMiddlewares(middlewares = [], props) {
+    const { procedure, params, metadata } = props;
+    if (middlewares.length == 0)
+        return Promise.resolve({});
+    return executeHell([initializerMiddleware, ...middlewares], { procedure, params, metadata });
+}

package/server/type.d.ts

@@ -0,0 +1,14 @@
+import type { Storage } from '../storage';
+export type CallProps = {
+    metadata: Storage;
+};
+export type ErrorResponse = {
+    error: boolean;
+    status: number;
+    message: string;
+    code: string;
+};
+export type Response = {
+    error: false;
+    status: 200;
+};

package/server/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/storage.d.ts

@@ -0,0 +1,9 @@
+type StorageValue = Record<string, any>;
+export type Storage = {
+    set: CallableFunction;
+    get: CallableFunction;
+    setItem: CallableFunction;
+    removeItem: CallableFunction;
+};
+export default function headers(value?: StorageValue): Storage;
+export {};

package/storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = headers;
+function headers(value = {}) {
+    let singleton = value;
+    return {
+        set: (value) => {
+            singleton = { ...singleton, ...value };
+            return singleton;
+        },
+        get: (key = false, fallbackVal = undefined) => {
+            if (!key)
+                return singleton;
+            return (singleton[key.toString()] || fallbackVal);
+        },
+        setItem: (key, value) => {
+            singleton = { ...singleton, [key]: value };
+            return singleton;
+        },
+        removeItem: (key) => {
+            delete singleton[key];
+            return singleton;
+        },
+    };
+}

package/types.d.ts

@@ -0,0 +1,9 @@
+export type MessageQueue = {
+    host: string;
+    port: string | number;
+    user: string;
+    password: string;
+    retryInterval?: number;
+};
+export type RPCClient = (procedureName: string, ...params: any[]) => Promise<any>;
+export { ChannelModel, Channel, } from 'amqplib';

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils.d.ts

@@ -0,0 +1 @@
+export declare function getValue(value: any, props: unknown): Promise<any>;

package/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValue = getValue;
+function getValue(value, props) {
+    const callback = (typeof value === 'function')
+        ? value(props)
+        : value;
+    const isPromise = callback instanceof Promise;
+    if (!isPromise)
+        return Promise.resolve(callback);
+    return callback;
+}