@sap-ux/odata-service-inquirer 0.5.59 → 0.6.0

package/dist/prompts/connectionValidator.js

@@ -23,8 +23,12 @@ const ignorableCertErrors = [error_handler_1.ERROR_TYPE.CERT_SELF_SIGNED, error_
  */
 class ConnectionValidator {
     validity = {};
-    // The current valid url (not necessarily authenticated but the url is in a valid format)
+    // The current valid url (not necessarily authenticated but the url is in a valid format), for destination connections this will be in the form: <protocol>://<destinationName>.dest
     _validatedUrl;
+    // Only in the case of destination connections does this store the destination `url` value, this is the fully expanded destination url and any user specified service paths
+    _destinationUrl;
+    // The full destination object
+    _destination;
     // The current client code used for requests, the client code has been validated by a successful request
     _validatedClient;
     _odataService;
@@ -135,6 +139,22 @@ class ConnectionValidator {
     get refreshToken() {
         return this._refreshToken;
     }
+    /**
+     * Get the full expanded destination url as defined in the destination configuration. This should not be used to connect from App Studio (use the .dest form).
+     *
+     * @returns the connected destination 'URL' attribute value
+     */
+    get destinationUrl() {
+        return this._destinationUrl;
+    }
+    /**
+     * Get the  destination.
+     *
+     * @returns the connected destination 'URL' attribute value
+     */
+    get destination() {
+        return this._destination;
+    }
     /**
      * Get the connected system name. If previously set this will be used, otherwise the name is determined
      * by the system auth type, or the validated url.
@@ -168,8 +188,9 @@ class ConnectionValidator {
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
      * @returns the status code or error returned by the connection attempt
+     * @throws an error if the connection attempt fails and the error is a 500 on App Studio or a non-axios error is caught
      */
-    async checkSapServiceUrl(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion } = {}) {
+    async checkUrl(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion } = {}) {
         const isBAS = (0, btp_utils_1.isAppStudio)();
         try {
             // Auto add trailing '/' to path
@@ -196,8 +217,8 @@ class ConnectionValidator {
         catch (e) {
             logger_helper_1.default.logger.debug(`ConnectionValidator.checkSapService() - error: ${e.message}`);
             if (e?.isAxiosError) {
-                // Only throw for 500 on App Studio
-                if (e?.response?.status === 500 && isBAS) {
+                // Error handling for BAS specific 500 errors
+                if (e?.response?.status.toString().match(/5\d\d/) && isBAS) {
                     throw e;
                 }
                 return e?.response?.status || e?.code;
@@ -251,7 +272,11 @@ class ConnectionValidator {
         logger_helper_1.default.attachAxiosLogger(this._serviceProvider.interceptors);
         await this._odataService.get('');
     }
-    resetConnectionState() {
+    /**
+     *
+     * @param resetValidity
+     */
+    resetConnectionState(resetValidity = false) {
         this._serviceProvider = undefined;
         this._odataService = undefined;
         this._catalogV2 = undefined;
@@ -260,6 +285,9 @@ class ConnectionValidator {
         this._connectedUserName = undefined;
         this._refreshToken = undefined;
         this._connectedSystemName = undefined;
+        if (resetValidity) {
+            this.resetValidity();
+        }
     }
     /**
      * Create the connection for a system url, the specified axios config or the specified service info.
@@ -269,12 +297,21 @@ class ConnectionValidator {
      * @param connectConfig.url the system url
      * @param connectConfig.serviceInfo the service info
      * @param connectConfig.odataVersion the odata version to restrict the catalog requests if only a specific version is required
+     * @param connectConfig.destination the destination to connect with
+     * @throws an error if the connection attempt fails, callers should handle the error
      */
-    async createSystemConnection({ axiosConfig, url, serviceInfo, odataVersion }) {
+    async createSystemConnection({ axiosConfig, url, serviceInfo, destination, odataVersion }) {
         this.resetConnectionState();
+        this.resetValidity();
         if (this.systemAuthType === 'reentranceTicket' || this.systemAuthType === 'serviceKey') {
             this._serviceProvider = this.getAbapOnCloudServiceProvider(url, serviceInfo);
         }
+        else if (destination) {
+            // Assumption: the destination configured URL is a valid URL, will be needed later for basic auth error handling
+            this._validatedUrl = (0, btp_utils_1.getDestinationUrlForAppStudio)(destination.Name);
+            this._destinationUrl = destination.Host;
+            this._serviceProvider = (0, axios_extension_1.createForDestination)({}, destination);
+        }
         else if (axiosConfig) {
             this._axiosConfig = axiosConfig;
             this._serviceProvider = (0, axios_extension_1.createForAbap)(axiosConfig);
@@ -307,6 +344,8 @@ class ConnectionValidator {
                 await this._catalogV4.listServices();
             }
             else {
+                // Either the v2 or v4 catalog request failed for a specific odata version, or both failed where no odata verison was specified
+                // Do some root cause analysis to determine the end user help message
                 throw error;
             }
         }
@@ -325,7 +364,7 @@ class ConnectionValidator {
         return errorType === error_handler_1.ERROR_TYPE.NOT_FOUND || errorType === error_handler_1.ERROR_TYPE.AUTH;
     }
     /**
-     * Callback for when the refresh token changes.
+     * Callback for when the Abap cloud system refresh token changes.
      *
      * @param refreshToken the new refresh token
      */
@@ -358,10 +397,12 @@ class ConnectionValidator {
     }
     /**
      * Validate the system connectivity with the specified service info (containing UAA details).
+     * This will create a connection to the system, updating the service provider reference.
+     * The connected user name will be cached for later use.
      *
      * @param serviceInfo the service info containing the UAA details
      * @param odataVersion the odata version to restrict the catalog requests if only a specific version is required
-     * @returns true if the system is reachable, false if not, or an error message string
+     * @returns true if the system is reachable and authenticated, if required, false if not, or an error message string
      */
     async validateServiceInfo(serviceInfo, odataVersion) {
         if (!serviceInfo) {
@@ -385,7 +426,85 @@ class ConnectionValidator {
         }
     }
     /**
-     * Validates the system or service url format as well as its reachability.
+     * Validate the specified destination connectivity, determining if authentication is required or if the destination is misconfigured.
+     *
+     * @param destination the destination to validate
+     * @param odataVersion the odata version to restrict the catalog requests if only a specific version is required
+     * @param servicePath the service path to validate, if specified will be appended to the destination URL for validation, if not specified the destination url will be used
+     * @returns true if the system is reachable and authenticated, if required, false if not, or an error message string
+     */
+    async validateDestination(destination, odataVersion, servicePath) {
+        try {
+            // The only supported authentication mechanism for destinations set to Authentication 'NO_AUTHENTICATION' is basic (i.e. to the target Abap system)
+            // So while we actually dont know we assume its basic for now since thats the only supported mechanism
+            this.systemAuthType = destination.Authentication === btp_utils_1.Authentication.NO_AUTHENTICATION ? 'basic' : 'unknown';
+            // Since a destination may be a system or a service connection, we need to determine the connection request (catalog or service)
+            if ((0, btp_utils_1.isFullUrlDestination)(destination) || (0, btp_utils_1.isPartialUrlDestination)(destination)) {
+                return await this.validateOdataServiceDestination(destination, servicePath);
+            }
+            else {
+                await this.createSystemConnection({ destination, odataVersion });
+            }
+            return {
+                valResult: this.getValidationResultFromStatusCode(200)
+            };
+        }
+        catch (error) {
+            if (error?.isAxiosError) {
+                this.getValidationResultFromStatusCode(error?.response?.status || error?.code);
+            }
+            // Log the network error
+            const errorLog = prompt_helpers_1.errorHandler.logErrorMsgs(error);
+            // Return a more helpful error message
+            return {
+                valResult: prompt_helpers_1.errorHandler.getValidationErrorHelp(error, false, destination) ?? errorLog,
+                errorType: prompt_helpers_1.errorHandler.getCurrentErrorType() ?? error_handler_1.ERROR_TYPE.DESTINATION_CONNECTION_ERROR
+            };
+        }
+    }
+    /**
+     * Validate the connectivity to a destination odata service (for generic odata service destinations), determining, for example, if authentication is required.
+     *
+     * @param destination a destination that is a generic odata service destination
+     * @param servicePath additional service path to append to the destination URL
+     * @param requiredOdataVersion the required odata version, if specified will validate the odata service version satisfies the specified version
+     * @returns validation result and error type if validation fails
+     */
+    async validateOdataServiceDestination(destination, servicePath, requiredOdataVersion) {
+        this.resetConnectionState();
+        this.resetValidity();
+        // Get the destination URL in the BAS specific form <protocol>://<destinationName>.dest
+        const destUrl = (0, btp_utils_1.getDestinationUrlForAppStudio)(destination.Name, servicePath);
+        // Get the destination URL in the portable form <protocol>://<host>:<port>
+        this._destinationUrl = servicePath ? new URL(`${destination.Host}${servicePath}`).toString() : destination.Host;
+        this._destination = destination;
+        // No need to apply sap-client as this happens automatically (from destination config) when going through the BAS proxy
+        const status = await this.checkUrl(new URL(destUrl), undefined, undefined, {
+            odataVersion: requiredOdataVersion
+        });
+        this._validatedUrl = destUrl;
+        const validationResult = this.getValidationResultFromStatusCode(status);
+        if (!this.validity.reachable) {
+            // Log the error
+            const errorLog = prompt_helpers_1.errorHandler.logErrorMsgs(status);
+            return {
+                valResult: prompt_helpers_1.errorHandler.getValidationErrorHelp(status, false, destination) ?? errorLog,
+                errorType: prompt_helpers_1.errorHandler.getCurrentErrorType() ?? error_handler_1.ERROR_TYPE.DESTINATION_CONNECTION_ERROR
+            };
+        }
+        if (this.validity.authRequired) {
+            return {
+                valResult: error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.AUTH),
+                errorType: error_handler_1.ERROR_TYPE.AUTH
+            };
+        }
+        return {
+            valResult: validationResult
+        };
+    }
+    /**
+     * Validates an odata service url format as well as its reachability. Note if this function returns true, this is only an indication that the system is reachable
+     * not that a connection has been established. The connection may require separate authentication or other steps (it may be reachable but a cert error was returned).
      *
      * @param serviceUrl the url to validate, may be a system or service url.
      *     Note that if systemAuthType is specified, the url will be treated as a system url (only the origin will be considered)
@@ -394,46 +513,61 @@ class ConnectionValidator {
      * @param options.forceReValidation force re-validation of the url
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url, this value is retained for subsequent calls
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
+     * @param options.systemAuthType the system auth type used to create system connections, if not specified or `isSystem` is false or undefined, `basic` is assumed
      * @returns true if the url is reachable, false if not, or an error message string
      */
-    async validateUrl(serviceUrl, { ignoreCertError = false, forceReValidation = false, isSystem = false, odataVersion } = {}) {
+    async validateUrl(serviceUrl, { ignoreCertError = false, forceReValidation = false, isSystem = false, odataVersion, systemAuthType } = {}) {
         if (this.isEmptyString(serviceUrl)) {
             this.resetValidity();
+            this.validity.urlFormat = false;
             return false;
         }
+        let url;
+        try {
+            // Check if the url is valid
+            url = new URL(serviceUrl);
+            if (url.origin === 'null') {
+                return (0, i18n_1.t)('errors.invalidUrl', { input: serviceUrl });
+            }
+        }
+        catch (error) {
+            return (0, i18n_1.t)('errors.invalidUrl', { input: serviceUrl });
+        }
+        if (systemAuthType) {
+            this.systemAuthType = systemAuthType;
+        }
         try {
-            const url = new URL(serviceUrl);
             if (!forceReValidation && this.isUrlValidated(serviceUrl)) {
                 return this.validity.reachable ?? false;
             }
-            if (url.origin === 'null') {
-                return (0, i18n_1.t)('errors.invalidUrl');
+            else {
+                // New URL so reset the validity
+                this.resetValidity();
             }
             // Ignore path if a system url
-            const status = await this.checkSapServiceUrl(url, undefined, undefined, {
+            const status = await this.checkUrl(url, undefined, undefined, {
                 ignoreCertError,
                 isSystem,
                 odataVersion
             });
-            logger_helper_1.default.logger.debug(`ConnectionValidator.validateUrl() - status: ${status}; url: ${serviceUrl}`);
+            logger_helper_1.default.logger.debug(`ConnectionValidator.checkSapServiceUrl() - status: ${status}; url: ${serviceUrl}`);
             this.validity.urlFormat = true;
             this._validatedUrl = serviceUrl;
             return this.getValidationResultFromStatusCode(status);
         }
         catch (error) {
+            this.resetValidity();
             // 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.systemOrServiceUrlNotFound', { url: serviceUrl }));
             }
-            this.resetValidity();
             const errorMsg = prompt_helpers_1.errorHandler.getErrorMsg(error);
-            return errorMsg ?? (0, i18n_1.t)('errors.invalidUrl');
+            return errorMsg ?? error.message;
         }
     }
     /**
-     * Converts the http status code into 'validty' and returns true if the status code indicates that the URL was reachable.
-     * Sets the instance validity state based on the status code.
+     * Sets the instance validity state based on the status code and returns true if the status code indicates that the URL was reachable.
      *
      * @param status a http request status code used to determine the validation result
      * @returns true, if the status code indicates the url is reachable, false if not, or an error message string
@@ -442,6 +576,7 @@ class ConnectionValidator {
         if (status === 200) {
             this.validity.reachable = true;
             this.validity.authenticated = true;
+            return true;
         }
         else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.NOT_FOUND) {
             this.validity.reachable = false;
@@ -450,12 +585,14 @@ class ConnectionValidator {
         else if (error_handler_1.ErrorHandler.isCertError(status)) {
             this.validity.reachable = true;
             this.validity.canSkipCertError = ignorableCertErrors.includes(error_handler_1.ErrorHandler.getErrorType(status));
+            this.validity.authenticated = false;
             return prompt_helpers_1.errorHandler.getValidationErrorHelp(status, false) ?? false;
         }
         else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.AUTH) {
             this.validity.reachable = true;
             this.validity.authRequired = true;
             this.validity.authenticated = false;
+            return true;
         }
         else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.REDIRECT) {
             this.validity.reachable = true;
@@ -463,10 +600,18 @@ class ConnectionValidator {
         }
         else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.CONNECTION) {
             this.validity.reachable = false;
-            return error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.CONNECTION, `http code: ${status}`) ?? false;
+            return (error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.CONNECTION, (0, i18n_1.t)('texts.httpStatus', { httpStatus: status })) ?? false);
+        }
+        else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.BAD_REQUEST) {
+            this.validity.reachable = true;
+            return (error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.BAD_REQUEST, (0, i18n_1.t)('texts.httpStatus', { httpStatus: status })) ?? false);
+        }
+        else if (error_handler_1.ErrorHandler.getErrorType(status) === error_handler_1.ERROR_TYPE.BAD_GATEWAY) {
+            this.validity.reachable = false;
+            return (error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.BAD_GATEWAY, (0, i18n_1.t)('texts.httpStatus', { httpStatus: status })) ?? false);
         }
         this.validity.reachable = true;
-        return true;
+        return (error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ErrorHandler.getErrorType(status), (0, i18n_1.t)('texts.httpStatus', { httpStatus: status })) ?? true);
     }
     /**
      * Is a string nil or whitespace only.
@@ -487,12 +632,11 @@ class ConnectionValidator {
         if (this._validatedUrl === url) {
             return true;
         }
-        this.resetValidity();
         return false;
     }
     /**
      * Check whether basic auth is required for the given url, or for the previously validated url if none specified.
-     * This will also set the validity state for the url. This will not validate the URL.
+     * This will also set the validity state for the url.
      *
      * @param urlString the url to validate, if not provided the previously validated url will be used
      * @param client optional, sap client code, if not provided the previously validated client will be used
@@ -503,11 +647,15 @@ class ConnectionValidator {
         if (!urlString) {
             return false;
         }
-        // Dont re-request if already validated
-        if (this._validatedUrl === urlString &&
-            this._validatedClient === client &&
-            this.validity.authRequired !== undefined) {
-            return this.validity.authRequired;
+        // Dont re-request if we have already determined the auth requirement or we are authenticated
+        if (this._validatedUrl === urlString && this._validatedClient === client) {
+            if (this.validity.authenticated) {
+                return false;
+            }
+            if (this.validity.authRequired !== undefined) {
+                return this.validity.authRequired;
+            }
+            // Not determined yet, continue
         }
         // New URL or client so we need to re-request
         try {
@@ -515,13 +663,16 @@ class ConnectionValidator {
             if (client) {
                 url.searchParams.append(types_1.SAP_CLIENT_KEY, client);
             }
-            const authError = error_handler_1.ErrorHandler.getErrorType(await this.checkSapServiceUrl(url, undefined, undefined, { ignoreCertError })) === error_handler_1.ERROR_TYPE.AUTH;
+            const authError = error_handler_1.ErrorHandler.getErrorType(await this.checkUrl(url, undefined, undefined, { ignoreCertError })) ===
+                error_handler_1.ERROR_TYPE.AUTH;
             // Only if we get the specific auth error so we know that auth is required, otherwise we cannot determine so leave as undefined
             if (authError) {
                 this.validity.authRequired = true;
                 this.validity.reachable = true;
             }
-            // Returning undefined if we cannot determine if auth is required
+            // Since an exception was not thrown, this is a valid url
+            this.validity.urlFormat = true;
+            this._validatedUrl = urlString;
             return this.validity.authRequired;
         }
         catch (error) {
@@ -544,7 +695,7 @@ class ConnectionValidator {
      */
     async validateAuth(url, username, password, { ignoreCertError = false, sapClient, odataVersion, isSystem = false } = {}) {
         if (!url) {
-            return false;
+            return { valResult: false };
         }
         try {
             const urlObject = new URL(url);
@@ -552,40 +703,47 @@ class ConnectionValidator {
                 urlObject.searchParams.append(types_1.SAP_CLIENT_KEY, sapClient);
             }
             this.systemAuthType = 'basic';
-            const status = await this.checkSapServiceUrl(urlObject, username, password, {
+            const status = await this.checkUrl(urlObject, username, password, {
                 ignoreCertError,
                 isSystem,
                 odataVersion
             });
-            logger_helper_1.default.logger.debug(`ConnectionValidator.validateUrl() - status: ${status}; url: ${url}`);
+            logger_helper_1.default.logger.debug(`ConnectionValidator.checkSapServiceUrl() - status: ${status}; url: ${url}`);
             // Since an exception was not thrown, this is a valid url
             this.validity.urlFormat = true;
             this._validatedUrl = url;
             const valResult = this.getValidationResultFromStatusCode(status);
             if (valResult === true) {
                 if (this.validity.authenticated === true) {
-                    return true;
+                    return { valResult: true };
                 }
                 else if (this.validity.authenticated === false) {
-                    return (0, i18n_1.t)('errors.authenticationFailed');
+                    return { valResult: (0, i18n_1.t)('errors.authenticationFailed'), errorType: error_handler_1.ERROR_TYPE.AUTH };
                 }
             }
-            return valResult;
+            return { valResult };
         }
         catch (error) {
-            return prompt_helpers_1.errorHandler.getErrorMsg(error) ?? false;
+            return {
+                valResult: prompt_helpers_1.errorHandler.getValidationErrorHelp(error, false, this.destination) ??
+                    prompt_helpers_1.errorHandler.getErrorMsg(error) ??
+                    (0, i18n_1.t)('errors.unknownError'),
+                errorType: prompt_helpers_1.errorHandler.getCurrentErrorType() ?? undefined
+            };
         }
     }
     /**
      * Reset the validity state.
      */
     resetValidity() {
-        this.validity.urlFormat = false;
+        delete this.validity.urlFormat;
         delete this.validity.reachable;
         delete this.validity.authRequired;
         delete this.validity.authenticated;
         delete this.validity.canSkipCertError;
         this._validatedUrl = undefined;
+        this._destinationUrl = undefined;
+        this._destination = undefined;
     }
     /**
      * Set the rejectUnauthorized option of the global https agent.

package/dist/prompts/datasources/sap-system/abap-on-btp/questions.d.ts

@@ -2,6 +2,7 @@ import type { ServiceInstanceInfo } from '@sap/cf-tools';
 import type { Question } from 'inquirer';
 import { type OdataServiceAnswers, type OdataServicePromptOptions } from '../../../../types';
 import { ConnectionValidator } from '../../../connectionValidator';
+import { type ServiceAnswer } from '../service-selection';
 declare const systemUrlPromptName: "abapOnBtp:newSystemUrl";
 declare const abapOnBtpPromptNames: {
     readonly abapOnBtpAuthType: "abapOnBtpAuthType";
@@ -21,7 +22,7 @@ interface AbapOnBtpAnswers extends Partial<OdataServiceAnswers> {
  * @param promptOptions The prompt options which control the service selection and system name]
  * @returns The list of questions for the ABAP on BTP system
  */
-export declare function getAbapOnBTPSystemQuestions(promptOptions?: OdataServicePromptOptions): Question<AbapOnBtpAnswers>[];
+export declare function getAbapOnBTPSystemQuestions(promptOptions?: OdataServicePromptOptions): Question<AbapOnBtpAnswers & ServiceAnswer>[];
 /**
  * Get the Cloud Foundry Abap system discovery prompt. This prompt will list all available ABAP environments in the connected Cloud Foundry space.
  * If the Cloud Foundry connection fails, a warning message will be displayed.

package/dist/prompts/datasources/sap-system/abap-on-btp/questions.js

@@ -18,6 +18,7 @@ const questions_1 = require("../new-system/questions");
 const types_2 = require("../new-system/types");
 const validators_1 = require("../validators");
 const cf_helper_1 = require("./cf-helper");
+const service_selection_1 = require("../service-selection");
 const abapOnBtpPromptNamespace = 'abapOnBtp';
 const systemUrlPromptName = `${abapOnBtpPromptNamespace}:${types_2.newSystemPromptNames.newSystemUrl}`;
 const cliCfAbapServicePromptName = 'cliCfAbapService';
@@ -72,11 +73,12 @@ function getAbapOnBTPSystemQuestions(promptOptions) {
             (connectValidator.validity.authenticated ?? connectValidator.validity.authRequired !== true))[0]);
     }
     // Service selection prompt
-    questions.push(...(0, questions_1.getSystemServiceQuestion)(connectValidator, abapOnBtpPromptNamespace, promptOptions));
+    questions.push(...(0, service_selection_1.getSystemServiceQuestion)(connectValidator, abapOnBtpPromptNamespace, promptOptions));
     return questions;
 }
 /**
  * Validate the service info for the ABAP on BTP system. This function will validate the service key file and the connection to the ABAP system.
+ * Updates the prompt state with the connected system.
  *
  * @param abapService the abap service as provided by CF tools
  * @param connectionValidator connection validator instance

package/dist/prompts/datasources/sap-system/abap-on-prem/questions.d.ts

@@ -1,19 +1,17 @@
 import type { OdataVersion } from '@sap-ux/odata-service-writer';
 import type { Question } from 'inquirer';
-import type { OdataServiceAnswers, OdataServicePromptOptions, SystemNamePromptOptions, promptNames } from '../../../../types';
+import { type OdataServiceAnswers, type OdataServicePromptOptions, type SystemNamePromptOptions } from '../../../../types';
 import { ConnectionValidator } from '../../../connectionValidator';
-import { type ServiceAnswer } from '../new-system/types';
+import { type ServiceAnswer } from '../service-selection';
 declare const systemUrlPromptName: "abapOnPrem:newSystemUrl";
-export declare enum abapOnPremInternalPromptNames {
-    sapClient = "sapClient",
-    systemUsername = "abapSystemUsername",
-    systemPassword = "abapSystemPassword"
+declare const usernamePromptName: "abapOnPrem:systemUsername";
+declare const passwordPromptName: "abapOnPrem:systemPassword";
+interface AbabpOnPremCredentialsAnswers {
+    [usernamePromptName]?: string;
+    [passwordPromptName]?: string;
 }
-interface AbapOnPremAnswers extends Partial<OdataServiceAnswers> {
+export interface AbapOnPremAnswers extends Partial<OdataServiceAnswers>, AbabpOnPremCredentialsAnswers {
     [systemUrlPromptName]?: string;
-    [abapOnPremInternalPromptNames.systemUsername]?: string;
-    [abapOnPremInternalPromptNames.systemPassword]?: string;
-    [promptNames.serviceSelection]?: ServiceAnswer;
 }
 /**
  * Get the Abap on-premise datasource questions.
@@ -21,7 +19,7 @@ interface AbapOnPremAnswers extends Partial<OdataServiceAnswers> {
  * @param promptOptions options for prompts. Applicable options are: {@link ServiceSelectionPromptOptions}, {@link SystemNamePromptOptions}
  * @returns property questions for the Abap on-premise datasource
  */
-export declare function getAbapOnPremQuestions(promptOptions?: OdataServicePromptOptions): Question<AbapOnPremAnswers>[];
+export declare function getAbapOnPremQuestions(promptOptions?: OdataServicePromptOptions): Question<AbapOnPremAnswers & ServiceAnswer>[];
 /**
  * Gets the Abap on-premise system questions.
  *

package/dist/prompts/datasources/sap-system/abap-on-prem/questions.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.abapOnPremInternalPromptNames = void 0;
 exports.getAbapOnPremQuestions = getAbapOnPremQuestions;
 exports.getAbapOnPremSystemQuestions = getAbapOnPremSystemQuestions;
 const inquirer_common_1 = require("@sap-ux/inquirer-common");
@@ -8,16 +7,17 @@ const project_input_validator_1 = require("@sap-ux/project-input-validator");
 const i18n_1 = require("../../../../i18n");
 const utils_1 = require("../../../../utils");
 const connectionValidator_1 = require("../../../connectionValidator");
-const questions_1 = require("../new-system/questions");
+const questions_1 = require("../credentials/questions");
+const questions_2 = require("../new-system/questions");
 const types_1 = require("../new-system/types");
+const service_selection_1 = require("../service-selection");
 const abapOnPremPromptNamespace = 'abapOnPrem';
 const systemUrlPromptName = `${abapOnPremPromptNamespace}:${types_1.newSystemPromptNames.newSystemUrl}`;
-var abapOnPremInternalPromptNames;
-(function (abapOnPremInternalPromptNames) {
-    abapOnPremInternalPromptNames["sapClient"] = "sapClient";
-    abapOnPremInternalPromptNames["systemUsername"] = "abapSystemUsername";
-    abapOnPremInternalPromptNames["systemPassword"] = "abapSystemPassword";
-})(abapOnPremInternalPromptNames || (exports.abapOnPremInternalPromptNames = abapOnPremInternalPromptNames = {}));
+const usernamePromptName = `${abapOnPremPromptNamespace}:${questions_1.BasicCredentialsPromptNames.systemUsername}`;
+const passwordPromptName = `${abapOnPremPromptNamespace}:${questions_1.BasicCredentialsPromptNames.systemPassword}`;
+const abapOnPremPromptNames = {
+    sapClient: 'sapClient'
+};
 /**
  * Get the Abap on-premise datasource questions.
  *
@@ -30,7 +30,7 @@ function getAbapOnPremQuestions(promptOptions) {
     // Prompt options
     const requiredOdataVersion = promptOptions?.serviceSelection?.requiredOdataVersion;
     const questions = getAbapOnPremSystemQuestions(promptOptions?.userSystemName, connectValidator, requiredOdataVersion);
-    questions.push(...(0, questions_1.getSystemServiceQuestion)(connectValidator, abapOnPremPromptNamespace, promptOptions));
+    questions.push(...(0, service_selection_1.getSystemServiceQuestion)(connectValidator, abapOnPremPromptNamespace, promptOptions));
     return questions;
 }
 /**
@@ -43,12 +43,14 @@ function getAbapOnPremQuestions(promptOptions) {
  */
 function getAbapOnPremSystemQuestions(systemNamePromptOptions, connectionValidator, requiredOdataVersion) {
     const connectValidator = connectionValidator ?? new connectionValidator_1.ConnectionValidator();
-    let validClient = true;
+    // Object reference to access dynamic sapClient value in prompts where the previous answers are not available.
+    // This allows re-usability of the credentials prompts where a client prompt was not used (client was loaded from store).
+    const sapClientRef = { sapClient: undefined, isValid: true };
     const questions = [
-        (0, questions_1.getSystemUrlQuestion)(connectValidator, abapOnPremPromptNamespace, requiredOdataVersion),
+        (0, questions_2.getSystemUrlQuestion)(connectValidator, abapOnPremPromptNamespace, requiredOdataVersion),
         {
             type: 'input',
-            name: abapOnPremInternalPromptNames.sapClient,
+            name: abapOnPremPromptNames.sapClient,
             message: (0, i18n_1.t)('prompts.sapClient.message'),
             guiOptions: {
                 breadcrumb: (0, i18n_1.t)('prompts.sapClient.breadcrumb')
@@ -56,58 +58,22 @@ function getAbapOnPremSystemQuestions(systemNamePromptOptions, connectionValidat
             validate: (client) => {
                 const valRes = (0, project_input_validator_1.validateClient)(client);
                 if (valRes === true) {
-                    validClient = true;
+                    sapClientRef.sapClient = client;
+                    sapClientRef.isValid = true;
                     return true;
                 }
-                validClient = false;
+                sapClientRef.sapClient = undefined;
+                sapClientRef.isValid = false;
                 return valRes;
             }
         },
-        {
-            when: () => connectValidator.isAuthRequired(),
-            type: 'input',
-            name: abapOnPremInternalPromptNames.systemUsername,
-            message: (0, i18n_1.t)('prompts.systemUsername.message'),
-            guiOptions: {
-                mandatory: true
-            },
-            default: '',
-            validate: (user) => user?.length > 0
-        },
-        {
-            when: () => connectValidator.isAuthRequired(),
-            type: 'password',
-            guiOptions: {
-                mandatory: true
-            },
-            name: abapOnPremInternalPromptNames.systemPassword,
-            message: (0, i18n_1.t)('prompts.systemPassword.message'),
-            guiType: 'login',
-            mask: '*',
-            default: '',
-            validate: async (password, answers) => {
-                if (!(connectValidator.validatedUrl && answers.abapSystemUsername && password && validClient)) {
-                    return false;
-                }
-                const valResult = await connectValidator.validateAuth(connectValidator.validatedUrl, answers.abapSystemUsername, password, {
-                    sapClient: answers.sapClient,
-                    isSystem: true
-                });
-                if (valResult === true && connectValidator.serviceProvider) {
-                    utils_1.PromptState.odataService.connectedSystem = {
-                        serviceProvider: connectValidator.serviceProvider
-                    };
-                    return true;
-                }
-                return valResult;
-            }
-        }
+        ...(0, questions_1.getCredentialsPrompts)(connectValidator, abapOnPremPromptNamespace, sapClientRef)
     ];
     if (systemNamePromptOptions?.hide !== true) {
         // New system question will allow user to give the system a user friendly name
-        questions.push((0, inquirer_common_1.withCondition)([(0, questions_1.getUserSystemNameQuestion)(connectValidator, abapOnPremPromptNamespace)], (answers) => !!answers?.[systemUrlPromptName] &&
+        questions.push((0, inquirer_common_1.withCondition)([(0, questions_2.getUserSystemNameQuestion)(connectValidator, abapOnPremPromptNamespace)], (answers) => !!answers?.[systemUrlPromptName] &&
             connectValidator.validity.reachable === true &&
-            (connectValidator.validity.authenticated || connectValidator.validity.authRequired !== true))[0]);
+            (connectValidator.validity.authenticated || connectValidator.validity.authRequired === false))[0]);
     }
     return questions;
 }