@sap-ux/odata-service-inquirer 0.5.60 → 0.6.1

package/dist/prompts/datasources/sap-system/system-selection/prompt-helpers.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectWithBackendSystem = connectWithBackendSystem;
+exports.connectWithDestination = connectWithDestination;
+exports.getBackendSystemDisplayName = getBackendSystemDisplayName;
+exports.createSystemChoices = createSystemChoices;
+const btp_utils_1 = require("@sap-ux/btp-utils");
+const store_1 = require("@sap-ux/store");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
+const i18n_1 = require("../../../../i18n");
+const utils_1 = require("../../../../utils");
+const logger_helper_1 = __importDefault(require("../../../logger-helper"));
+const questions_1 = require("./questions");
+/**
+ * Connects to the specified backend system and validates the connection.
+ * Note this will return true in the case of basic auth validation failure to defer validation to the credentials prompt.
+ *
+ * @param backendSystem the backend system to connect to
+ * @param connectionValidator the connection validator to use for the connection
+ * @param requiredOdataVersion the required OData version for the service, this will be used to narrow the catalog service connections
+ * @returns the validation result of the backend system connection
+ */
+async function connectWithBackendSystem(backendSystem, connectionValidator, requiredOdataVersion) {
+    // Create a new connection with the selected system
+    let connectValResult = false;
+    if (backendSystem) {
+        // Assumption: non-BAS systems are BackendSystems
+        if (backendSystem.authenticationType === 'reentranceTicket') {
+            connectValResult = await connectionValidator.validateUrl(backendSystem.url, {
+                isSystem: true,
+                odataVersion: (0, utils_1.convertODataVersionType)(requiredOdataVersion),
+                systemAuthType: 'reentranceTicket'
+            });
+        }
+        else if (backendSystem.serviceKeys) {
+            connectValResult = await connectionValidator.validateServiceInfo(backendSystem.serviceKeys);
+        }
+        else if (backendSystem.authenticationType === 'basic' || !backendSystem.authenticationType) {
+            let errorType;
+            ({ valResult: connectValResult, errorType } = await connectionValidator.validateAuth(backendSystem.url, backendSystem.username, backendSystem.password, {
+                isSystem: true,
+                odataVersion: (0, utils_1.convertODataVersionType)(requiredOdataVersion),
+                sapClient: backendSystem.client
+            }));
+            // If authentication failed with existing credentials the user will be prompted to enter new credentials.
+            // We log the error in case there is another issue (unresolveable) with the stored backend configuration.
+            if (errorType === inquirer_common_1.ERROR_TYPE.AUTH && backendSystem.username && backendSystem.password) {
+                logger_helper_1.default.logger.error((0, i18n_1.t)('errors.storedSystemConnectionError', { systemName: backendSystem.name, error: connectValResult }));
+                return true;
+            }
+        }
+        // If the connection is successful, we will return the connected system from the inquirer
+        if (connectValResult === true && connectionValidator.serviceProvider) {
+            utils_1.PromptState.odataService.connectedSystem = {
+                serviceProvider: connectionValidator.serviceProvider,
+                backendSystem
+            };
+        }
+    }
+    return connectValResult;
+}
+/**
+ * Connects to the specified destination and validates the connection.
+ * Note that a destination may be a system or a service connection.
+ *
+ * @param destination the destination specifying the connection details
+ * @param connectionValidator the connection validator to use for the connection
+ * @param requiredOdataVersion the required OData version for the service, this will be used to narrow the catalog service connections
+ * @param addServicePath the service path to add to the destination URL
+ * @returns the validation result of the destination connection attempt
+ */
+async function connectWithDestination(destination, connectionValidator, requiredOdataVersion, addServicePath) {
+    const { valResult: connectValResult, errorType } = await connectionValidator.validateDestination(destination, (0, utils_1.convertODataVersionType)(requiredOdataVersion), addServicePath);
+    // If authentication failed with an auth error, and the system connection auth type is basic, we will defer validation to the credentials prompt.
+    if (errorType === inquirer_common_1.ERROR_TYPE.AUTH && connectionValidator.systemAuthType === 'basic') {
+        logger_helper_1.default.logger.error((0, i18n_1.t)('errors.destination.authError', { systemName: destination.Name, error: connectValResult }));
+        return true;
+    }
+    // If the connection is successful, we will return the connected system from the inquirer
+    if (connectValResult === true && connectionValidator.serviceProvider) {
+        utils_1.PromptState.odataService.connectedSystem = {
+            serviceProvider: connectionValidator.serviceProvider,
+            destination
+        };
+    }
+    // Deal with all destination errors here
+    return connectValResult;
+}
+/**
+ * Creates and returns a display name for the system, appending the system type and user display name if available.
+ *
+ * @param system the backend system to create a display name for
+ * @returns the display name for the system
+ */
+function getBackendSystemDisplayName(system) {
+    const userDisplayName = system.userDisplayName ? ` [${system.userDisplayName}]` : '';
+    let systemTypeName = '';
+    if (system.authenticationType === 'reentranceTicket') {
+        systemTypeName = ` (${(0, i18n_1.t)('texts.systemTypeS4HC')})`;
+    }
+    if (system.authenticationType === 'oauth2') {
+        systemTypeName = ` (${(0, i18n_1.t)('texts.systemTypeBTP')})`;
+    }
+    return `${system.name}${systemTypeName}${userDisplayName}`;
+}
+/**
+ * Matches the destination against the provided filters. Returns true if the destination matches any filters, false otherwise.
+ *
+ * @param destination
+ * @param filters
+ * @returns true if the destination matches any filters, false otherwise
+ */
+function matchesFilters(destination, filters) {
+    if (!filters) {
+        return true;
+    }
+    if (filters.odata_abap && (0, btp_utils_1.isAbapODataDestination)(destination)) {
+        return true;
+    }
+    if (filters.odata_generic && (0, btp_utils_1.isGenericODataDestination)(destination)) {
+        return true;
+    }
+    if (filters.full_service_url && (0, btp_utils_1.isFullUrlDestination)(destination)) {
+        return true;
+    }
+    if (filters.partial_service_url && (0, btp_utils_1.isPartialUrlDestination)(destination)) {
+        return true;
+    }
+    logger_helper_1.default.logger.debug(`Destination: ${destination.Name} does not match any filters and will be excluded as a prompt choice. Destination configuration: ${JSON.stringify(destination)}`);
+    return false;
+}
+/**
+ * Creates a list of choices for the system selection prompt using destinations or stored backend systems, depending on the environment.
+ *
+ * @param destinationFilters
+ * @param includeCloudFoundryAbapEnvChoice
+ * @returns a list of choices for the system selection prompt
+ */
+async function createSystemChoices(destinationFilters, includeCloudFoundryAbapEnvChoice = false) {
+    let systemChoices = [];
+    let newSystemChoice;
+    // If this is BAS, return destinations, otherwise return stored backend systems
+    if ((0, btp_utils_1.isAppStudio)()) {
+        const destinations = await (0, btp_utils_1.listDestinations)();
+        systemChoices = Object.values(destinations)
+            .filter((destination) => {
+            return matchesFilters(destination, destinationFilters);
+        })
+            .map((destination) => {
+            return {
+                name: (0, btp_utils_1.getDisplayName)(destination),
+                value: {
+                    type: 'destination',
+                    system: destination
+                }
+            };
+        });
+        if (includeCloudFoundryAbapEnvChoice) {
+            newSystemChoice = {
+                name: (0, i18n_1.t)('prompts.newSystemType.choiceCFAbapEnvServiceOnBtp'),
+                value: { type: 'cfAbapEnvService', system: 'cfAbapEnvService' }
+            };
+        }
+    }
+    else {
+        const backendSystems = await new store_1.SystemService(logger_helper_1.default.logger).getAll();
+        systemChoices = backendSystems.map((system) => {
+            return {
+                name: getBackendSystemDisplayName(system),
+                value: {
+                    system,
+                    type: 'backendSystem'
+                }
+            };
+        });
+        newSystemChoice = {
+            name: (0, i18n_1.t)('prompts.systemSelection.newSystemChoiceLabel'),
+            value: { system: questions_1.newSystemChoiceValue, type: 'newSystemChoice' }
+        };
+    }
+    systemChoices.sort(({ name: nameA }, { name: nameB }) => nameA.localeCompare(nameB, undefined, { numeric: true, caseFirst: 'lower' }));
+    if (newSystemChoice) {
+        systemChoices.unshift(newSystemChoice);
+    }
+    return systemChoices;
+}
+//# sourceMappingURL=prompt-helpers.js.map

