@sap-ux/odata-service-inquirer 0.4.8 → 0.5.0

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

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbapOnPremSystemQuestions = exports.getAbapOnPremQuestions = exports.abapOnPremInternalPromptNames = void 0;
+const yeoman_ui_types_1 = require("@sap-devx/yeoman-ui-types");
+const axios_extension_1 = require("@sap-ux/axios-extension");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
+const odata_service_writer_1 = require("@sap-ux/odata-service-writer");
+const project_input_validator_1 = require("@sap-ux/project-input-validator");
+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("../new-system/questions");
+const service_helper_1 = require("./service-helper");
+var abapOnPremInternalPromptNames;
+(function (abapOnPremInternalPromptNames) {
+    abapOnPremInternalPromptNames["systemUrl"] = "systemUrl";
+    abapOnPremInternalPromptNames["sapClient"] = "sapClient";
+    abapOnPremInternalPromptNames["systemUsername"] = "abapSystemUsername";
+    abapOnPremInternalPromptNames["systemPassword"] = "abapSystemPassword";
+})(abapOnPremInternalPromptNames || (exports.abapOnPremInternalPromptNames = abapOnPremInternalPromptNames = {}));
+const cliServicePromptName = 'cliServicePromptName';
+/**
+ * Convert the odata version type from the prompt (odata-service-writer) type to the axios-extension type.
+ *
+ * @param odataVersion The odata version to convert
+ * @returns The converted odata version
+ */
+function convertODataVersionType(odataVersion) {
+    if (!odataVersion) {
+        return undefined;
+    }
+    return odataVersion === odata_service_writer_1.OdataVersion.v2 ? axios_extension_1.ODataVersion.v2 : axios_extension_1.ODataVersion.v4;
+}
+/**
+ * Get the Abap on-premise datasource questions.
+ *
+ * @param promptOptions options for prompts. Applicable options are: {@link ServiceSelectionPromptOptions}, {@link SystemNamePromptOptions}
+ * @returns property questions for the Abap on-premise datasource
+ */
+function getAbapOnPremQuestions(promptOptions) {
+    utils_1.PromptState.reset();
+    const connectValidator = new connectionValidator_1.ConnectionValidator();
+    let serviceChoices;
+    // Prevent re-requesting services repeatedly by only requesting them once and when the system is changed
+    let previousSystemUrl;
+    let previousService;
+    // Prompt options
+    const requiredOdataVersion = promptOptions?.serviceSelection?.requiredOdataVersion;
+    const questions = getAbapOnPremSystemQuestions(promptOptions?.userSystemName, connectValidator, requiredOdataVersion);
+    questions.push({
+        when: () => connectValidator.validity.authenticated || connectValidator.validity.authRequired === false,
+        name: types_1.promptNames.serviceSelection,
+        type: promptOptions?.serviceSelection?.useAutoComplete ? 'autocomplete' : 'list',
+        message: (0, i18n_1.t)('prompts.systemService.message'),
+        guiOptions: {
+            breadcrumb: (0, i18n_1.t)('prompts.systemService.breadcrumb'),
+            mandatory: true,
+            applyDefaultWhenDirty: true
+        },
+        source: (prevAnswers, input) => (0, inquirer_common_1.searchChoices)(input, serviceChoices),
+        choices: async (answers) => {
+            if (!serviceChoices || previousSystemUrl !== answers.systemUrl) {
+                let catalogs = [];
+                if (requiredOdataVersion) {
+                    catalogs.push(connectValidator.catalogs[requiredOdataVersion]);
+                }
+                else {
+                    catalogs = Object.values(connectValidator.catalogs);
+                }
+                previousSystemUrl = answers.systemUrl;
+                serviceChoices = await (0, service_helper_1.getServiceChoices)(catalogs);
+            }
+            return serviceChoices;
+        },
+        additionalMessages: async (selectedService) => {
+            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 (0, service_helper_1.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
+                    };
+                }
+            }
+        },
+        default: () => (serviceChoices?.length > 1 ? undefined : 0),
+        // Warning: only executes in YUI not cli
+        validate: async (service, { systemUrl } = {}) => {
+            if (!systemUrl) {
+                return false;
+            }
+            // Dont re-request the same service details
+            if (service && previousService?.servicePath !== service.servicePath) {
+                previousService = service;
+                return getServiceDetails(service, systemUrl, connectValidator);
+            }
+            return true;
+        }
+    });
+    // Only for CLI use as `list` prompt validation does not run on CLI
+    if ((0, utils_1.getHostEnvironment)() === types_1.hostEnvironment.cli) {
+        questions.push({
+            when: async (answers) => {
+                if (answers.serviceSelection && answers.systemUrl) {
+                    const result = await getServiceDetails(answers.serviceSelection, answers.systemUrl, connectValidator);
+                    if (typeof result === 'string') {
+                        logger_helper_1.default.logger.error(result);
+                    }
+                }
+                return false;
+            },
+            name: cliServicePromptName
+        });
+    }
+    return questions;
+}
+exports.getAbapOnPremQuestions = getAbapOnPremQuestions;
+/**
+ * Gets the Abap on-premise system questions.
+ *
+ * @param systemNamePromptOptions options for the system name prompt see {@link SystemNamePromptOptions}
+ * @param connectionValidator reference to the existing connection validator, a new one will be created otherwise
+ * @param requiredOdataVersion the required OData version for the service, this will be used to narrow the catalog service connections
+ * @returns the Abap on-premise system questions
+ */
+function getAbapOnPremSystemQuestions(systemNamePromptOptions, connectionValidator, requiredOdataVersion) {
+    const connectValidator = connectionValidator ?? new connectionValidator_1.ConnectionValidator();
+    const questions = [
+        {
+            type: 'input',
+            name: abapOnPremInternalPromptNames.systemUrl,
+            message: (0, i18n_1.t)('prompts.systemUrl.message'),
+            guiOptions: {
+                hint: (0, i18n_1.t)('prompts.systemUrl.description'),
+                mandatory: true,
+                breadcrumb: true
+            },
+            validate: async (url) => {
+                const valResult = await connectValidator.validateUrl(url, {
+                    isSystem: true,
+                    odataVersion: convertODataVersionType(requiredOdataVersion)
+                });
+                if (valResult === true) {
+                    utils_1.PromptState.odataService.connectedSystem = {
+                        serviceProvider: connectValidator.serviceProvider
+                    };
+                }
+                return valResult;
+            }
+        },
+        {
+            type: 'input',
+            name: abapOnPremInternalPromptNames.sapClient,
+            message: (0, i18n_1.t)('prompts.sapClient.message'),
+            guiOptions: {
+                breadcrumb: (0, i18n_1.t)('prompts.sapClient.breadcrumb')
+            },
+            validate: project_input_validator_1.validateClient
+        },
+        {
+            when: () => (connectValidator.validity.reachable ? connectValidator.validity.authRequired === true : false),
+            type: 'input',
+            name: abapOnPremInternalPromptNames.systemUsername,
+            message: (0, i18n_1.t)('prompts.systemUsername.message'),
+            guiOptions: {
+                mandatory: true
+            },
+            validate: (user) => user?.length > 0
+        },
+        {
+            when: () => (connectValidator.validity.reachable ? connectValidator.validity.authRequired === true : false),
+            type: 'password',
+            guiOptions: {
+                mandatory: true
+            },
+            name: abapOnPremInternalPromptNames.systemPassword,
+            message: (0, i18n_1.t)('prompts.systemPassword.message'),
+            guiType: 'login',
+            mask: '*',
+            validate: async (password, { systemUrl, abapSystemUsername, sapClient }) => {
+                if (!(systemUrl && abapSystemUsername && password)) {
+                    return false;
+                }
+                const valResult = await connectValidator.validateAuth(systemUrl, abapSystemUsername, password, {
+                    isSystem: true,
+                    sapClient
+                });
+                if (valResult === true) {
+                    utils_1.PromptState.odataService.connectedSystem = {
+                        serviceProvider: connectValidator.serviceProvider
+                    };
+                }
+                return valResult;
+            }
+        }
+    ];
+    if (systemNamePromptOptions?.exclude !== 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)()], (answers) => !!answers.systemUrl &&
+            connectValidator.validity.reachable === true &&
+            (connectValidator.validity.authenticated || connectValidator.validity.authRequired !== true))[0]);
+    }
+    return questions;
+}
+exports.getAbapOnPremSystemQuestions = getAbapOnPremSystemQuestions;
+/**
+ * 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 systemUrl the system origin where the service is hosted
+ * @param connectionValidator a reference to the connection validator
+ * @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, systemUrl, connectionValidator) {
+    const serviceCatalog = connectionValidator.catalogs[service.serviceODataVersion];
+    const serviceResult = await (0, service_helper_1.getServiceMetadata)(service.servicePath, serviceCatalog, connectionValidator.serviceProvider);
+    if (typeof serviceResult === 'string') {
+        return serviceResult;
+    }
+    utils_1.PromptState.odataService.annotations = serviceResult?.annotations;
+    utils_1.PromptState.odataService.metadata = serviceResult?.metadata;
+    utils_1.PromptState.odataService.odataVersion =
+        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 = systemUrl;
+    return true;
+}
+//# sourceMappingURL=questions.js.map

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

@@ -0,0 +1,33 @@
+import { ServiceType, type Annotations, type CatalogService, type V2CatalogService, type ServiceProvider } from '@sap-ux/axios-extension';
+import type { ListChoiceOptions } from 'inquirer';
+import type { ServiceAnswer } from './questions';
+/**
+ * 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>[]>;
+/**
+ * Gets the service metadata and annotations for the specified service path.
+ *
+ * @param servicePath service path
+ * @param catalog the catalog service used to get the annotations for the specified service path
+ * @param serviceProvider the service provider for the connected system
+ * @returns Promise<string | boolean>, string error message or true if successful
+ */
+export declare function getServiceMetadata(servicePath: string, catalog: CatalogService, serviceProvider: ServiceProvider): Promise<{
+    annotations: Annotations[];
+    metadata: string;
+    serviceProvider: ServiceProvider;
+} | string>;
+/**
+ * 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>;
+//# sourceMappingURL=service-helper.d.ts.map

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

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceType = exports.getServiceMetadata = exports.getServiceChoices = void 0;
+const axios_extension_1 = require("@sap-ux/axios-extension");
+const i18n_1 = require("../../../../i18n");
+const logger_helper_1 = __importDefault(require("../../../logger-helper"));
+// Service ids continaining these paths should not be offered as UI compatible services
+const nonUIServicePaths = ['/IWBEP/COMMON/'];
+/**
+ * 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));
+};
+/**
+ * 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 listServicesRequests = catalogs.map(async (catalog) => {
+        try {
+            return await catalog.listServices();
+        }
+        catch (error) {
+            logger_helper_1.default.logger.error(`An error occurred requesting services from: ${catalog.entitySet}. Some services may not be listed.`);
+            return [];
+        }
+    });
+    const serviceInfos = await Promise.all(listServicesRequests);
+    const flatServices = serviceInfos?.flat() ?? [];
+    logger_helper_1.default.logger.debug(`Number of services available: ${flatServices.length}`);
+    return createServiceChoices(flatServices);
+}
+exports.getServiceChoices = getServiceChoices;
+/**
+ * Gets the service metadata and annotations for the specified service path.
+ *
+ * @param servicePath service path
+ * @param catalog the catalog service used to get the annotations for the specified service path
+ * @param serviceProvider the service provider for the connected system
+ * @returns Promise<string | boolean>, string error message or true if successful
+ */
+async function getServiceMetadata(servicePath, catalog, serviceProvider) {
+    let annotations = [];
+    try {
+        try {
+            annotations = await catalog.getAnnotations({ path: servicePath });
+        }
+        catch {
+            logger_helper_1.default.logger.info((0, i18n_1.t)('prompts.validationMessages.noAnnotations'));
+        }
+        const odataService = serviceProvider.service(servicePath);
+        const metadata = await odataService.metadata();
+        return {
+            annotations,
+            metadata,
+            serviceProvider
+        };
+    }
+    catch (error) {
+        logger_helper_1.default.logger.error((0, i18n_1.t)('errors.serviceMetadataErrorLog', { servicePath, error }));
+        return (0, i18n_1.t)('errors.serviceMetadataErrorUI', { servicePath });
+    }
+}
+exports.getServiceMetadata = getServiceMetadata;
+/**
+ * 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;
+}
+exports.getServiceType = getServiceType;
+//# sourceMappingURL=service-helper.js.map

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

@@ -0,0 +1,35 @@
+import type { InputQuestion, Question } from 'inquirer';
+import type { OdataServiceAnswers, OdataServicePromptOptions, SapSystemType } from '../../../../types';
+import { promptNames } from '../../../../types';
+export declare const newSystemChoiceValue = "!@\u00A3*&937newSystem*X~qy^";
+declare const newSystemPromptNames: {
+    readonly newSystemType: "newSystemType";
+};
+/**
+ * Internal only answers to service URL prompting not returned with OdataServiceAnswers.
+ */
+export interface NewSystemAnswers {
+    [newSystemPromptNames.newSystemType]?: SapSystemType;
+    [promptNames.userSystemName]?: string;
+}
+declare const systemSelectionPromptNames: {
+    readonly system: "system";
+};
+export interface SystemSelectionAnswer extends OdataServiceAnswers {
+    [systemSelectionPromptNames.system]?: string;
+}
+/**
+ * Provides prompts that allow the creation of a new system connection.
+ *
+ * @param promptOptions options for the new system prompts see {@link OdataServicePromptOptions}
+ * @returns questions for creating a new system connection
+ */
+export declare function getNewSystemQuestions(promptOptions?: OdataServicePromptOptions): Question<NewSystemAnswers>[];
+/**
+ * Get a prompt for new system name.
+ *
+ * @returns the new system name prompt
+ */
+export declare function getUserSystemNameQuestion(): InputQuestion<NewSystemAnswers>;
+export {};
+//# sourceMappingURL=questions.d.ts.map

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserSystemNameQuestion = exports.getNewSystemQuestions = exports.newSystemChoiceValue = void 0;
+/**
+ * New system prompting questions for re-use in multiple sap-system datasource prompt sets.
+ */
+const yeoman_ui_types_1 = require("@sap-devx/yeoman-ui-types");
+const inquirer_common_1 = require("@sap-ux/inquirer-common");
+const store_1 = require("@sap-ux/store");
+const i18n_1 = require("../../../../i18n");
+const types_1 = require("../../../../types");
+const utils_1 = require("../../../../utils");
+const logger_helper_1 = __importDefault(require("../../../logger-helper"));
+const questions_1 = require("../abap-on-prem/questions");
+const prompt_helpers_1 = require("../prompt-helpers");
+const validators_1 = require("../validators");
+// 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 newSystemPromptNames = {
+    newSystemType: 'newSystemType'
+};
+const systemSelectionPromptNames = {
+    system: 'system'
+};
+/**
+ * Provides prompts that allow the creation of a new system connection.
+ *
+ * @param promptOptions options for the new system prompts see {@link OdataServicePromptOptions}
+ * @returns questions for creating a new system connection
+ */
+function getNewSystemQuestions(promptOptions) {
+    const questions = [
+        {
+            type: 'list',
+            name: newSystemPromptNames.newSystemType,
+            choices: [
+                { name: (0, i18n_1.t)('prompts.newSystemType.choiceAbapOnBtp'), value: 'abapOnBtp' },
+                { name: (0, i18n_1.t)('prompts.newSystemType.choiceAbapOnPrem'), value: 'abapOnPrem' }
+            ],
+            message: (0, i18n_1.t)('prompts.newSystemType.message'),
+            additionalMessages: (systemType) => {
+                if (['abapOnBtp'].includes(systemType)) {
+                    logger_helper_1.default.logger?.warn((0, i18n_1.t)('prompts.systemType.notYetImplementedWarningMessage', { systemType }));
+                    return {
+                        message: (0, i18n_1.t)('prompts.systemType.notYetImplementedWarningMessage', { systemType }),
+                        severity: yeoman_ui_types_1.Severity.warning
+                    };
+                }
+            }
+        }
+    ];
+    questions.push(...(0, inquirer_common_1.withCondition)((0, questions_1.getAbapOnPremQuestions)(promptOptions), (answers) => answers.newSystemType === 'abapOnPrem'));
+    return questions;
+}
+exports.getNewSystemQuestions = getNewSystemQuestions;
+/**
+ * Get a prompt for new system name.
+ *
+ * @returns the new system name prompt
+ */
+function getUserSystemNameQuestion() {
+    let defaultSystemName;
+    const newSystemNamePrompt = {
+        type: 'input',
+        guiOptions: {
+            hint: (0, i18n_1.t)('prompts.systemName.hint'),
+            applyDefaultWhenDirty: true,
+            breadcrumb: true
+        },
+        name: types_1.promptNames.userSystemName,
+        message: (0, i18n_1.t)('prompts.systemName.message'),
+        default: async (answers) => {
+            if (answers.newSystemType === 'abapOnPrem' && answers.systemUrl) {
+                defaultSystemName = await (0, prompt_helpers_1.suggestSystemName)(answers.systemUrl, answers.sapClient);
+            }
+            return defaultSystemName;
+        },
+        validate: async (systemName, answers) => {
+            let validationResult = false;
+            // Dont validate the suggested default system name
+            if (systemName === defaultSystemName) {
+                validationResult = true;
+            }
+            validationResult = await (0, validators_1.validateSystemName)(systemName);
+            if (validationResult === true) {
+                const backendSystem = new store_1.BackendSystem({
+                    name: systemName,
+                    url: answers.systemUrl,
+                    client: answers.sapClient,
+                    username: answers.abapSystemUsername,
+                    password: answers.abapSystemPassword
+                });
+                if (utils_1.PromptState.odataService.connectedSystem) {
+                    utils_1.PromptState.odataService.connectedSystem.backendSystem = backendSystem;
+                }
+            }
+            return validationResult;
+        }
+    };
+    return newSystemNamePrompt;
+}
+exports.getUserSystemNameQuestion = getUserSystemNameQuestion;
+//# sourceMappingURL=questions.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Provides a system name suggestion based on the system URL, system ID, and client, validating the name is unique against the secure store.
+ *
+ * @param systemUrl the system URL origin
+ * @param client the sap client to use for the system
+ * @returns a unique system name suggestion
+ */
+export declare function suggestSystemName(systemUrl: string, client?: string): Promise<string>;
+//# sourceMappingURL=prompt-helpers.d.ts.map

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestSystemName = void 0;
+const i18n_1 = require("../../../i18n");
+const validators_1 = require("./validators");
+/**
+ * Provides a system name suggestion based on the system URL, system ID, and client, validating the name is unique against the secure store.
+ *
+ * @param systemUrl the system URL origin
+ * @param client the sap client to use for the system
+ * @returns a unique system name suggestion
+ */
+async function suggestSystemName(systemUrl, client) {
+    const initialSystemName = systemUrl + (client ? (0, i18n_1.t)('texts.suggestedSystemNameClient', { client }) : '');
+    if ((await (0, validators_1.validateSystemName)(initialSystemName)) === true) {
+        return initialSystemName;
+    }
+    // If initial suggested name is taken, append a suffix
+    return appendSuffix(initialSystemName);
+}
+exports.suggestSystemName = suggestSystemName;
+/**
+ * Appends a suffix to the system name to make it unique.
+ *
+ * @param systemName system name to use as a base name for finding a unique name
+ * @returns suffixed system name
+ */
+async function appendSuffix(systemName) {
+    let suffixNumber = 1;
+    let suffixedSystemName = `${systemName} (${suffixNumber})`;
+    while ((await (0, validators_1.validateSystemName)(suffixedSystemName)) !== true) {
+        suffixedSystemName = `${systemName} (${suffixNumber})`;
+        suffixNumber++;
+    }
+    return suffixedSystemName;
+}
+//# sourceMappingURL=prompt-helpers.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Validates that the system name does not exist yet.
+ *
+ * @param systemName a system name to validate
+ * @returns true if the name is valid, otherwise an error message
+ */
+export declare function validateSystemName(systemName: string): Promise<boolean | string>;
+//# sourceMappingURL=validators.d.ts.map

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSystemName = void 0;
+const i18n_1 = require("../../../i18n");
+const store_1 = require("@sap-ux/store");
+const logger_helper_1 = __importDefault(require("../../logger-helper"));
+/**
+ * Check if the system name is already in use.
+ *
+ * @param systemName a system name to check
+ * @returns true if the system name is already in use, otherwise false
+ */
+async function isSystemNameInUse(systemName) {
+    const backendSystems = await new store_1.SystemService(logger_helper_1.default.logger).getAll();
+    return !!backendSystems.find((system) => system.name === systemName);
+}
+/**
+ * Validates that the system name does not exist yet.
+ *
+ * @param systemName a system name to validate
+ * @returns true if the name is valid, otherwise an error message
+ */
+async function validateSystemName(systemName) {
+    const systemExists = await isSystemNameInUse(systemName);
+    if (systemExists) {
+        return (0, i18n_1.t)('prompts.systemName.systemNameExistsWarning');
+    }
+    else {
+        return true;
+    }
+}
+exports.validateSystemName = validateSystemName;
+//# sourceMappingURL=validators.js.map