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

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

@@ -0,0 +1,71 @@
+import { type IMessageSeverity } from '@sap-devx/yeoman-ui-types';
+import { type CatalogService, ServiceType, V2CatalogService } from '@sap-ux/axios-extension';
+import type { Destination } from '@sap-ux/btp-utils';
+import { OdataVersion } from '@sap-ux/odata-service-writer';
+import type { ListChoiceOptions } from 'inquirer';
+import type { ConnectionValidator } from '../../../connectionValidator';
+import type { ServiceAnswer } from './types';
+export declare const telemEventBASServiceSuccess = "SERVICE_INQUIRER_BAS_SUCCESS";
+/**
+ * Refines the error type and logs based on the specified options. This should log more precise error messages based on inputs
+ * and the platform making the call i.e. VSC | SBAS. Errors are mapped to GA links if the platform is SBAS.
+ *
+ * @param options Options
+ * @param options.system - sap system used
+ * @param options.catRequestErrorTypes - all catalog service request error types, used to do further root cause analysis
+ * @param options.rootCauseErrorType - the error type as determined by the caller, will be used if a more precise error type cannot be determined by rca
+ * @param options.logMsg - the log message that will be used if a better root cause is not determined
+ * @param options.error - the original error, used to determine the error log message if otherwise not determined
+ * @param option.reqVersion - specific odata version that is required by the template
+ */
+/**
+ * Get the service choices from the specified catalogs.
+ *
+ * @param catalogs catalogs to get the services from. There should be one per odata version required.
+ * @returns service choices based on the provided catalogs
+ */
+export declare function getServiceChoices(catalogs: CatalogService[]): Promise<ListChoiceOptions<ServiceAnswer>[]>;
+/**
+ * Generates a telemetry event for successfully listing service(s) using a destination.
+ *
+ * @param destination the destination used to list the service(s)
+ */
+export declare function sendDestinationServiceSuccessTelemetryEvent(destination: Destination): void;
+/**
+ * Get service type for 'Not Determined' services from `ServiceTypeForHUBServices()`
+ *
+ * @param servicePath service path
+ * @param serviceType service type
+ * @param catalog the catalog service used to get the service type for the specified service path
+ * @returns service type
+ */
+export declare function getServiceType(servicePath: string, serviceType: string | undefined, catalog: V2CatalogService): Promise<ServiceType | undefined>;
+/**
+ * Requests and sets the service details to the PromptState.odataService properties.
+ * If an error occurs, the error message is returned for use in validators.
+ *
+ * @param service the specific service to get details for
+ * @param connectionValidator a reference to the connection validator which has an active connection to the backend
+ * @param requiredOdataVersion
+ * @returns true if successful, setting the PromptState.odataService properties, or an error message indicating why the service details could not be retrieved.
+ */
+export declare function getServiceDetails(service: ServiceAnswer, connectionValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion): Promise<string | boolean>;
+/**
+ * Create a value for the service selection prompt message, which may include thge active connected user name.
+ *
+ * @param username The connected user name
+ * @returns The service selection prompt message
+ */
+export declare function getSelectedServiceLabel(username: string | undefined): string;
+/**
+ * Get the service selection prompt additional message. This prompt will make an additional call to the system backend
+ * to retrieve the service type and display a warning message if the service type is not UI.
+ *
+ * @param serviceChoices a list of service choices
+ * @param selectedService the selected service
+ * @param connectValidator the connection validator
+ * @param requiredOdataVersion the required OData version for the service
+ * @returns the service selection prompt additional message
+ */
+export declare function getSelectedServiceMessage(serviceChoices: ListChoiceOptions<ServiceAnswer>[], selectedService: ServiceAnswer, connectValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion): Promise<IMessageSeverity | undefined>;
+//# sourceMappingURL=service-helper.d.ts.map