package/dist/prompts/datasources/sap-system/system-selection/questions.d.ts

@@ -0,0 +1,40 @@
+import type { Destination } from '@sap-ux/btp-utils';
+import type { BackendSystem } from '@sap-ux/store';
+import type { Question } from 'inquirer';
+import { promptNames, type OdataServicePromptOptions } from '../../../../types';
+import { ConnectionValidator } from '../../../connectionValidator';
+import type { ServiceAnswer } from '../service-selection';
+export declare const newSystemChoiceValue = "!@\u00A3*&937newSystem*X~qy^";
+type NewSystemChoice = typeof newSystemChoiceValue;
+declare const usernamePromptName: "systemSelection:systemUsername";
+declare const passwordPromptName: "systemSelection:systemPassword";
+export type SystemSelectionAnswerType = {
+    type: 'destination' | 'backendSystem' | 'newSystemChoice' | 'cfAbapEnvService';
+    system: Destination | BackendSystem | NewSystemChoice | 'cfAbapEnvService';
+};
+interface SystemSelectionCredentialsAnswers {
+    [usernamePromptName]?: string;
+    [passwordPromptName]?: string;
+}
+export interface SystemSelectionAnswers extends SystemSelectionCredentialsAnswers {
+    [promptNames.systemSelection]?: SystemSelectionAnswerType;
+}
+/**
+ * Returns a list of questions for creating a new system configuration or selecting an existing stored system.
+ *
+ * @param promptOptions prompt options that may be used to customize the questions
+ * @returns a list of questions for creating a new system configuration or selecting an existing stored system
+ */
+export declare function getSystemSelectionQuestions(promptOptions?: OdataServicePromptOptions): Promise<Question<SystemSelectionAnswers & ServiceAnswer>[]>;
+/**
+ * Returns a list of existing systems, either destinations or backend systems from persistent store, depending on the environment.
+ * Note that destinations are only available in BAS environment and must include the destination attribute `WebIDEEnabled` to be listed.
+ * Additional destination attribute filters may be provided.
+ *
+ * @param connectionValidator A reference to the active connection validator, used to validate the service selection and retrieve service details.
+ * @param promptOptions
+ * @returns a list of existing systems
+ */
+export declare function getSystemConnectionQuestions(connectionValidator: ConnectionValidator, promptOptions?: OdataServicePromptOptions): Promise<Question<SystemSelectionAnswers>[]>;
+export {};
+//# sourceMappingURL=questions.d.ts.map

