@adastradev/serverless-discovery-sdk - npm Package Compare versions

Comparing version 2.2.8 to 2.3.0-beta.1668626343850

dist/DiscoverySdk.d.ts

@@ -9,3 +9,12 @@ export declare class DiscoverySdk {
     getDependency(name: string): string | undefined;
-    lookupService(serviceName: string, stageName?: string, version?: string, externalID?: string): Promise<any>;
+    lookupService(serviceName: string, stageName?: string, version?: string, externalID?: string, shouldInvalidateCache?: boolean): Promise<any>;
+    checkIsCurrentVersion(service: string, configVersion: string, shouldInvalidateCache?: boolean): Promise<{
+        isLatest: boolean;
+        currentVersion: string;
+        URI?: undefined;
+    } | {
+        URI: string;
+        isLatest: boolean;
+        currentVersion: any;
+    }>;
 }

dist/DiscoverySdk.js

@@ -41,3 +41,3 @@ "use strict";
 var DiscoveryServiceApi_1 = require("./DiscoveryServiceApi");
-var delay = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
+var astra_logger_1 = require("@adastradev/astra-logger");
 var DiscoverySdk = /** @class */ (function () {
@@ -68,5 +68,5 @@ function DiscoverySdk(serviceEndpointUri, region, defaultStageName, lookupVersionPostfix, cloudDeps) {
     };
-    DiscoverySdk.prototype.lookupService = function (serviceName, stageName, version, externalID) {
+    DiscoverySdk.prototype.lookupService = function (serviceName, stageName, version, externalID, shouldInvalidateCache) {
         return __awaiter(this, void 0, void 0, function () {
-            var result, error, retriesLeft, e_1;
+            var result;
             return __generator(this, function (_a) {
@@ -93,28 +93,66 @@ switch (_a.label) {
                         }
-                        retriesLeft = 3;
-                        _a.label = 1;
+                        return [4 /*yield*/, this.api.lookupService(serviceName, stageName, version, externalID, shouldInvalidateCache)];
                     case 1:
-                        if (!(!result && retriesLeft > 0)) return [3 /*break*/, 7];
-                        _a.label = 2;
+                        result = _a.sent();
+                        return [2 /*return*/, result.data.map(function (item) { return item.ServiceURL; })];
+                }
+            });
+        });
+    };
+    DiscoverySdk.prototype.checkIsCurrentVersion = function (service, configVersion, shouldInvalidateCache) {
+        return __awaiter(this, void 0, void 0, function () {
+            var URI, thisVersion, err_1, versionSpec, latestVer, retVal, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.api.lookupService(service, undefined, configVersion, undefined, shouldInvalidateCache)];
+                    case 1:
+                        thisVersion = _a.sent();
+                        URI = thisVersion.data[0].ServiceURL;
+                        return [3 /*break*/, 3];
                     case 2:
-                        _a.trys.push([2, 4, , 6]);
-                        return [4 /*yield*/, this.api.lookupService(serviceName, stageName, version, externalID)];
+                        err_1 = _a.sent();
+                        astra_logger_1.default.error("discovery failure for " + service + " " + configVersion, err_1);
+                        return [2 /*return*/, {
+                                isLatest: false,
+                                currentVersion: configVersion
+                            }];
                     case 3:
-                        result = _a.sent();
-                        error = null;
-                        return [3 /*break*/, 6];
+                        if (!!configVersion.includes('-')) return [3 /*break*/, 8];
+                        versionSpec = configVersion.split('.')[0] + '.x';
+                        latestVer = void 0;
+                        _a.label = 4;
                     case 4:
-                        e_1 = _a.sent();
-                        error = e_1;
-                        retriesLeft--;
-                        return [4 /*yield*/, delay(500)];
+                        _a.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.api.lookupService(service, undefined, versionSpec, undefined, shouldInvalidateCache)];
                     case 5:
-                        _a.sent();
-                        return [3 /*break*/, 6];
-                    case 6: return [3 /*break*/, 1];
+                        retVal = _a.sent();
+                        if (retVal && Array.isArray(retVal.data) && retVal.data.length > 0) {
+                            latestVer = retVal.data[0].Version;
+                            URI = retVal.data[0].ServiceURL;
+                            astra_logger_1.default.info("discovery service reports version " + latestVer + " for service " + service);
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _a.sent();
+                        astra_logger_1.default.error("discovery failure for " + service + " " + versionSpec, err_2);
+                        return [2 /*return*/, {
+                                isLatest: false,
+                                currentVersion: configVersion
+                            }];
                     case 7:
-                        if (error) {
-                            throw new Error(error.message);
+                        // check returned version against this configVersion.
+                        // if no results, allow to proceed. Is this the best way to handle?
+                        if (latestVer !== configVersion) {
+                            // no match or no latest version returned, throw/return error result
+                            astra_logger_1.default.info("discovery service reports version " + latestVer + " which doesn't match this services version " + configVersion);
+                            return [2 /*return*/, {
+                                    URI: URI,
+                                    isLatest: false,
+                                    currentVersion: latestVer
+                                }];
                         }
-                        return [2 /*return*/, result.data.map(function (item) { return item.ServiceURL; })];
+                        _a.label = 8;
+                    case 8: return [2 /*return*/, { isLatest: true, currentVersion: configVersion, URI: URI }];
                 }
@@ -121,0 +159,0 @@ });

dist/DiscoveryServiceApi.d.ts

@@ -8,5 +8,5 @@ import { ServiceApiModel } from './ServiceApiModel';
     getService(id: string): any;
-    lookupService(serviceName: string, stageName?: string, version?: string, externalID?: string): any;
+    lookupService(serviceName: string, stageName?: string, version?: string, externalID?: string, shouldInvalidateCache?: boolean): any;
     createService(service: ServiceApiModel): any;
     deleteService(id: string): any;
 }

dist/DiscoveryServiceApi.js

 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscoveryServiceApi = void 0;
 var apigClientFactory = require('@adastradev/aws-api-gateway-client').default; // tslint:disable-line
+var retryOptions = {
+    retries: 3,
+    retryDelay: function () { return 500; },
+    retryCondition: function (error) {
+        return (!error.response || (error.response.status === 429 || error.response.status === 502 || error.response.status === 503 || error.response.status === 504));
+    }
+};
 var DiscoveryServiceApi = /** @class */ (function () {
     function DiscoveryServiceApi(serviceEndpointUri, region, credentials) {
         if (credentials.type === 'None') {
-            this.apigClient = apigClientFactory.newClient({
-                accessKey: '',
-                invokeUrl: serviceEndpointUri,
-                region: region,
-                secretKey: ''
-            });
+            this.apigClient = apigClientFactory.newClient(__assign({ accessKey: '', invokeUrl: serviceEndpointUri, region: region, secretKey: '' }, retryOptions));
         }
         else if (credentials.type === 'IAM') {
             var iamCreds = credentials;
-            this.apigClient = apigClientFactory.newClient({
-                accessKey: iamCreds.accessKeyId,
-                invokeUrl: serviceEndpointUri,
-                region: region,
-                secretKey: iamCreds.secretAccessKey
-            });
+            this.apigClient = apigClientFactory.newClient(__assign({ accessKey: iamCreds.accessKeyId, invokeUrl: serviceEndpointUri, region: region, secretKey: iamCreds.secretAccessKey }, retryOptions));
         }
@@ -31,8 +39,3 @@ else if (credentials.type === 'BearerToken') {
             };
-            this.apigClient = apigClientFactory.newClient({
-                accessKey: '',
-                invokeUrl: serviceEndpointUri,
-                region: region,
-                secretKey: ''
-            });
+            this.apigClient = apigClientFactory.newClient(__assign({ accessKey: '', invokeUrl: serviceEndpointUri, region: region, secretKey: '' }, retryOptions));
         }
@@ -51,6 +54,7 @@ else {
     };
-    DiscoveryServiceApi.prototype.lookupService = function (serviceName, stageName, version, externalID) {
+    DiscoveryServiceApi.prototype.lookupService = function (serviceName, stageName, version, externalID, shouldInvalidateCache) {
         if (stageName === void 0) { stageName = ''; }
         if (version === void 0) { version = ''; }
         if (externalID === void 0) { externalID = ''; }
+        if (shouldInvalidateCache === void 0) { shouldInvalidateCache = false; }
         var params = {};
@@ -62,2 +66,7 @@ var pathTemplate = '/catalog/service';
         };
+        if (shouldInvalidateCache) {
+            additionalParams = __assign(__assign({}, additionalParams), { headers: {
+                    'Cache-Control': 'max-age=0'
+                } });
+        }
         var body = {};
@@ -64,0 +73,0 @@ // We need more than stageName only

package.json

 {
   "name": "@adastradev/serverless-discovery-sdk",
-  "version": "2.2.8",
+  "version": "2.3.0-beta.1668626343850",
   "description": "Serverless Service Discovery API",
@@ -30,2 +30,3 @@ "main": "dist/index.js",
     "jest": "^26.6.3",
+    "nock": "^13.2.9",
     "snyk": "^1.437.4",
@@ -37,3 +38,4 @@ "tmp": "^0.2.1",
     "tslint-config-security": "^1.16.0",
-    "typescript": "^4.1.3"
+    "typescript": "^4.1.3",
+    "@adastradev/astra-logger": "^1.4.6"
   },
@@ -44,2 +46,5 @@ "dependencies": {
   },
+  "peerDependencies": {
+    "@adastradev/astra-logger": ">= 1.4.6"
+  },
   "snyk": true,
@@ -46,0 +51,0 @@ "files": [

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

24047

increased by19.33%

Lines of code

361

increased by18.36%

Worsened metrics

Dependency count

3

increased by50%

Dev dependency count

14

increased by16.67%

Number of low quality alerts

2

increased by100%

No dependency changes