@scvo/router-task-elasticsearch - npm Package Compare versions

Comparing version 0.0.8 to 0.0.9

dist/index.d.ts

 import { Client, SearchResponse, ConfigOptions } from 'elasticsearch';
-import { IRouterTask, IRouteMatch } from '@scvo/router';
+import { IRouterTask, IRouteMatch, IRouteTask } from '@scvo/router';
 export declare class ElasticsearchRouterTask implements IRouterTask {
     name: string;
     constructor(handlebarsHelpers: IHandlebarsHelpers);
-    execute(routeMatch: IRouteMatch, config: IElasticsearchTaskConfig): Promise<any>;
-    singleQuery(client: Client, queryTemplate: IElasticsearchQueryTemplate, routeMatch: IRouteMatch): Promise<ISearchResponse<any>>;
-    multiQuery(client: Client, queryTemplates: IElasticsearchQueryTemplate[], routeMatch: IRouteMatch): Promise<ISearchResponses<any>>;
+    execute(routeMatch: IRouteMatch, task: IRouteTask<IElasticsearchTaskConfig>): Promise<any>;
+    singleQuery(client: Client, task: IRouteTask<IElasticsearchTaskConfig>, routeMatch: IRouteMatch): Promise<ISearchResponse<any>>;
+    multiQuery(client: Client, task: IRouteTask<IElasticsearchTaskConfig>, routeMatch: IRouteMatch): Promise<ISearchResponses<any>>;
     getPagination(from?: number, size?: number, totalResults?: number): IPagination;
 }
-export declare class ElasticQueryError extends Error {
-    innerError: Error;
-    data: any;
-    message: string;
-    constructor(m: string, innerError: Error, data: any);
-}
 export interface IElasticsearchTaskConfig {
@@ -28,2 +22,3 @@ connectionStringTemplate: string;
     paginationDetails?: IPaginationDetails;
+    noResultsRoute?: string;
 }