package/dist/prompts/datasources/sap-system/service-selection/service-helper.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemEventBASServiceSuccess = void 0;
+exports.getServiceChoices = getServiceChoices;
+exports.sendDestinationServiceSuccessTelemetryEvent = sendDestinationServiceSuccessTelemetryEvent;
+exports.getServiceType = getServiceType;
+exports.getServiceDetails = getServiceDetails;
+exports.getSelectedServiceLabel = getSelectedServiceLabel;
+exports.getSelectedServiceMessage = getSelectedServiceMessage;
+const yeoman_ui_types_1 = require("@sap-devx/yeoman-ui-types");
+const axios_extension_1 = require("@sap-ux/axios-extension");
+const fiori_generator_shared_1 = require("@sap-ux/fiori-generator-shared");
+const odata_service_writer_1 = require("@sap-ux/odata-service-writer");
+const i18n_1 = require("../../../../i18n");
+const utils_1 = require("../../../../utils");
+const logger_helper_1 = __importDefault(require("../../../logger-helper"));
+const prompt_helpers_1 = require("../../../prompt-helpers");
+const validators_1 = require("../../../validators");
+// Service ids continaining these paths should not be offered as UI compatible services
+const nonUIServicePaths = ['/IWBEP/COMMON/'];
+// Telemetry event name for successful service validation on BAS, note: legacy event names should not be changed
+exports.telemEventBASServiceSuccess = 'SERVICE_INQUIRER_BAS_SUCCESS';
+/**
+ * Builds and formats the service choices list.
+ *
+ * @param serviceInfos service information to build the choices from. Services with a service id containing '/IWBEP/COMMON' are ignored.
+ * @returns service choices list
+ */
+const createServiceChoices = (serviceInfos) => {
+    const choices = [];
+    // Provide additional service information in trace mode (YUI only)
+    let isLogTrace = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Only specific loggers have this method
+    if (typeof logger_helper_1.default.logger.getLogLevel === 'function') {
+        isLogTrace = logger_helper_1.default.logger.getLogLevel() === 'trace';
+    }
+    serviceInfos
+        // Exclude non-UI compatible services
+        ?.filter((service) => !nonUIServicePaths.some((path) => service.path.includes(path)))
+        .forEach((service) => {
+        let serviceName = service.name;
+        const servicePath = service.path;
+        serviceName = `${serviceName} (${service.serviceVersion}) - OData V${service.odataVersion}`;
+        if (isLogTrace) {
+            serviceName = `${serviceName} Service Type: ${service.serviceType}`;
+        }
+        choices.push({
+            name: serviceName,
+            value: {
+                servicePath,
+                serviceODataVersion: service.odataVersion,
+                toString: () => serviceName,
+                serviceType: service.serviceType
+            }
+        });
+    });
+    return choices.sort((a, b) => (a.name ? a.name.localeCompare(b.name ?? '') : 0));
+};
+/**
+ * Logs the catalog request errors using the error handler.
+ *
+ * @param requestErrors catalog request errors, keyed by the OData version of the catalog service, with the error, status code number or error message as the value
+ * @param numOfRequests
+ */
+function logServiceCatalogErrorsForHelp(requestErrors, numOfRequests) {
+    const catalogRequesErrors = Object.values(requestErrors);
+    catalogRequesErrors.forEach((error) => {
+        prompt_helpers_1.errorHandler.logErrorMsgs(error); // Log and process the error -> error type
+    });
+    // If all requests failed, log a generic message, this will be stored in the error handler
+    if (numOfRequests === catalogRequesErrors.length) {
+        prompt_helpers_1.errorHandler.logErrorMsgs((0, i18n_1.t)('errors.allCatalogServiceRequestsFailed', { version: Object.keys(requestErrors).join(', ') }));
+    }
+}
+/**
+ * Refines the error type and logs based on the specified options. This should log more precise error messages based on inputs
+ * and the platform making the call i.e. VSC | SBAS. Errors are mapped to GA links if the platform is SBAS.
+ *
+ * @param options Options
+ * @param options.system - sap system used
+ * @param options.catRequestErrorTypes - all catalog service request error types, used to do further root cause analysis
+ * @param options.rootCauseErrorType - the error type as determined by the caller, will be used if a more precise error type cannot be determined by rca
+ * @param options.logMsg - the log message that will be used if a better root cause is not determined
+ * @param options.error - the original error, used to determine the error log message if otherwise not determined
+ * @param option.reqVersion - specific odata version that is required by the template
+ */
+/**
+ * Get the service choices from the specified catalogs.
+ *
+ * @param catalogs catalogs to get the services from. There should be one per odata version required.
+ * @returns service choices based on the provided catalogs
+ */
+async function getServiceChoices(catalogs) {
+    const requestErrors = {};
+    const listServicesRequests = catalogs.map(async (catalog) => {
+        try {
+            return await catalog.listServices();
+        }
+        catch (error) {
+            logger_helper_1.default.logger.error((0, i18n_1.t)('errors.serviceCatalogRequest', {
+                catalogRequestUri: catalog.getUri(),
+                entitySet: catalog.entitySet,
+                error
+            }));
+            // Save any errors for processing later as we may show more useful message to the user
+            Object.assign(requestErrors, {
+                [catalog instanceof axios_extension_1.V2CatalogService ? axios_extension_1.ODataVersion.v2 : axios_extension_1.ODataVersion.v4]: error
+            });
+            return [];
+        }
+    });
+    const serviceInfos = await Promise.all(listServicesRequests);
+    const flatServices = serviceInfos?.flat() ?? [];
+    logger_helper_1.default.logger.debug(`Number of services available: ${flatServices.length}`);
+    if (flatServices.length === 0) {
+        logServiceCatalogErrorsForHelp(requestErrors, catalogs.length);
+    }
+    return createServiceChoices(flatServices);
+}
+/**
+ * Generates a telemetry event for successfully listing service(s) using a destination.
+ *
+ * @param destination the destination used to list the service(s)
+ */
+function sendDestinationServiceSuccessTelemetryEvent(destination) {
+    // May return undefined if the same event was already sent within some time frame
+    const telemetryData = fiori_generator_shared_1.TelemetryHelper.createTelemetryData({
+        destODataType: (0, utils_1.getTelemPropertyDestinationType)(destination)
+    }) ?? {};
+    (0, utils_1.sendTelemetryEvent)(exports.telemEventBASServiceSuccess, telemetryData);
+}
+/**
+ * Gets the service metadata and annotations for the specified service path.
+ *
+ * @param servicePath service path
+ * @param odataService the odata service used to get the metadata for the specified service path
+ * @param catalog the catalog service used to get the annotations for the specified service path
+ * @returns Promise<string | boolean>, string error message or true if successful
+ */
+async function getServiceMetadata(servicePath, odataService, catalog) {
+    let annotations = [];
+    try {
+        if (catalog) {
+            try {
+                annotations = await catalog.getAnnotations({ path: servicePath });
+            }
+            catch {
+                logger_helper_1.default.logger.info((0, i18n_1.t)('prompts.validationMessages.noAnnotations'));
+            }
+        }
+        const metadata = await odataService.metadata();
+        return {
+            annotations,
+            metadata
+        };
+    }
+    catch (error) {
+        logger_helper_1.default.logger.error((0, i18n_1.t)('errors.serviceMetadataErrorLog', { servicePath, error }));
+        return (0, i18n_1.t)('errors.serviceMetadataErrorUI', { servicePath });
+    }
+}
+/**
+ * Get service type for 'Not Determined' services from `ServiceTypeForHUBServices()`
+ *
+ * @param servicePath service path
+ * @param serviceType service type
+ * @param catalog the catalog service used to get the service type for the specified service path
+ * @returns service type
+ */
+async function getServiceType(servicePath, serviceType, catalog) {
+    let resolvedServiceType;
+    if (serviceType === axios_extension_1.ServiceType.NotDetermined) {
+        try {
+            resolvedServiceType = (await catalog.getServiceType(servicePath)) ?? axios_extension_1.ServiceType.NotDetermined;
+        }
+        catch (e) {
+            logger_helper_1.default.logger.error((0, i18n_1.t)('errors.serviceTypeRequestError', { error: e.message }));
+        }
+    }
+    return resolvedServiceType ?? serviceType;
+}
+/**
+ * Requests and sets the service details to the PromptState.odataService properties.
+ * If an error occurs, the error message is returned for use in validators.
+ *
+ * @param service the specific service to get details for
+ * @param connectionValidator a reference to the connection validator which has an active connection to the backend
+ * @param requiredOdataVersion
+ * @returns true if successful, setting the PromptState.odataService properties, or an error message indicating why the service details could not be retrieved.
+ */
+async function getServiceDetails(service, connectionValidator, requiredOdataVersion) {
+    const serviceCatalog = connectionValidator.catalogs?.[service.serviceODataVersion];
+    if (!connectionValidator.serviceProvider) {
+        logger_helper_1.default.logger.error('ConnectionValidator connection is not initialized');
+        return false;
+    }
+    // We may already have an odata service endpoint connection
+    let odataService = connectionValidator.odataService;
+    if (!odataService) {
+        odataService = connectionValidator.serviceProvider.service(service.servicePath);
+    }
+    const serviceResult = await getServiceMetadata(service.servicePath, odataService, serviceCatalog);
+    if (typeof serviceResult === 'string') {
+        return serviceResult;
+    }
+    const { validationMsg, version } = (0, validators_1.validateODataVersion)(serviceResult.metadata, requiredOdataVersion);
+    if (validationMsg) {
+        return validationMsg;
+    }
+    // If destinationUrl is available, use it, as validatedUrl may be in the form <protocal>:<destinationName>.dest
+    const url = connectionValidator.destinationUrl ?? connectionValidator.validatedUrl;
+    let origin;
+    if (url) {
+        origin = new URL(url).origin;
+    }
+    utils_1.PromptState.odataService.annotations = serviceResult?.annotations;
+    utils_1.PromptState.odataService.metadata = serviceResult?.metadata;
+    utils_1.PromptState.odataService.odataVersion =
+        version ?? service.serviceODataVersion === axios_extension_1.ODataVersion.v2 ? odata_service_writer_1.OdataVersion.v2 : odata_service_writer_1.OdataVersion.v4;
+    utils_1.PromptState.odataService.servicePath = service.servicePath;
+    utils_1.PromptState.odataService.origin = origin;
+    utils_1.PromptState.odataService.sapClient = connectionValidator.validatedClient;
+    return true;
+}
+/**
+ * Create a value for the service selection prompt message, which may include thge active connected user name.
+ *
+ * @param username The connected user name
+ * @returns The service selection prompt message
+ */
+function getSelectedServiceLabel(username) {
+    let message = (0, i18n_1.t)('prompts.systemService.message');
+    if (username) {
+        message = message.concat(` ${(0, i18n_1.t)('texts.forUserName', { username })}`);
+    }
+    return message;
+}
+/**
+ * Get the service selection prompt additional message. This prompt will make an additional call to the system backend
+ * to retrieve the service type and display a warning message if the service type is not UI.
+ *
+ * @param serviceChoices a list of service choices
+ * @param selectedService the selected service
+ * @param connectValidator the connection validator
+ * @param requiredOdataVersion the required OData version for the service
+ * @returns the service selection prompt additional message
+ */
+async function getSelectedServiceMessage(serviceChoices, selectedService, connectValidator, requiredOdataVersion) {
+    if (serviceChoices?.length === 0) {
+        if (requiredOdataVersion) {
+            return {
+                message: (0, i18n_1.t)('prompts.warnings.noServicesAvailableForOdataVersion', {
+                    odataVersion: requiredOdataVersion
+                }),
+                severity: yeoman_ui_types_1.Severity.warning
+            };
+        }
+        else {
+            return {
+                message: (0, i18n_1.t)('prompts.warnings.noServicesAvailable'),
+                severity: yeoman_ui_types_1.Severity.warning
+            };
+        }
+    }
+    if (selectedService) {
+        let serviceType = selectedService.serviceType;
+        if (selectedService.serviceODataVersion === axios_extension_1.ODataVersion.v2) {
+            serviceType = await getServiceType(selectedService.servicePath, selectedService.serviceType, connectValidator.catalogs[axios_extension_1.ODataVersion.v2]);
+        }
+        if (serviceType && serviceType !== axios_extension_1.ServiceType.UI) {
+            return {
+                message: (0, i18n_1.t)('prompts.warnings.nonUIServiceTypeWarningMessage', { serviceType: 'A2X' }),
+                severity: yeoman_ui_types_1.Severity.warning
+            };
+        }
+    }
+}
+//# sourceMappingURL=service-helper.js.map

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

