@sap-ux/odata-service-inquirer 0.2.3 → 0.3.1

package/dist/error-handler/error-handler.d.ts

@@ -52,6 +52,13 @@ export declare class ErrorHandler {
      * @returns The Guided Answers node for the specified error type
      */
     private static readonly getHelpNode;
+    /**
+     * Find an error property for mapping to a general error type from most to least significant.
+     *
+     * @param error any type of error or object that has an error code, status, name or message
+     * @returns a value that can be used to look up a general error type
+     */
+    private static findErrorValueForMapping;
     /**
      * Create an instance of the ErrorHandler.
      *

package/dist/error-handler/error-handler.js

@@ -151,8 +151,12 @@ class ErrorHandler {
      * @returns the error type
      */
     static getErrorType(error) {
+        let errorValueToFind = error;
+        if (error instanceof Error) {
+            errorValueToFind = ErrorHandler.findErrorValueForMapping(error);
+        }
         return Object.keys(ERROR_TYPE).find((errorCodeType) => {
-            return exports.ERROR_MAP[errorCodeType].find((exp) => exp.test(error.toString()));
+            return exports.ERROR_MAP[errorCodeType].find((exp) => exp.test(errorValueToFind.toString()));
         }, {});
     }
     /**
@@ -196,21 +200,14 @@ class ErrorHandler {
      * @returns The mapped error message and error type
      */
     static mapErrorToMsg(error) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a;
         let errorType;
         if (Object.values(ERROR_TYPE).includes(error)) {
             errorType = error;
         }
         else {
             // Map error type using more to less specific information if available
-            errorType =
-                (_f = ErrorHandler.getErrorType(((_c = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.code) ||
-                    ((_d = error.response) === null || _d === void 0 ? void 0 : _d.status) ||
-                    ((_e = error.response) === null || _e === void 0 ? void 0 : _e.data) ||
-                    error.code ||
-                    (['TypeError', 'Error'].includes(error.name) ? error.message : error.name) || // For generic error types use the message otherwise the name is more relevant
-                    error.message ||
-                    error)) !== null && _f !== void 0 ? _f : ERROR_TYPE.UNKNOWN;
+            errorType = (_a = ErrorHandler.getErrorType(this.findErrorValueForMapping(error))) !== null && _a !== void 0 ? _a : ERROR_TYPE.UNKNOWN;
         }
         return {
             errorMsg: ErrorHandler._errorMsg(error)[errorType],
@@ -397,7 +394,7 @@ ErrorHandler._errorMsg = (error) => ({
     [ERROR_TYPE.INTERNAL_SERVER_ERROR]: (0, i18n_1.t)('errors.internalServerError', { error: error === null || error === void 0 ? void 0 : error.message }),
     [ERROR_TYPE.NOT_FOUND]: (0, i18n_1.t)('errors.urlNotFound'),
     [ERROR_TYPE.ODATA_URL_NOT_FOUND]: (0, i18n_1.t)('errors.odataServiceUrlNotFound'),
-    [ERROR_TYPE.BAD_GATEWAY]: (0, i18n_1.t)('errors.destinationUnavailable'),
+    [ERROR_TYPE.BAD_GATEWAY]: (0, i18n_1.t)('errors.badGateway'),
     [ERROR_TYPE.DESTINATION_UNAVAILABLE]: (0, i18n_1.t)('errors.destinationUnavailable'),
     [ERROR_TYPE.DESTINATION_NOT_FOUND]: (0, i18n_1.t)('errors.destinationNotFound'),
     [ERROR_TYPE.DESTINATION_MISCONFIGURED]: (0, i18n_1.t)('errors.destinationMisconfigured'),
@@ -447,4 +444,20 @@ ErrorHandler.getHelpNode = (errorType) => {
     };
     return errorToHelp[errorType];
 };
+/**
+ * Find an error property for mapping to a general error type from most to least significant.
+ *
+ * @param error any type of error or object that has an error code, status, name or message
+ * @returns a value that can be used to look up a general error type
+ */
+ErrorHandler.findErrorValueForMapping = (error) => {
+    var _a, _b, _c, _d, _e;
+    return ((_c = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.code) ||
+        ((_d = error.response) === null || _d === void 0 ? void 0 : _d.status) ||
+        ((_e = error.response) === null || _e === void 0 ? void 0 : _e.data) ||
+        error.code ||
+        (['TypeError', 'Error'].includes(error.name) ? error.message : error.name) || // For generic error types use the message otherwise the name is more relevant
+        error.message ||
+        error;
+};
 //# sourceMappingURL=error-handler.js.map

package/dist/i18n.js

@@ -25,7 +25,12 @@ function initI18nOdataServiceInquirer() {
         yield i18next_1.default.init({
             lng: 'en',
             fallbackLng: 'en',
-            missingInterpolationHandler: () => ''
+            missingInterpolationHandler: () => '',
+            interpolation: {
+                format: function odataVersionFormatter(odataVersion) {
+                    return odataVersion ? ` V${odataVersion}` : '';
+                }
+            }
         }, () => i18next_1.default.addResourceBundle('en', odataServiceInquirerNamespace, odata_service_inquirer_i18n_json_1.default));
     });
 }

package/dist/index.d.ts

@@ -16,9 +16,7 @@ import { DatasourceType, promptNames, type CapRuntime, type CapService, type Oda
  */
 declare function getPrompts(promptOptions?: OdataServicePromptOptions, logger?: Logger, enableGuidedAnswers?: boolean, telemetryClient?: ToolsSuiteTelemetryClient, isYUI?: boolean): Promise<{
     prompts: OdataServiceQuestion[];
-    answers: {
-        odataService: Partial<OdataServiceAnswers>;
-    };
+    answers: Partial<OdataServiceAnswers>;
 }>;
 /**
  * Prompt for odata service writer inputs.

package/dist/index.js

@@ -48,7 +48,7 @@ function getPrompts(promptOptions, logger, enableGuidedAnswers = false, telemetr
         return {
             prompts: yield (0, prompts_1.getQuestions)(promptOptions),
             // Return reference to derived answers object that will be populated with user responses (after prompting is complete)
-            answers: utils_1.PromptState
+            answers: utils_1.PromptState.odataService
         };
     });
 }

package/dist/prompts/datasources/cap-project/questions.js

@@ -153,7 +153,7 @@ function getLocalCapProjectPrompts(promptOptions) {
             })
         }
     ];
-    if ((0, utils_1.getPlatform)() === types_1.hostEnvironment.cli) {
+    if ((0, utils_1.getHostEnvironment)() === types_1.hostEnvironment.cli) {
         prompts.push({
             when: (answers) => __awaiter(this, void 0, void 0, function* () {
                 if (answers === null || answers === void 0 ? void 0 : answers.capService) {

package/dist/prompts/datasources/service-url/connectionValidator.d.ts

@@ -0,0 +1,99 @@
+import type { IValidationLink } from '@sap-devx/yeoman-ui-types';
+import type { AxiosRequestConfig, ODataService } from '@sap-ux/axios-extension';
+/**
+ * Structure to store validity information about url to be validated.
+ */
+interface Validity {
+    urlFormat?: boolean;
+    reachable?: boolean;
+    authRequired?: boolean;
+    authenticated?: boolean;
+    canSkipCertError?: boolean;
+}
+/**
+ * Class that validates the connection to a service url or catalog url.
+ * This will determine if authentication is required and if the service/catalog is reachable, generating messages to guide the user.
+ * It is optimized for re-validation of the same url, so that the validation is not repeated if not required.
+ *
+ */
+export declare class ConnectionValidator {
+    readonly validity: Validity;
+    private _validatedUrl;
+    private _odataService;
+    private _axiosConfig;
+    /**
+     * Getter for the axios configuration.
+     *
+     * @returns the axios configuration
+     */
+    get axiosConfig(): AxiosRequestConfig;
+    /**
+     * Get the odata service instance.
+     *
+     * @returns the odata service instance
+     */
+    get odataService(): ODataService;
+    /**
+     * Calls a given service url to test its reachability and authentication requirements.
+     *
+     * @param url a service url (<protocol://<host>:<port>/<service-path>)
+     * @param username optional username
+     * @param password optional password
+     * @param [ignoreCertError] optional, ignore some certificate errors
+     * @returns the status code or error returned by the connection attempt
+     */
+    private checkSapService;
+    /**
+     * Validates the service url format as well as its reachability.
+     *
+     * @param serviceUrl the odata service url to validate
+     * @param ignoreCertError ignore some certificate errors
+     * @param forceReValidation force re-validation of the url
+     * @returns true if the url is reachable, false if not, or an error message string
+     */
+    validateUrl(serviceUrl: string, ignoreCertError?: boolean, forceReValidation?: boolean): Promise<boolean | string | IValidationLink>;
+    /**
+     * Translate the status code into a validation result.
+     * Sets the instance validity state based on the status code.
+     *
+     * @param status a http request status code used to determine the validation result
+     * @returns
+     */
+    private getValidationResultFromStatusCode;
+    /**
+     * Is a string nil or whitespace only.
+     *
+     * @param url the string to test
+     * @returns true if the string is nil or whitespace
+     */
+    private isEmptyString;
+    /**
+     * Tests if the url has already been validated.
+     *
+     * @param url the full url to test for previous validation
+     * @returns true if the url has already been validated
+     */
+    private isUrlValidated;
+    /**
+     * Test the connectivity with the specified service url using the provided credentials.
+     *
+     * @param serviceUrl optional, the service url to validate
+     * @param username user name
+     * @param password password
+     * @param ignoreCertError optional, ignore some certificate errors
+     * @returns true if the authentication is successful, false if not, or an error message string
+     */
+    validateAuth(serviceUrl: string, username: string, password: string, ignoreCertError?: boolean): Promise<boolean | string>;
+    /**
+     * Reset the validity state.
+     */
+    private resetValidity;
+    /**
+     * Set the rejectUnauthorized option of the global https agent.
+     *
+     * @param rejectUnauthorized - true to reject unauthorized certificates, false to accept them
+     */
+    static setGlobalRejectUnauthorized(rejectUnauthorized: boolean): void;
+}
+export {};
+//# sourceMappingURL=connectionValidator.d.ts.map

package/dist/prompts/datasources/service-url/connectionValidator.js

@@ -0,0 +1,271 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionValidator = void 0;
+const btp_utils_1 = require("@sap-ux/btp-utils");
+const error_handler_1 = require("../../../error-handler/error-handler");
+const prompt_helpers_1 = require("../../prompt-helpers");
+const i18n_1 = require("../../../i18n");
+const https_1 = __importDefault(require("https"));
+const logger_helper_1 = __importDefault(require("../../logger-helper"));
+const axios_extension_1 = require("@sap-ux/axios-extension");
+// Cert errors that may be ignored by prompt user
+const ignorableCertErrors = [error_handler_1.ERROR_TYPE.CERT_SELF_SIGNED, error_handler_1.ERROR_TYPE.CERT_SELF_SIGNED_CERT_IN_CHAIN];
+/**
+ * Class that validates the connection to a service url or catalog url.
+ * This will determine if authentication is required and if the service/catalog is reachable, generating messages to guide the user.
+ * It is optimized for re-validation of the same url, so that the validation is not repeated if not required.
+ *
+ */
+class ConnectionValidator {
+    constructor() {
+        this.validity = {};
+    }
+    /**
+     * Getter for the axios configuration.
+     *
+     * @returns the axios configuration
+     */
+    get axiosConfig() {
+        return this._axiosConfig;
+    }
+    /**
+     * Get the odata service instance.
+     *
+     * @returns the odata service instance
+     */
+    get odataService() {
+        return this._odataService;
+    }
+    /**
+     * Calls a given service url to test its reachability and authentication requirements.
+     *
+     * @param url a service url (<protocol://<host>:<port>/<service-path>)
+     * @param username optional username
+     * @param password optional password
+     * @param [ignoreCertError] optional, ignore some certificate errors
+     * @returns the status code or error returned by the connection attempt
+     */
+    checkSapService(url, username, password, ignoreCertError = false) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const isBAS = (0, btp_utils_1.isAppStudio)();
+            try {
+                // Auto add trailing '/' to path
+                url.pathname = !((_a = url.pathname) === null || _a === void 0 ? void 0 : _a.endsWith('/')) ? `${url.pathname}/` : url.pathname;
+                // VSCode default extension proxy setting does not allow bypassing cert errors using httpsAgent (as used by Axios)
+                // so we must use globalAgent to bypass cert validation
+                if (ignoreCertError === true) {
+                    ConnectionValidator.setGlobalRejectUnauthorized(!ignoreCertError);
+                }
+                if (isBAS) {
+                    url.searchParams.append('saml2', 'disabled');
+                }
+                let axiosConfig = {
+                    params: url.searchParams,
+                    ignoreCertErrors: ignoreCertError,
+                    cookies: ''
+                };
+                if (username && password) {
+                    axiosConfig = Object.assign(axiosConfig, {
+                        auth: {
+                            username,
+                            password
+                        }
+                    });
+                }
+                this._axiosConfig = axiosConfig;
+                this._odataService = (0, axios_extension_1.createServiceForUrl)(url.origin + url.pathname, this._axiosConfig);
+                logger_helper_1.default.attachAxiosLogger(this._odataService.interceptors);
+                yield this._odataService.get('');
+                return 200;
+            }
+            catch (e) {
+                logger_helper_1.default.logger.debug(`ConnectionValidator.checkSapService() - error: ${e.message}`);
+                if (e === null || e === void 0 ? void 0 : e.isAxiosError) {
+                    // Only throw for 500 on App Studio
+                    if (((_b = e === null || e === void 0 ? void 0 : e.response) === null || _b === void 0 ? void 0 : _b.status) === 500 && isBAS) {
+                        throw e;
+                    }
+                    return ((_c = e === null || e === void 0 ? void 0 : e.response) === null || _c === void 0 ? void 0 : _c.status) || (e === null || e === void 0 ? void 0 : e.code);
+                }
+                else {
+                    throw e;
+                }
+            }
+            finally {
+                // Reset global cert validation
+                ConnectionValidator.setGlobalRejectUnauthorized(true);
+            }
+        });
+    }
+    /**
+     * Validates the service url format as well as its reachability.
+     *
+     * @param serviceUrl the odata service url to validate
+     * @param ignoreCertError ignore some certificate errors
+     * @param forceReValidation force re-validation of the url
+     * @returns true if the url is reachable, false if not, or an error message string
+     */
+    validateUrl(serviceUrl, ignoreCertError = false, forceReValidation = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isEmptyString(serviceUrl)) {
+                this.resetValidity();
+                return false;
+            }
+            try {
+                const url = new URL(serviceUrl);
+                if (!forceReValidation && this.isUrlValidated(serviceUrl)) {
+                    return (_a = this.validity.reachable) !== null && _a !== void 0 ? _a : false;
+                }
+                if (url.origin === 'null') {
+                    return (0, i18n_1.t)('errors.invalidUrl');
+                }
+                // Ignore path if a system url
+                const status = yield this.checkSapService(url, undefined, undefined, ignoreCertError);
+                logger_helper_1.default.logger.debug(`ConnectionValidator.validateUrl() - status: ${status}; url: ${serviceUrl}`);
+                this.validity.urlFormat = true;
+                this._validatedUrl = serviceUrl;
+                return this.getValidationResultFromStatusCode(status);
+            }
+            catch (error) {
+                // More helpful context specific error
+                if (error_handler_1.ErrorHandler.getErrorType(error) === error_handler_1.ERROR_TYPE.CONNECTION) {
+                    this.validity.reachable = false;
+                    return prompt_helpers_1.errorHandler.logErrorMsgs((0, i18n_1.t)('errors.serviceUrlNotFound', { url: serviceUrl }));
+                }
+                this.resetValidity();
+                const errorMsg = prompt_helpers_1.errorHandler.getErrorMsg(error);
+                return errorMsg !== null && errorMsg !== void 0 ? errorMsg : (0, i18n_1.t)('errors.invalidUrl');
+            }
+        });
+    }
+    /**
+     * Translate the status code into a validation result.
+     * Sets the instance validity state based on the status code.
+     *
+     * @param status a http request status code used to determine the validation result
+     * @returns
+     */
+    getValidationResultFromStatusCode(status) {
+        var _a, _b, _c;
+        if (status === 200) {
+            this.validity.authenticated = true;
+            this.validity.authRequired = false;
+        }
+        else if (status === 404) {
+            this.validity.reachable = false;
+            return (_a = error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.NOT_FOUND)) !== null && _a !== void 0 ? _a : false;
+        }
+        else if (error_handler_1.ErrorHandler.isCertError(status)) {
+            this.validity.reachable = true;
+            this.validity.canSkipCertError = ignorableCertErrors.includes(error_handler_1.ErrorHandler.getErrorType(status));
+            return (_b = prompt_helpers_1.errorHandler.getValidationErrorHelp(status, false)) !== null && _b !== void 0 ? _b : false;
+        }
+        else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.AUTH) {
+            this.validity.reachable = true;
+            this.validity.authRequired = true;
+        }
+        else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.REDIRECT) {
+            this.validity.reachable = true;
+            return (0, i18n_1.t)('errors.urlRedirect');
+        }
+        else if (status !== 404) {
+            this.validity.reachable = false;
+            return (_c = error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.CONNECTION, `http code: ${status}`)) !== null && _c !== void 0 ? _c : false;
+        }
+        this.validity.reachable = true;
+        return true;
+    }
+    /**
+     * Is a string nil or whitespace only.
+     *
+     * @param url the string to test
+     * @returns true if the string is nil or whitespace
+     */
+    isEmptyString(url) {
+        return !url || url.trim().length === 0;
+    }
+    /**
+     * Tests if the url has already been validated.
+     *
+     * @param url the full url to test for previous validation
+     * @returns true if the url has already been validated
+     */
+    isUrlValidated(url) {
+        if (this._validatedUrl === url) {
+            return true;
+        }
+        this.resetValidity();
+        return false;
+    }
+    /**
+     * Test the connectivity with the specified service url using the provided credentials.
+     *
+     * @param serviceUrl optional, the service url to validate
+     * @param username user name
+     * @param password password
+     * @param ignoreCertError optional, ignore some certificate errors
+     * @returns true if the authentication is successful, false if not, or an error message string
+     */
+    validateAuth(serviceUrl, username, password, ignoreCertError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!serviceUrl) {
+                return false;
+            }
+            if (!this.validity.reachable) {
+                return false;
+            }
+            try {
+                const url = new URL(serviceUrl);
+                this.validity.authenticated =
+                    (yield this.checkSapService(url, username, password, ignoreCertError)) === 200;
+                return this.validity.authenticated === true ? true : (0, i18n_1.t)('errors.authenticationFailed');
+            }
+            catch (error) {
+                return (_a = prompt_helpers_1.errorHandler.getErrorMsg(error)) !== null && _a !== void 0 ? _a : false;
+            }
+        });
+    }
+    /**
+     * Reset the validity state.
+     */
+    resetValidity() {
+        this.validity.urlFormat = false;
+        delete this.validity.reachable;
+        delete this.validity.authRequired;
+        delete this.validity.authenticated;
+        delete this.validity.canSkipCertError;
+        this._validatedUrl = undefined;
+    }
+    /**
+     * Set the rejectUnauthorized option of the global https agent.
+     *
+     * @param rejectUnauthorized - true to reject unauthorized certificates, false to accept them
+     */
+    static setGlobalRejectUnauthorized(rejectUnauthorized) {
+        if (https_1.default.globalAgent.options) {
+            https_1.default.globalAgent.options.rejectUnauthorized = rejectUnauthorized;
+        }
+        //@ts-expect-error - fallbackAgent is only present in BoundHttpsProxyAgent implementation and is not part of the Node.js API
+        if (https_1.default.globalAgent.fallbackAgent) {
+            //@ts-expect-error - fallbackAgent is not typed in Node.js API
+            https_1.default.globalAgent.fallbackAgent.options.rejectUnauthorized = rejectUnauthorized;
+        }
+    }
+}
+exports.ConnectionValidator = ConnectionValidator;
+//# sourceMappingURL=connectionValidator.js.map

package/dist/prompts/datasources/service-url/questions.d.ts

@@ -0,0 +1,12 @@
+import type { Question } from 'inquirer';
+import type { OdataServiceAnswers, OdataServicePromptOptions } from '../../../types';
+/**
+ * Get the service URL questions.
+ *
+ * @param promptOptions prompt options that can be passed to the service URL questions to configure behaviour
+ * @param promptOptions.serviceUrl see {@link OdataServicePromptOptions}
+ * @param promptOptions.serviceUrlPassword see {@link OdataServicePromptOptions}
+ * @returns the odata service URL questions
+ */
+export declare function getServiceUrlQuestions({ serviceUrl: serviceUrlOpts, serviceUrlPassword: passwordOpts }?: OdataServicePromptOptions): Question<OdataServiceAnswers>[];
+//# sourceMappingURL=questions.d.ts.map