package/dist/prompts/datasources/sap-system/system-selection/questions.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newSystemChoiceValue = void 0;
+exports.getSystemSelectionQuestions = getSystemSelectionQuestions;
+exports.getSystemConnectionQuestions = getSystemConnectionQuestions;
+const yeoman_ui_types_1 = require("@sap-devx/yeoman-ui-types");
+const btp_utils_1 = require("@sap-ux/btp-utils");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
+const i18n_1 = require("../../../../i18n");
+const types_1 = require("../../../../types");
+const utils_1 = require("../../../../utils");
+const connectionValidator_1 = require("../../../connectionValidator");
+const logger_helper_1 = __importDefault(require("../../../logger-helper"));
+const questions_1 = require("../credentials/questions");
+const questions_2 = require("../new-system/questions");
+const questions_3 = require("../service-selection/questions");
+const validators_1 = require("../validators");
+const prompt_helpers_1 = require("./prompt-helpers");
+const fiori_generator_shared_1 = require("@sap-ux/fiori-generator-shared");
+// New system choice value is a hard to guess string to avoid conflicts with existing system names or user named systems
+// since it will be used as a new system value in the system selection prompt.
+exports.newSystemChoiceValue = '!@£*&937newSystem*X~qy^';
+const systemSelectionPromptNamespace = 'systemSelection';
+const usernamePromptName = `${systemSelectionPromptNamespace}:${questions_1.BasicCredentialsPromptNames.systemUsername}`;
+const passwordPromptName = `${systemSelectionPromptNamespace}:${questions_1.BasicCredentialsPromptNames.systemPassword}`;
+const systemSelectionPromptNames = {
+    systemSelectionCli: 'systemSelectionCli',
+    destinationServicePath: 'destinationServicePath'
+};
+/**
+ * Validates the system selection, connecting to the selected system and validating the connection.
+ *
+ * @param systemSelection
+ * @param connectionValidator
+ * @param requiredOdataVersion
+ * @returns the validation result of the selected system connection attempt
+ */
+async function validateSystemSelection(systemSelection, connectionValidator, requiredOdataVersion) {
+    utils_1.PromptState.reset();
+    if (systemSelection.type === 'newSystemChoice') {
+        return true;
+    }
+    let connectValResult = false;
+    if (systemSelection.type === 'backendSystem') {
+        connectValResult = await (0, prompt_helpers_1.connectWithBackendSystem)(systemSelection.system, connectionValidator, requiredOdataVersion);
+    }
+    else if (systemSelection.type === 'destination') {
+        // Partial URL destinations will require additional service path prompt input, so we skip the connection validation here by returning true
+        // The service URL connection will need to be validated by the service path prompt
+        if ((0, btp_utils_1.isPartialUrlDestination)(systemSelection.system)) {
+            // Reset the connection state as we are deferring the connection validation to the service path prompt, any existing connection state should be cleared
+            // connectionValidator.resetConnectionState(true);
+            return true;
+        }
+        connectValResult = await (0, prompt_helpers_1.connectWithDestination)(systemSelection.system, connectionValidator, requiredOdataVersion);
+    }
+    return connectValResult;
+}
+/**
+ * Returns a list of questions for creating a new system configuration or selecting an existing stored system.
+ *
+ * @param promptOptions prompt options that may be used to customize the questions
+ * @returns a list of questions for creating a new system configuration or selecting an existing stored system
+ */
+async function getSystemSelectionQuestions(promptOptions) {
+    utils_1.PromptState.reset();
+    const connectValidator = new connectionValidator_1.ConnectionValidator();
+    const questions = await getSystemConnectionQuestions(connectValidator, promptOptions);
+    // Existing system (BackendSystem or Destination) selected,
+    // In future, make the service prompt optional by wrapping in condition `[promptOptions?.serviceSelection?.hide]`
+    questions.push(...(0, inquirer_common_1.withCondition)((0, questions_3.getSystemServiceQuestion)(connectValidator, systemSelectionPromptNamespace, promptOptions), (answers) => answers.systemSelection?.type !== 'newSystemChoice'));
+    // Create new system connection for storage only supported on non-App Studio environments
+    if (!(0, btp_utils_1.isAppStudio)()) {
+        questions.push(...(0, inquirer_common_1.withCondition)((0, questions_2.getNewSystemQuestions)(promptOptions), (answers) => answers.systemSelection?.type === 'newSystemChoice'));
+    }
+    return questions;
+}
+/**
+ * Returns a list of existing systems, either destinations or backend systems from persistent store, depending on the environment.
+ * Note that destinations are only available in BAS environment and must include the destination attribute `WebIDEEnabled` to be listed.
+ * Additional destination attribute filters may be provided.
+ *
+ * @param connectionValidator A reference to the active connection validator, used to validate the service selection and retrieve service details.
+ * @param promptOptions
+ * @returns a list of existing systems
+ */
+async function getSystemConnectionQuestions(connectionValidator, promptOptions) {
+    const requiredOdataVersion = promptOptions?.serviceSelection?.requiredOdataVersion;
+    const destinationFilters = promptOptions?.systemSelection?.destinationFilters;
+    const systemChoices = await (0, prompt_helpers_1.createSystemChoices)(destinationFilters, promptOptions?.systemSelection?.includeCloudFoundryAbapEnvChoice);
+    const questions = [
+        {
+            type: promptOptions?.systemSelection?.useAutoComplete ? 'autocomplete' : 'list',
+            name: types_1.promptNames.systemSelection,
+            message: (0, i18n_1.t)('prompts.systemSelection.message'),
+            source: (prevAnswers, input) => (0, inquirer_common_1.searchChoices)(input, systemChoices),
+            choices: systemChoices,
+            validate: async (selectedSystem) => {
+                if (!selectedSystem) {
+                    return false;
+                }
+                let selectedSystemAnswer = selectedSystem;
+                // Autocomplete passes the entire choice object as the answer, so we need to extract the value
+                if (promptOptions?.systemSelection?.useAutoComplete && selectedSystem.value) {
+                    selectedSystemAnswer = selectedSystem.value;
+                }
+                return (validateSystemSelection(selectedSystemAnswer, connectionValidator, requiredOdataVersion) ?? false);
+            },
+            additionalMessages: async (selectedSystem) => {
+                // Backend systems credentials may need to be updated
+                if (selectedSystem.type === 'backendSystem' &&
+                    connectionValidator.systemAuthType === 'basic' &&
+                    (await connectionValidator.isAuthRequired())) {
+                    return {
+                        message: (0, i18n_1.t)('prompts.systemSelection.authenticationFailedUpdateCredentials'),
+                        severity: yeoman_ui_types_1.Severity.information
+                    };
+                }
+            }
+        }
+    ];
+    if ((0, btp_utils_1.isAppStudio)()) {
+        // Additional service path prompt for partial URL destinations
+        const servicePathPrompt = {
+            when: (answers) => {
+                const selectedSystem = answers?.[types_1.promptNames.systemSelection];
+                if (selectedSystem?.type === 'destination') {
+                    return (0, btp_utils_1.isPartialUrlDestination)(selectedSystem.system);
+                }
+                return false;
+            },
+            type: 'input',
+            name: systemSelectionPromptNames.destinationServicePath,
+            message: (0, i18n_1.t)('prompts.destinationServicePath.message'),
+            guiOptions: {
+                hint: (0, i18n_1.t)('prompts.destinationServicePath.hint'),
+                mandatory: true,
+                breadcrumb: true
+            },
+            validate: async (servicePath, answers) => {
+                if (!servicePath) {
+                    return (0, i18n_1.t)('prompts.destinationServicePath.invalidServicePathWarning');
+                }
+                // Validate format of the service path, note this relies on the assumption that the destination is correctly configured with a valid URL
+                const selectedDestination = answers?.[types_1.promptNames.systemSelection]?.system;
+                const valUrlResult = (0, validators_1.validateServiceUrl)(selectedDestination.Host, servicePath);
+                if (valUrlResult !== true) {
+                    return valUrlResult;
+                }
+                const connectValResult = await (0, prompt_helpers_1.connectWithDestination)(selectedDestination, connectionValidator, requiredOdataVersion, servicePath);
+                return connectValResult;
+            }
+        };
+        questions.push(servicePathPrompt);
+    }
+    // Only for CLI use as `list` prompt validation does not run on CLI unless autocomplete plugin is used
+    if ((0, utils_1.getPromptHostEnvironment)() === fiori_generator_shared_1.hostEnvironment.cli && !promptOptions?.systemSelection?.useAutoComplete) {
+        questions.push({
+            when: async (answers) => {
+                const selectedSystem = answers?.[types_1.promptNames.systemSelection];
+                if (!selectedSystem) {
+                    return false;
+                }
+                const connectValResult = await validateSystemSelection(selectedSystem, connectionValidator, requiredOdataVersion);
+                // An issue occurred with the selected system, there is no need to continue on the CLI, log and exit
+                // Note that for connection authentication errors, the result will be true, the user will be prompted to update their credentials in the next prompt
+                if (connectValResult !== true) {
+                    logger_helper_1.default.logger.error(connectValResult.toString);
+                    throw new Error(connectValResult.toString());
+                }
+                return false;
+            },
+            name: `${systemSelectionPromptNames.systemSelectionCli}`
+        });
+    }
+    questions.push(...(0, questions_1.getCredentialsPrompts)(connectionValidator, systemSelectionPromptNamespace));
+    return questions;
+}
+//# sourceMappingURL=questions.js.map

