@orion-js/echoes 3.12.0 → 3.13.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Orionjs Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/config.d.ts

@@ -0,0 +1,3 @@
+import { EchoesConfigHandler } from './types';
+declare const config: EchoesConfigHandler;
+export default config;

package/lib/config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {};
+exports.default = config;

package/lib/echo/deserialize.d.ts

@@ -0,0 +1 @@
+export default function (serializedJavascript: string): any;

package/lib/echo/deserialize.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(serializedJavascript) {
+    try {
+        return eval('(' + serializedJavascript + ')');
+    }
+    catch (error) {
+        throw new Error('Error deserializing echo message');
+    }
+}
+exports.default = default_1;

package/lib/echo/index.d.ts

@@ -0,0 +1,9 @@
+import { EchoType, EchoConfig } from '../types';
+declare const echo: {
+    (options: EchoConfig): EchoType;
+    types: {
+        event: string;
+        request: string;
+    };
+};
+export default echo;

package/lib/echo/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deserialize_1 = __importDefault(require("./deserialize"));
+const types_1 = __importDefault(require("./types"));
+const echo = function createNewEcho(options) {
+    return {
+        ...options,
+        onMessage: async (messageData) => {
+            const { message } = messageData;
+            const data = (0, deserialize_1.default)(message.value.toString());
+            const context = {
+                ...messageData,
+                data
+            };
+            await options.resolve(data.params || {}, context);
+        },
+        onRequest: async (serializedParams) => {
+            const context = {};
+            const params = (0, deserialize_1.default)(serializedParams);
+            const result = await options.resolve(params || {}, context);
+            return result;
+        }
+    };
+};
+echo.types = types_1.default;
+exports.default = echo;

package/lib/echo/types.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    event: string;
+    request: string;
+};
+export default _default;

package/lib/echo/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    event: 'event',
+    request: 'request'
+};

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import startService, { stopService } from './startService';
+import publish from './publish';
+import echo from './echo';
+import request from './request';
+export * from './types';
+export * from './service';
+export { publish, startService, stopService, echo, request };

package/lib/index.js

@@ -0,0 +1,43 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.request = exports.echo = exports.stopService = exports.startService = exports.publish = void 0;
+const startService_1 = __importStar(require("./startService"));
+exports.startService = startService_1.default;
+Object.defineProperty(exports, "stopService", { enumerable: true, get: function () { return startService_1.stopService; } });
+const publish_1 = __importDefault(require("./publish"));
+exports.publish = publish_1.default;
+const echo_1 = __importDefault(require("./echo"));
+exports.echo = echo_1.default;
+const request_1 = __importDefault(require("./request"));
+exports.request = request_1.default;
+__exportStar(require("./types"), exports);
+__exportStar(require("./service"), exports);

package/lib/publish/index.d.ts

@@ -0,0 +1,5 @@
+import { PublishOptions } from '../types';
+/**
+ * Publish
+ */
+export default function publish<TParams = any>(options: PublishOptions<TParams>): Promise<import("kafkajs").RecordMetadata[]>;

package/lib/publish/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../config"));
+const serialize_1 = __importDefault(require("./serialize"));
+/**
+ * Publish
+ */
+async function publish(options) {
+    if (!config_1.default.producer) {
+        throw new Error('You must initialize echoes configruation to use publish');
+    }
+    const payload = {
+        params: options.params,
+    };
+    return await config_1.default.producer.send({
+        acks: options.acks,
+        timeout: options.timeout,
+        topic: options.topic,
+        messages: [
+            {
+                value: (0, serialize_1.default)(payload),
+            },
+        ],
+    });
+}
+exports.default = publish;

package/lib/publish/serialize.d.ts

@@ -0,0 +1 @@
+export default function (data: any): string;

package/lib/publish/serialize.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+function default_1(data) {
+    const cloned = (0, cloneDeep_1.default)(data);
+    const serialized = (0, serialize_javascript_1.default)(cloned, { ignoreFunction: true });
+    return serialized;
+}
+exports.default = default_1;

package/lib/request/getPassword.d.ts

@@ -0,0 +1 @@
+export declare function getEchoesPassword(): string;

package/lib/request/getPassword.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEchoesPassword = void 0;
+const config_1 = __importDefault(require("../config"));
+const env_1 = require("@orion-js/env");
+function getEchoesPassword() {
+    const secret = config_1.default?.requests?.key || (0, env_1.internalGetEnv)('echoes_password', 'ECHOES_PASSWORD');
+    if (!secret) {
+        console.warn('Warning: no secret key found for echoes requests. Init echoes or set the env var "echoes_password" or process.env.ECHOES_PASSWORD');
+    }
+    return secret;
+}
+exports.getEchoesPassword = getEchoesPassword;

package/lib/request/getSignature.d.ts

@@ -0,0 +1 @@
+export default function (body: any): string;