@@ -30,0 +25,0 @@ export interface IHandlebarsHelpers {

dist/index.js

 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
@@ -59,3 +49,3 @@ return new (P || (P = Promise))(function (resolve, reject) {
     }
-    ElasticsearchRouterTask.prototype.execute = function (routeMatch, config) {
+    ElasticsearchRouterTask.prototype.execute = function (routeMatch, task) {
         return __awaiter(this, void 0, void 0, function () {
@@ -67,3 +57,3 @@ var data, connectionStringCompiled, connectionString, configOptions, client;
                         data = {};
-                        connectionStringCompiled = hbs.compile(config.connectionStringTemplate);
+                        connectionStringCompiled = hbs.compile(task.config.connectionStringTemplate);
                         connectionString = connectionStringCompiled(routeMatch);
@@ -74,10 +64,10 @@ configOptions = {
                         };
-                        Object.assign(configOptions, config.elasticsearchConfig || {});
+                        Object.assign(configOptions, task.config.elasticsearchConfig || {});
                         client = new elasticsearch_1.Client(configOptions);
-                        if (!Array.isArray(config.queryTemplates)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.multiQuery(client, config.queryTemplates, routeMatch)];
+                        if (!Array.isArray(task.config.queryTemplates)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.multiQuery(client, task, routeMatch)];
                     case 1:
                         data = _a.sent();
                         return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.singleQuery(client, config.queryTemplates, routeMatch)];
+                    case 2: return [4 /*yield*/, this.singleQuery(client, task, routeMatch)];
                     case 3:
@@ -91,5 +81,5 @@ data = _a.sent();
     };
-    ElasticsearchRouterTask.prototype.singleQuery = function (client, queryTemplate, routeMatch) {
+    ElasticsearchRouterTask.prototype.singleQuery = function (client, task, routeMatch) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryCompiled, queryJson, query, queryError, queryError, queryError, payload, response, err_1, queryError, pagination, err_2, queryError;
+            var queryTemplate, queryCompiled, queryJson, query, payload, response, err_1, queryError, pagination, err_2;
             return __generator(this, function (_a) {
@@ -99,2 +89,3 @@ switch (_a.label) {
                         _a.trys.push([0, 5, , 6]);
+                        queryTemplate = task.config.queryTemplates;
                         try {
@@ -104,4 +95,10 @@ queryCompiled = hbs.compile(queryTemplate.template);
                         catch (err) {
-                            queryError = new ElasticQueryError('Failed to compile template', err, { queryTemplate: queryTemplate });
-                            throw queryError;
+                            err = new router_1.RouteTaskError(err, {
+                                statusCode: 500,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: task.errorRoute || null,
+                                data: { queryTemplate: queryTemplate }
+                            });
+                            throw err;
                         }
@@ -112,4 +109,10 @@ try {
                         catch (err) {
-                            queryError = new ElasticQueryError('Failed to render template', err, { queryTemplate: queryTemplate });
-                            throw queryError;
+                            err = new router_1.RouteTaskError(err, {
+                                statusCode: 500,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: task.errorRoute || null,
+                                data: { queryTemplate: queryTemplate }
+                            });
+                            throw err;
                         }
@@ -120,4 +123,10 @@ try {
                         catch (err) {
-                            queryError = new ElasticQueryError('Failed to parse queryJson', err, { queryTemplate: queryTemplate, queryJson: queryJson });
-                            throw queryError;
+                            err = new router_1.RouteTaskError(err, {
+                                statusCode: 500,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: task.errorRoute || null,
+                                data: { queryTemplate: queryTemplate, queryJson: queryJson }
+                            });
+                            throw err;
                         }
@@ -139,5 +148,20 @@ payload = {
                         err_1 = _a.sent();
-                        queryError = new ElasticQueryError('Failed to perform search', err_1, { payload: payload });
+                        queryError = new router_1.RouteTaskError(err_1, {
+                            statusCode: 500,
+                            sourceRoute: routeMatch,
+                            task: task,
+                            redirectTo: task.errorRoute || null,
+                            data: { payload: payload }
+                        });
                         throw queryError;
                     case 4:
+                        if (queryTemplate.noResultsRoute && response.hits.total === 0) {
+                            throw new router_1.RouteTaskError(new Error('No results'), {
+                                statusCode: 404,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: queryTemplate.noResultsRoute,
+                                data: { payload: payload }
+                            });
+                        }
                         pagination = this.getPagination(query.from || 0, query.size || 10, response.hits.total);
@@ -149,12 +173,12 @@ response.pagination = pagination;
                         err_2 = _a.sent();
-                        if (err_2 instanceof ElasticQueryError) {
-                            console.error(err_2);
-                            throw err_2;
+                        if (!(err_2 instanceof router_1.RouteTaskError)) {
+                            err_2 = new router_1.RouteTaskError(err_2, {
+                                statusCode: 500,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: task.errorRoute || null,
+                                data: {}
+                            });
                         }
-                        else {
-                            queryError = new ElasticQueryError('Someother error in Single Query', err_2, {});
-                            console.error(queryError);
-                            throw queryError;
-                        }
-                        return [3 /*break*/, 6];
+                        throw err_2;
                     case 6: return [2 /*return*/];
@@ -165,6 +189,6 @@ }
     };
-    ElasticsearchRouterTask.prototype.multiQuery = function (client, queryTemplates, routeMatch) {
+    ElasticsearchRouterTask.prototype.multiQuery = function (client, task, routeMatch) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            var bulk, payload, multiResponse, err_3, queryError, responseMap, err_4, queryError;
+            var queryTemplates, bulk, payload, multiResponse, err_3, responseMap, err_4;
             return __generator(this, function (_a) {
@@ -174,2 +198,3 @@ switch (_a.label) {
                         _a.trys.push([0, 5, , 6]);
+                        queryTemplates = task.config.queryTemplates;
                         bulk = [];
@@ -182,4 +207,10 @@ queryTemplates.forEach(function (queryTemplate) {
                             catch (err) {
-                                var queryError = new ElasticQueryError('Failed to compile template', err, { queryTemplate: queryTemplate });
-                                throw queryError;
+                                err = new router_1.RouteTaskError(err, {
+                                    statusCode: 500,
+                                    sourceRoute: routeMatch,
+                                    task: task,
+                                    redirectTo: task.errorRoute || null,
+                                    data: { queryTemplate: queryTemplate }
+                                });
+                                throw err;
                             }
@@ -190,4 +221,10 @@ try {
                             catch (err) {
-                                var queryError = new ElasticQueryError('Failed to render template', err, { queryTemplate: queryTemplate });
-                                throw queryError;
+                                err = new router_1.RouteTaskError(err, {
+                                    statusCode: 500,
+                                    sourceRoute: routeMatch,
+                                    task: task,
+                                    redirectTo: task.errorRoute || null,
+                                    data: { queryTemplate: queryTemplate }
+                                });
+                                throw err;
                             }
@@ -198,4 +235,10 @@ try {
                             catch (err) {
-                                var queryError = new ElasticQueryError('Failed to parse queryJson', err, { queryTemplate: queryTemplate, queryJson: queryJson });
-                                throw queryError;
+                                err = new router_1.RouteTaskError(err, {
+                                    statusCode: 500,
+                                    sourceRoute: routeMatch,
+                                    task: task,
+                                    redirectTo: task.errorRoute || null,
+                                    data: { queryTemplate: queryTemplate, queryJson: queryJson }
+                                });
+                                throw err;
                             }
@@ -230,4 +273,10 @@ head = {
                         err_3 = _a.sent();
-                        queryError = new ElasticQueryError('Failed to perform search', err_3, { payload: payload });
-                        throw queryError;
+                        err_3 = new router_1.RouteTaskError(err_3, {
+                            statusCode: 500,
+                            sourceRoute: routeMatch,
+                            task: task,
+                            redirectTo: task.errorRoute || null,
+                            data: { payload: payload }
+                        });
+                        throw err_3;
                     case 4:
@@ -238,2 +287,3 @@ responseMap = {};
                             var paginationDetails = queryTemplates[i].paginationDetails;
+                            var noResultsRoute = queryTemplates[i].noResultsRoute;
                             var pagination = _this.getPagination(paginationDetails.from, paginationDetails.size, response.hits.total);
@@ -243,2 +293,11 @@ response.pagination = pagination;
                             responseMap[name] = response;
+                            if (noResultsRoute && response.hits.total === 0) {
+                                throw new router_1.RouteTaskError(new Error('No results'), {
+                                    statusCode: 404,
+                                    sourceRoute: routeMatch,
+                                    task: task,
+                                    redirectTo: noResultsRoute,
+                                    data: { queryTemplate: queryTemplates[i], response: response }
+                                });
+                            }
                         });
@@ -248,12 +307,11 @@ return [2 /*return*/, responseMap];
                         err_4 = _a.sent();
-                        if (err_4 instanceof ElasticQueryError) {
-                            console.error(err_4);
-                            throw err_4;
+                        if (!(err_4 instanceof router_1.RouteTaskError)) {
+                            err_4 = new router_1.RouteTaskError(err_4, {
+                                statusCode: 500,
+                                sourceRoute: routeMatch,
+                                task: task,
+                                redirectTo: task.errorRoute || null
+                            });
                         }
-                        else {
-                            queryError = new ElasticQueryError('Someother error in Multi Query', err_4, {});
-                            console.error(queryError);
-                            throw queryError;
-                        }
-                        return [3 /*break*/, 6];
+                        throw err_4;
                     case 6: return [2 /*return*/];
@@ -307,15 +365,2 @@ }
 exports.ElasticsearchRouterTask = ElasticsearchRouterTask;
-var ElasticQueryError = /** @class */ (function (_super) {
-    __extends(ElasticQueryError, _super);
-    function ElasticQueryError(m, innerError, data) {
-        var _this = _super.call(this, m) || this;
-        _this.innerError = innerError;
-        _this.data = data;
-        _this.message = m;
-        Object.setPrototypeOf(_this, ElasticQueryError.prototype);
-        return _this;
-    }
-    return ElasticQueryError;
-}(Error));
-exports.ElasticQueryError = ElasticQueryError;
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@scvo/router-task-elasticsearch",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "SCVO=>Router task for Elasticsearch",
@@ -31,3 +31,3 @@ "main": "dist/index.js",
   "dependencies": {
-    "@scvo/router": "1.1.4",
+    "@scvo/router": "1.1.5",
     "clayhandlebars": "^4.0.0",
@@ -34,0 +34,0 @@ "dot-object": "^1.7.0",

src/index.ts

@@ -1,5 +0,11 @@
-import { Client, MSearchParams, SearchResponse, MSearchResponse, ConfigOptions } from 'elasticsearch';
+import { 
+    Client, MSearchParams, SearchResponse, 
+    MSearchResponse, ConfigOptions 
+} from 'elasticsearch';
 const hbs = require('clayhandlebars')();
 
-import { IRouterTask, IRouteMatch, Helpers } from '@scvo/router';
+import { 
+    IRouterTask, IRouteMatch, Helpers, 
+    RouteTaskError, IRouteTask
+} from '@scvo/router';
 
@@ -16,6 +22,6 @@ export class ElasticsearchRouterTask implements IRouterTask {
 
-    public async execute(routeMatch: IRouteMatch, config: IElasticsearchTaskConfig): Promise<any> {
+    public async execute(routeMatch: IRouteMatch, task: IRouteTask<IElasticsearchTaskConfig>): Promise<any> {
         var data = {};
 
-        var connectionStringCompiled = hbs.compile(config.connectionStringTemplate);
+        var connectionStringCompiled = hbs.compile(task.config.connectionStringTemplate);
         var connectionString = connectionStringCompiled(routeMatch);   
@@ -26,10 +32,10 @@ var configOptions: ConfigOptions = {
         };
-        Object.assign(configOptions, config.elasticsearchConfig || { });
+        Object.assign(configOptions, task.config.elasticsearchConfig || { });
 
         var client = new Client(configOptions);
 
-        if (Array.isArray(config.queryTemplates)) {
-            data = await this.multiQuery(client, config.queryTemplates, routeMatch); 
+        if (Array.isArray(task.config.queryTemplates)) {
+            data = await this.multiQuery(client, task, routeMatch); 
         } else {
-            data = await this.singleQuery(client, config.queryTemplates, routeMatch); 
+            data = await this.singleQuery(client, task, routeMatch); 
         }
@@ -40,4 +46,5 @@
 
-    async singleQuery(client: Client, queryTemplate: IElasticsearchQueryTemplate, routeMatch: IRouteMatch): Promise<ISearchResponse<any>> {
+    async singleQuery(client: Client, task: IRouteTask<IElasticsearchTaskConfig>, routeMatch: IRouteMatch): Promise<ISearchResponse<any>> {
         try {
+            var queryTemplate = task.config.queryTemplates;
             var queryCompiled, queryJson, query;
@@ -48,4 +55,10 @@
             } catch(err) {
-                var queryError = new ElasticQueryError('Failed to compile template', err, { queryTemplate: queryTemplate });
-                throw queryError;
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null, 
+                    data: { queryTemplate: queryTemplate }
+                });
+                throw err;
             }
@@ -56,4 +69,10 @@
             } catch(err) {
-                var queryError = new ElasticQueryError('Failed to render template', err, { queryTemplate: queryTemplate });
-                throw queryError;
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null, 
+                    data: { queryTemplate: queryTemplate }
+                });
+                throw err;
             }
@@ -64,4 +83,10 @@
             } catch(err) {
-                var queryError = new ElasticQueryError('Failed to parse queryJson', err, { queryTemplate: queryTemplate, queryJson: queryJson });
-                throw queryError;
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null, 
+                    data: { queryTemplate: queryTemplate, queryJson: queryJson }
+                });
+                throw err;
             }
@@ -79,5 +104,22 @@
             } catch(err) {
-                var queryError = new ElasticQueryError('Failed to perform search', err, { payload: payload });
+                var queryError = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null, 
+                    data: { payload: payload }
+                });
                 throw queryError;
             }
+
+            if (queryTemplate.noResultsRoute && response.hits.total === 0) {
+                throw new RouteTaskError(new Error('No results'), {
+                    statusCode: 404, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: queryTemplate.noResultsRoute, 
+                    data: { payload: payload }
+                });
+            }
+
             var pagination = this.getPagination(query.from || 0, query.size || 10, response.hits.total);
@@ -89,15 +131,18 @@ response.pagination = pagination;
         } catch(err) {
-            if (err instanceof ElasticQueryError) {
-                console.error(err);
-                throw err;
-            } else {
-                var queryError = new ElasticQueryError('Someother error in Single Query', err, {});
-                console.error(queryError);
-                throw queryError;
+            if (!(err instanceof RouteTaskError)) {
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null,
+                    data: {}
+                });
             }
+            throw err;
         }
     }
 
-    async multiQuery(client: Client, queryTemplates: IElasticsearchQueryTemplate[], routeMatch: IRouteMatch): Promise<ISearchResponses<any>> {
+    async multiQuery(client: Client, task: IRouteTask<IElasticsearchTaskConfig>, routeMatch: IRouteMatch): Promise<ISearchResponses<any>> {
         try {
+            var queryTemplates = <IElasticsearchQueryTemplate[]>task.config.queryTemplates;
             var bulk = [];
@@ -111,4 +156,10 @@
                 } catch(err) {
-                    var queryError = new ElasticQueryError('Failed to compile template', err, { queryTemplate: queryTemplate });
-                    throw queryError;
+                    err = new RouteTaskError(err, {
+                        statusCode: 500, 
+                        sourceRoute: routeMatch, 
+                        task: task, 
+                        redirectTo: task.errorRoute || null, 
+                        data: { queryTemplate: queryTemplate }
+                    });
+                    throw err;
                 }
@@ -119,4 +170,10 @@
                 } catch(err) {
-                    var queryError = new ElasticQueryError('Failed to render template', err, { queryTemplate: queryTemplate });
-                    throw queryError;
+                    err = new RouteTaskError(err, {
+                        statusCode: 500, 
+                        sourceRoute: routeMatch, 
+                        task: task, 
+                        redirectTo: task.errorRoute || null, 
+                        data: { queryTemplate: queryTemplate }
+                    });
+                    throw err;
                 }
@@ -127,4 +184,10 @@
                 } catch(err) {
-                    var queryError = new ElasticQueryError('Failed to parse queryJson', err, { queryTemplate: queryTemplate, queryJson: queryJson });
-                    throw queryError;
+                    err = new RouteTaskError(err, {
+                        statusCode: 500, 
+                        sourceRoute: routeMatch, 
+                        task: task, 
+                        redirectTo: task.errorRoute || null, 
+                        data: { queryTemplate: queryTemplate, queryJson: queryJson }
+                    });
+                    throw err;
                 }
@@ -156,4 +219,10 @@
             } catch(err) {
-                var queryError = new ElasticQueryError('Failed to perform search', err, { payload: payload });
-                throw queryError;
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null, 
+                    data: { payload: payload }
+                });
+                throw err;
             }
@@ -165,2 +234,3 @@ var responseMap: ISearchResponses<any> = {};
                 var paginationDetails = queryTemplates[i].paginationDetails;
+                var noResultsRoute = queryTemplates[i].noResultsRoute;
 
@@ -172,2 +242,12 @@ var pagination = this.getPagination(paginationDetails.from, paginationDetails.size, response.hits.total);
                 responseMap[name] = response;
+
+                if (noResultsRoute && response.hits.total === 0) {
+                    throw new RouteTaskError(new Error('No results'), {
+                        statusCode: 404, 
+                        sourceRoute: routeMatch, 
+                        task: task, 
+                        redirectTo: noResultsRoute, 
+                        data: { queryTemplate: queryTemplates[i], response: response }
+                    });
+                }
             });
@@ -177,10 +257,11 @@
         } catch(err) {
-            if (err instanceof ElasticQueryError) {
-                console.error(err);
-                throw err;
-            } else {
-                var queryError = new ElasticQueryError('Someother error in Multi Query', err, {});
-                console.error(queryError);
-                throw queryError;
+            if (!(err instanceof RouteTaskError)) {
+                err = new RouteTaskError(err, {
+                    statusCode: 500, 
+                    sourceRoute: routeMatch, 
+                    task: task, 
+                    redirectTo: task.errorRoute || null
+                });
             }
+            throw err;
         }
@@ -240,11 +321,2 @@ }
 
-export class ElasticQueryError extends Error {
-    message: string;
-    constructor(m: string, public innerError: Error, public data: any) {
-        super(m);
-        this.message = m;
-        Object.setPrototypeOf(this, ElasticQueryError.prototype);
-    }
-}
-
 export interface IElasticsearchTaskConfig {
@@ -262,2 +334,3 @@ connectionStringTemplate: string;
     paginationDetails?: IPaginationDetails;
+    noResultsRoute?: string;
 }
@@ -264,0 +337,0 @@

No alert changes

Improved metrics

Total package byte prevSize

145338

increased by4.21%

Lines of code

2561

increased by4.53%

Dependency changes

• + Added@scvo/router@1.1.5(transitive)

• - Removed@scvo/router@1.1.4(transitive)

• Updated@scvo/router@1.1.5