package/dist/prompts/datasources/sap-system/validators.d.ts

@@ -13,4 +13,12 @@ export declare function validateSystemName(systemName: string): Promise<boolean
  * @returns the service key info if the file is valid, otherwise an error message
  */
 export declare function validateServiceKey(path: string): string | ServiceInfo | boolean;
+/**
+ * Validates the specified origin and service path can be used to form a valid URL.
+ *
+ * @param origin the origin of the service
+ * @param servicePath the path to the service
+ * @returns true if a URL can be created from the specified parameters, otherwise an error message
+ */
+export declare function validateServiceUrl(origin: string, servicePath: string): string | boolean;
 //# sourceMappingURL=validators.d.ts.map

package/dist/prompts/datasources/sap-system/validators.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSystemName = validateSystemName;
 exports.validateServiceKey = validateServiceKey;
+exports.validateServiceUrl = validateServiceUrl;
 const i18n_1 = require("../../../i18n");
 const store_1 = require("@sap-ux/store");
 const logger_helper_1 = __importDefault(require("../../logger-helper"));
@@ -59,4 +60,20 @@ function validateServiceKey(path) {
         return error.name === 'SyntaxError' ? (0, i18n_1.t)('prompts.serviceKey.unparseableServiceKey') : error.message;
     }
 }