package/lib/request/getSignature.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jssha_1 = __importDefault(require("jssha"));
+const getPassword_1 = require("./getPassword");
+function default_1(body) {
+    const password = (0, getPassword_1.getEchoesPassword)();
+    const shaObj = new jssha_1.default('SHA-1', 'TEXT');
+    shaObj.setHMACKey(password, 'TEXT');
+    shaObj.update(body);
+    return shaObj.getHMAC('HEX');
+}
+exports.default = default_1;

package/lib/request/getURL.d.ts

@@ -0,0 +1 @@
+export default function (serviceName: string): string;

package/lib/request/getURL.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../config"));
+function default_1(serviceName) {
+    if (serviceName.startsWith('http'))
+        return serviceName;
+    const url = config_1.default?.requests?.services[serviceName];
+    if (!url) {
+        throw new Error(`No URL found in echoes config for service ${serviceName}`);
+    }
+    return url;
+}
+exports.default = default_1;

package/lib/request/index.d.ts

@@ -0,0 +1,2 @@
+import type { RequestOptions } from '../types';
+export default function request<TData = any, TParams = any>(options: RequestOptions<TParams>): Promise<TData>;

package/lib/request/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getURL_1 = __importDefault(require("./getURL"));
+const getSignature_1 = __importDefault(require("./getSignature"));
+const serialize_1 = __importDefault(require("../publish/serialize"));
+const deserialize_1 = __importDefault(require("../echo/deserialize"));
+const config_1 = __importDefault(require("../config"));
+const makeRequest_1 = require("./makeRequest");
+const schema_1 = require("@orion-js/schema");
+const helpers_1 = require("@orion-js/helpers");
+async function request(options) {
+    const { method, service, params } = options;
+    const serializedParams = (0, serialize_1.default)(params);
+    const date = new Date();
+    const body = { method, service, serializedParams, date };
+    const signature = (0, getSignature_1.default)(body);
+    try {
+        const requestMaker = config_1.default?.requests?.makeRequest || makeRequest_1.makeRequest;
+        const requestOptions = {
+            url: (0, getURL_1.default)(service),
+            retries: options.retries,
+            timeout: options.timeout,
+            data: {
+                body,
+                signature,
+            },
+        };
+        const result = await requestMaker(requestOptions);
+        if (result.statusCode !== 200) {
+            throw new Error(`Wrong status code ${result.statusCode}`);
+        }
+        const data = result.data;
+        if (data.error) {
+            const info = data.errorInfo;
+            if (info) {
+                if (data.isValidationError) {
+                    throw new schema_1.ValidationError(info.validationErrors);
+                }
+                if (data.isUserError) {
+                    throw new helpers_1.UserError(info.error, info.message, info.extra);
+                }
+            }
+            throw new Error(`${data.error}`);
+        }
+        const response = (0, deserialize_1.default)(data.result);
+        return response;
+    }
+    catch (error) {
+        if (error.isOrionError)
+            throw error;
+        throw new Error(`Echoes request network error calling ${service}/${method}: ${error.message}`);
+    }
+}
+exports.default = request;

package/lib/request/makeRequest.d.ts

@@ -0,0 +1,2 @@
+import { RequestMaker } from '../types';
+export declare const makeRequest: RequestMaker;

package/lib/request/makeRequest.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRequest = void 0;
+const axios_1 = __importDefault(require("axios"));
+const helpers_1 = require("@orion-js/helpers");
+const makeRequest = async (options) => {
+    const result = await (0, helpers_1.executeWithRetries)(async () => {
+        return await (0, axios_1.default)({
+            method: 'post',
+            url: options.url,
+            timeout: options.timeout,
+            headers: {
+                'User-Agent': 'Orionjs-Echoes/1.1'
+            },
+            data: options.data
+        });
+    }, options.retries, 200);
+    return {
+        data: result.data,
+        statusCode: result.status
+    };
+};
+exports.makeRequest = makeRequest;

package/lib/requestsHandler/checkSignature.d.ts

@@ -0,0 +1 @@
+export default function (body: any, signature: string): void;

package/lib/requestsHandler/checkSignature.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getSignature_1 = __importDefault(require("../request/getSignature"));
+function default_1(body, signature) {
+    const generatedSignature = (0, getSignature_1.default)(body);
+    if (generatedSignature !== signature) {
+        throw new Error('Echoes invalid signature');
+    }
+}
+exports.default = default_1;

package/lib/requestsHandler/getEcho.d.ts

@@ -0,0 +1 @@
+export default function (method: string): import("..").EchoType;

package/lib/requestsHandler/getEcho.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../config"));
+const types_1 = __importDefault(require("../echo/types"));
+function default_1(method) {
+    const echo = config_1.default.echoes[method];
+    if (!echo) {
+        throw new Error(`Echo named ${method} not found in this service`);
+    }
+    if (echo.type !== types_1.default.request) {
+        throw new Error(`Echo named ${method} is not of type request`);
+    }
+    return echo;
+}
+exports.default = default_1;

