@orion-js/echoes 3.8.0 → 3.9.0

package/lib/request/index.d.ts

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

package/lib/request/index.js

@@ -9,6 +9,8 @@ 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);
@@ -23,21 +25,32 @@ async function request(options) {
             timeout: options.timeout,
             data: {
                 body,
-                signature
-            }
+                signature,
+            },
         };
         const result = await requestMaker(requestOptions);
         if (result.statusCode !== 200) {
-            throw new Error(`Echoes request network error calling ${service}/${method}: Wrong status code ${result.statusCode}`);
+            throw new Error(`Wrong status code ${result.statusCode}`);
         }
         const data = result.data;
         if (data.error) {
-            throw new Error(`Echoes request error calling ${service}/${method}: ${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}`);
     }
 }

package/lib/requestsHandler/index.js

@@ -20,17 +20,22 @@ exports.default = (options) => (0, http_1.route)({
             const result = await echo.onRequest(serializedParams);
             return {
                 body: {
-                    result: (0, serialize_1.default)(result)
-                }
+                    result: (0, serialize_1.default)(result),
+                },
             };
         }
         catch (error) {
-            console.error('Error at echo requests handler:', error);
+            if (!error.getInfo) {
+                console.error('Error at echo requests handler:', error);
+            }
             return {
                 body: {
-                    error: error.message
-                }
+                    error: error.message,
+                    errorInfo: error.getInfo ? error.getInfo() : null,
+                    isValidationError: !!error.isValidationError,
+                    isUserError: !!error.isUserError,
+                },
             };
         }
-    }
+    },
 });

package/lib/tests/requests/index.test.js

@@ -6,28 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("../..");
 const supertest_1 = __importDefault(require("supertest"));
 const http_1 = require("@orion-js/http");
+const schema_1 = require("@orion-js/schema");
 describe('Test echoes requests', () => {
     const makeRequest = async (options) => {
         const app = (0, http_1.getApp)();
         const response = await (0, supertest_1.default)(app).post('/echoes-services').send(options.data);
         return {
             statusCode: response.statusCode,
-            data: response.body
+            data: response.body,
         };
     };
     it('Should start echoes requests service', () => {
         const echoes = {
             test: (0, __1.echo)({
                 type: 'request',
-                async resolve() { }
-            })
+                async resolve() { },
+            }),
         };
         (0, __1.startService)({
             echoes,
             requests: {
                 key: 'secret',
-                services: {}
-            }
+                services: {},
+            },
         });
     });
     it('Should be able to make a echoes request passing dates as params', async () => {
@@ -40,18 +41,18 @@ describe('Test echoes requests', () => {
                     expect(params.date).toBeInstanceOf(Date);
                     return {
                         text: 'Hello world',
-                        date: params.date
+                        date: params.date,
                     };
-                }
-            })
+                },
+            }),
         };
         (0, __1.startService)({
             echoes,
             requests: {
                 key: 'secret',
                 services: { test: 'mockURL' },
-                makeRequest
-            }
+                makeRequest,
+            },
         });
         const date = new Date();
         const result = await (0, __1.request)({
@@ -59,11 +60,40 @@ describe('Test echoes requests', () => {
             service: 'test',
             params: {
                 hello: 'world',
-                date
-            }
+                date,
+            },
         });
         expect(result.text).toBe('Hello world');
         expect(result.date).toBeInstanceOf(Date);
         expect(result.date.getTime()).toBe(date.getTime());
     });
+    it('should pass errors to Orion errors', async () => {
+        const echoes = {
+            test: (0, __1.echo)({
+                type: 'request',
+                async resolve() {
+                    throw new schema_1.ValidationError({ hello: 'world' });
+                },
+            }),
+        };
+        (0, __1.startService)({
+            echoes,
+            requests: {
+                key: 'secret',
+                services: { test: 'mockURL' },
+                makeRequest,
+            },
+        });
+        expect.assertions(1);
+        try {
+            await (0, __1.request)({
+                method: 'test',
+                service: 'test',
+                params: {},
+            });
+        }
+        catch (error) {
+            expect(error.validationErrors).toEqual({ hello: 'world' });
+        }
+    });
 });

package/lib/types.d.ts

@@ -23,6 +23,14 @@ export interface RequestOptions<TParams> {
 export interface RequestHandlerResponse {
     result?: any;
     error?: any;
+    isUserError?: boolean;
+    isValidationError?: boolean;
+    errorInfo?: {
+        error: string;
+        message: string;
+        extra?: any;
+        validationErrors?: any;
+    };
 }
 export interface MakeRequestParams {
     url: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/echoes",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,10 +17,11 @@
     "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/env": "^3.8.0",
-    "@orion-js/helpers": "^3.7.4",
-    "@orion-js/http": "^3.8.0",
-    "@orion-js/services": "^3.7.4",
+    "@orion-js/env": "^3.9.0",
+    "@orion-js/helpers": "^3.9.0",
+    "@orion-js/http": "^3.9.0",
+    "@orion-js/schema": "^3.9.0",
+    "@orion-js/services": "^3.9.0",
     "axios": "^0.24.0",
     "jssha": "^3.2.0",
     "kafkajs": "^1.15.0",
@@ -40,5 +41,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "05bb0f7c0679b17993a2375332804d745dd49ba2"
+  "gitHead": "23e0eda5348153dcc07b307a97b641d52eb41f39"
 }