+/**
+ * Validates the specified origin and service path can be used to form a valid URL.
+ *
+ * @param origin the origin of the service
+ * @param servicePath the path to the service
+ * @returns true if a URL can be created from the specified parameters, otherwise an error message
+ */
+function validateServiceUrl(origin, servicePath) {
+    try {
+        new URL(servicePath, origin);
+        return true;
+    }
+    catch (error) {
+        return (0, i18n_1.t)('errors.invalidUrl', { input: `${origin}${servicePath}` });
+    }
+}
 //# sourceMappingURL=validators.js.map

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

@@ -12,6 +12,7 @@ const connectionValidator_1 = require("../../connectionValidator");
 const logger_helper_1 = __importDefault(require("../../logger-helper"));
 const types_2 = require("./types");
 const validators_1 = require("./validators");
+const fiori_generator_shared_1 = require("@sap-ux/fiori-generator-shared");
 /**
  * Prompt for the service URL.
  *
@@ -168,15 +169,15 @@ function getPasswordPrompt(connectValidator, requiredVersion) {
             applyDefaultWhenDirty: true,
             mandatory: true
         },
+        guiType: 'login',
         name: types_1.promptNames.serviceUrlPassword,
         message: (0, i18n_1.t)('prompts.servicePassword.message'),
-        guiType: 'login',
         mask: '*',
         validate: async (password, { username, serviceUrl, ignoreCertError, sapClient }) => {
             if (!serviceUrl || !username || !password) {
                 return false;
             }
-            const validAuth = await connectValidator.validateAuth(serviceUrl, username, password, {
+            const { valResult: validAuth } = await connectValidator.validateAuth(serviceUrl, username, password, {
                 ignoreCertError,
                 sapClient
             });
@@ -207,7 +208,7 @@ function getServiceUrlQuestions({ serviceUrl: serviceUrlOpts, serviceUrlPassword
         getServiceUrlPrompt(connectValidator, requiredVersion),
         getIgnoreCertErrorsPrompt(connectValidator, requiredVersion)
     ];
-    if ((0, utils_1.getHostEnvironment)() === types_1.hostEnvironment.cli) {
+    if ((0, utils_1.getPromptHostEnvironment)() === fiori_generator_shared_1.hostEnvironment.cli) {
         questions.push(getCliIgnoreCertValidatePrompt(connectValidator, requiredVersion));
     }
     questions.push(getUsernamePrompt(connectValidator), getPasswordPrompt(connectValidator, requiredVersion));

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

@@ -5,13 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateService = validateService;
 const axios_extension_1 = require("@sap-ux/axios-extension");
-const error_handler_1 = require("../../../error-handler/error-handler");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
 const i18n_1 = require("../../../i18n");
 const types_1 = require("../../../types");
 const utils_1 = require("../../../utils");
 const connectionValidator_1 = require("../../connectionValidator");
 const logger_helper_1 = __importDefault(require("../../logger-helper"));
 const prompt_helpers_1 = require("../../prompt-helpers");
+const validators_1 = require("../../validators");
 /**
  * Validates that a service specified by the service url is accessible, has the required version and returns valid metadata.
  * Retrieves annotations (from Abap backends) if available and stores them in the PromptState.
@@ -30,13 +31,11 @@ async function validateService(url, { odataService, axiosConfig }, requiredVersi
             connectionValidator_1.ConnectionValidator.setGlobalRejectUnauthorized(!ignoreCertError);
         }
         const metadata = await odataService.metadata();
-        const serviceOdataVersion = (0, utils_1.parseOdataVersion)(metadata);
-        if (requiredVersion && requiredVersion !== serviceOdataVersion) {
-            return `${(0, i18n_1.t)('errors.odataServiceVersionMismatch', {
-                serviceVersion: serviceOdataVersion,
-                requiredVersion
-            })}`;
+        const odataVersionValResult = (0, validators_1.validateODataVersion)(metadata, requiredVersion);
+        if (odataVersionValResult.validationMsg) {
+            return odataVersionValResult.validationMsg;
         }
+        const serviceOdataVersion = odataVersionValResult.version;
         // Remove all occurrences of the origin from the metadata to make backend uris relative
         utils_1.PromptState.odataService.metadata = (0, utils_1.originToRelative)(metadata);
         utils_1.PromptState.odataService.odataVersion = serviceOdataVersion;
@@ -69,9 +68,9 @@ async function validateService(url, { odataService, axiosConfig }, requiredVersi
     catch (error) {
         delete utils_1.PromptState.odataService.metadata;
         // Provide a more specific error message if the metadata service URL is not found
-        if (error_handler_1.ErrorHandler.getErrorType(error) === error_handler_1.ERROR_TYPE.NOT_FOUND) {
+        if (inquirer_common_1.ErrorHandler.getErrorType(error) === inquirer_common_1.ERROR_TYPE.NOT_FOUND) {
             // No metadata implies not a valid odata service
-            return error_handler_1.ErrorHandler.getErrorMsgFromType(error_handler_1.ERROR_TYPE.ODATA_URL_NOT_FOUND) ?? false;
+            return inquirer_common_1.ErrorHandler.getErrorMsgFromType(inquirer_common_1.ERROR_TYPE.ODATA_URL_NOT_FOUND) ?? false;
         }
         return prompt_helpers_1.errorHandler.logErrorMsgs(error);
     }

package/dist/prompts/prompt-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { ListChoiceOptions } from 'inquirer';
-import { ErrorHandler } from '../error-handler/error-handler';
+import { ErrorHandler } from '@sap-ux/inquirer-common';
 import { type DatasourceTypePromptOptions } from '../types';
 export declare const errorHandler: ErrorHandler;
 /**
@@ -7,8 +7,7 @@ export declare const errorHandler: ErrorHandler;
  *
  * @param options - optionally include some of the supported datasource type choices
  * @param options.includeNone - Include the `NONE` option in the datasource type prompt
- * @param options.includeProjectSpecificDest - Include the `projectSpecificDestination` option in the datasource type prompt
  * @returns The datasource type choices
  */