package/lib/requestsHandler/index.d.ts

@@ -0,0 +1,3 @@
+import { EchoesOptions } from '../types';
+declare const _default: (options: EchoesOptions) => import("@orion-js/http").RouteType;
+export default _default;

package/lib/requestsHandler/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getEcho_1 = __importDefault(require("./getEcho"));
+const serialize_1 = __importDefault(require("../publish/serialize"));
+const checkSignature_1 = __importDefault(require("./checkSignature"));
+const http_1 = require("@orion-js/http");
+exports.default = (options) => (0, http_1.route)({
+    method: 'post',
+    path: options.requests.handlerPath || '/echoes-services',
+    bodyParser: 'json',
+    bodyParserOptions: {
+        limit: '10mb',
+    },
+    async resolve(req) {
+        try {
+            const { body, signature } = req.body;
+            (0, checkSignature_1.default)(body, signature);
+            const { method, serializedParams } = body;
+            const echo = (0, getEcho_1.default)(method);
+            const result = await echo.onRequest(serializedParams);
+            return {
+                body: {
+                    result: (0, serialize_1.default)(result),
+                },
+            };
+        }
+        catch (error) {
+            if (!error.getInfo) {
+                console.error('Error at echo requests handler:', error);
+            }
+            return {
+                body: {
+                    error: error.message,
+                    errorInfo: error.getInfo ? error.getInfo() : null,
+                    isValidationError: !!error.isValidationError,
+                    isUserError: !!error.isUserError,
+                },
+            };
+        }
+    },
+});

package/lib/service/index.d.ts

@@ -0,0 +1,8 @@
+import { EchoConfig, EchoesMap } from '../types';
+export declare function Echoes(): ClassDecorator;
+export interface EchoesPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: EchoConfig['resolve'];
+}
+export declare function EchoRequest(options?: Omit<EchoConfig, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: EchoesPropertyDescriptor) => void;
+export declare function EchoEvent(options?: Omit<EchoConfig, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: EchoesPropertyDescriptor) => void;
+export declare function getServiceEchoes(target: any): EchoesMap;

package/lib/service/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceEchoes = exports.EchoEvent = exports.EchoRequest = exports.Echoes = void 0;
+const services_1 = require("@orion-js/services");
+const echo_1 = __importDefault(require("../echo"));
+function Echoes() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+exports.Echoes = Echoes;
+function EchoRequest(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, echo_1.default)({
+            ...options,
+            type: 'request',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.EchoRequest = EchoRequest;
+function EchoEvent(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, echo_1.default)({
+            ...options,
+            type: 'event',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+exports.EchoEvent = EchoEvent;
+function getServiceEchoes(target) {
+    if (!target.prototype) {
+        throw new Error('You must pass a class to getServiceRoutes');
+    }
+    return target.prototype.echoes || {};
+}
+exports.getServiceEchoes = getServiceEchoes;

package/lib/service/index.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/service/index.test.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const _1 = require(".");
+describe('Echoes with service injections', () => {
+    it('Should define a echoes map using services', async () => {
+        let ExampleEchoesService = class ExampleEchoesService {
+            async echo() {
+                return 1;
+            }
+            async echoEvent() {
+                return 2;
+            }
+        };
+        __decorate([
+            (0, _1.EchoRequest)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleEchoesService.prototype, "echo", null);
+        __decorate([
+            (0, _1.EchoEvent)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleEchoesService.prototype, "echoEvent", null);
+        ExampleEchoesService = __decorate([
+            (0, _1.Echoes)()
+        ], ExampleEchoesService);
+        const echoes = (0, _1.getServiceEchoes)(ExampleEchoesService);
+        expect(echoes).toMatchObject({
+            echo: {
+                type: 'request',
+                onRequest: expect.any(Function)
+            },
+            echoEvent: {
+                type: 'event',
+                resolve: expect.any(Function)
+            }
+        });
+    });
+});

package/lib/startService/KafkaManager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { Kafka, EachMessagePayload, Producer, Consumer } from 'kafkajs';
+import { EchoesOptions, EchoType } from '../types';
+/**
+ * Manages the Kafka connection and the consumers.
+ */
+declare class KafkaManager {
+    kafka: Kafka;
+    options: EchoesOptions;
+    producer: Producer;
+    consumer: Consumer;
+    topics: string[];
+    started: boolean;
+    interval: NodeJS.Timeout;
+    constructor(options: EchoesOptions);
+    checkJoinConsumerGroupConditions(): Promise<boolean>;
+    joinConsumerGroup(): Promise<void>;
+    conditionalStart(): Promise<boolean>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(params: EachMessagePayload): Promise<void>;
+    handleRetries(echo: EchoType, params: EachMessagePayload, error: Error): Promise<void>;
+}
+export default KafkaManager;