@@ -0,0 +1,11 @@
+import type { ODataVersion } from '@sap-ux/axios-extension';
+/**
+ * Sap System service answer
+ */
+export type ServiceAnswer = {
+    servicePath: string;
+    serviceODataVersion: ODataVersion;
+    toString: () => string;
+    serviceType?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/prompts/datasources/sap-system/service-selection/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,2 @@
+export * from './questions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./questions"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,44 @@
+import type { Destination } from '@sap-ux/btp-utils';
+import type { OdataVersion } from '@sap-ux/odata-service-writer';
+import type { BackendSystem } from '@sap-ux/store';
+import type { ListChoiceOptions } from 'inquirer';
+import { type DestinationFilters } from '../../../../types';
+import type { ConnectionValidator, ValidationResult } from '../../../connectionValidator';
+import { type SystemSelectionAnswers } from './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
+ */
+export declare function connectWithBackendSystem(backendSystem: BackendSystem, connectionValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion): Promise<ValidationResult>;
+/**
+ * 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
+ */
+export declare function connectWithDestination(destination: Destination, connectionValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion, addServicePath?: string): Promise<ValidationResult>;
+/**
+ * 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
+ */
+export declare function getBackendSystemDisplayName(system: BackendSystem): string;
+/**
+ * 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
+ */
+export declare function createSystemChoices(destinationFilters?: Partial<DestinationFilters>, includeCloudFoundryAbapEnvChoice?: boolean): Promise<ListChoiceOptions<SystemSelectionAnswers>[]>;
+//# sourceMappingURL=prompt-helpers.d.ts.map

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 error_handler_1 = require("../../../../error-handler/error-handler");
+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 === error_handler_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 === error_handler_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