-export declare function getDatasourceTypeChoices({ includeNone, includeProjectSpecificDest }?: DatasourceTypePromptOptions): ListChoiceOptions[];
+export declare function getDatasourceTypeChoices({ includeNone }?: DatasourceTypePromptOptions): ListChoiceOptions[];
 //# sourceMappingURL=prompt-helpers.d.ts.map

package/dist/prompts/prompt-helpers.js

@@ -2,21 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
 exports.getDatasourceTypeChoices = getDatasourceTypeChoices;
-const btp_utils_1 = require("@sap-ux/btp-utils");
-const error_handler_1 = require("../error-handler/error-handler");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
 const i18n_1 = require("../i18n");
 const types_1 = require("../types");
 // Error handling is a cross-cutting concern, a single instance is required
-exports.errorHandler = new error_handler_1.ErrorHandler();
+exports.errorHandler = new inquirer_common_1.ErrorHandler();
 /**
  * Get the datasource type choices.
  *
  * @param options - optionally include some of the supported datasource type choices
  * @param options.includeNone - Include the `NONE` option in the datasource type prompt
- * @param options.includeProjectSpecificDest - Include the `projectSpecificDestination` option in the datasource type prompt
  * @returns The datasource type choices
  */
-function getDatasourceTypeChoices({ includeNone = false, includeProjectSpecificDest = false } = {}) {
+function getDatasourceTypeChoices({ includeNone = false } = {}) {
     const choices = [
         {
             name: (0, i18n_1.t)('prompts.datasourceType.sapSystemChoiceText'),
@@ -25,15 +23,8 @@ function getDatasourceTypeChoices({ includeNone = false, includeProjectSpecificD
         {
             name: (0, i18n_1.t)('prompts.datasourceType.odataServiceUrlChoiceText'),
             value: types_1.DatasourceType.odataServiceUrl
-        },
-        { name: (0, i18n_1.t)('prompts.datasourceType.businessHubChoiceText'), value: types_1.DatasourceType.businessHub }
+        }
     ];
-    if ((0, btp_utils_1.isAppStudio)() && includeProjectSpecificDest) {
-        choices.push({
-            name: (0, i18n_1.t)('prompts.datasourceType.projectSpecificDestChoiceText'),
-            value: types_1.DatasourceType.projectSpecificDestination
-        });
-    }
     choices.push({ name: (0, i18n_1.t)('prompts.datasourceType.capProjectChoiceText'), value: types_1.DatasourceType.capProject });
     choices.push({ name: (0, i18n_1.t)('prompts.datasourceType.metadataFileChoiceText'), value: types_1.DatasourceType.metadataFile });
     if (includeNone) {