@sap-ux/odata-service-inquirer 2.18.13 → 2.19.1

package/dist/prompts/connectionValidator.d.ts

@@ -15,6 +15,7 @@ interface Validity {
     canSkipCertError?: boolean;
 }
 export type SystemAuthType = 'serviceKey' | 'reentranceTicket' | 'basic' | 'unknown';
+export type ConnectionType = 'abap_catalog' | 'odata_path';
 /**
  * Class that can be used to determine the connectivity using a service url, system url, or service info (UAA Key details) or reentrance ticket.
  * This will determine if if the service/catalog is reachable, authentication is required and generates ting messages to guide the user.
@@ -161,6 +162,7 @@ export declare class ConnectionValidator {
      * @param options.ignoreCertError ignore some certificate errors
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
+     * @param options.connectType if specified will determine how a system is authenticated, catalog or metadata request
      * @returns the status code or error returned by the connection attempt
      * @throws an error if the connection attempt fails and the error is a 500 on App Studio or a non-axios error is caught
      */
@@ -206,6 +208,7 @@ export declare class ConnectionValidator {
      * @param connectConfig.serviceInfo the service info
      * @param connectConfig.odataVersion the odata version to restrict the catalog requests if only a specific version is required
      * @param connectConfig.destination the destination to connect with
+     * @param connectConfig.connectType Override the default connection approach if specified
      * @throws an error if the connection attempt fails, callers should handle the error
      */
     private createSystemConnection;
@@ -268,25 +271,26 @@ export declare class ConnectionValidator {
      */
     private validateOdataServiceDestination;
     /**
-     * Validates an odata service url format as well as its reachability. Note if this function returns true, this is only an indication that the system is reachable
+     * Validates a url format as well as its reachability. Note if this function returns true, this is only an indication that the url or host is reachable
      * not that a connection has been established. The connection may require separate authentication or other steps (it may be reachable but a cert error was returned).
      *
      * @param serviceUrl the url to validate, may be a system or service url.
-     *     Note that if systemAuthType is specified, the url will be treated as a system url (only the origin will be considered)
      * @param options options for the connection validation
      * @param options.ignoreCertError ignore some certificate errors
      * @param options.forceReValidation force re-validation of the url
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url, this value is retained for subsequent calls
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
      * @param options.systemAuthType the system auth type used to create system connections, if not specified or `isSystem` is false or undefined, `basic` is assumed
+     * @param options.connectType if specified will be used to determine the endpoint used for authentication
      * @returns true if the url is reachable, false if not, or an error message string
      */
-    validateUrl(serviceUrl: string, { ignoreCertError, forceReValidation, isSystem, odataVersion, systemAuthType }?: {
+    validateUrl(serviceUrl: string, { ignoreCertError, forceReValidation, isSystem, odataVersion, systemAuthType, connectType }?: {
         ignoreCertError?: boolean;
         forceReValidation?: boolean;
         isSystem?: boolean;
         odataVersion?: ODataVersion;
         systemAuthType?: SystemAuthType;
+        connectType?: ConnectionType;
     }): Promise<ValidationResult>;
     /**
      * Sets the instance validity state based on the status code and returns true if the status code indicates that the URL was reachable.
@@ -330,13 +334,15 @@ export declare class ConnectionValidator {
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url
      * @param options.sapClient the sap client to use for the connection
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
+     * @param options.connectType if specified this will determine how a connection is authenticated, catalog or service metadata, overiding the default approach
      * @returns true if the authentication is successful, false if not, or an error message string
      */
-    validateAuth(url: string, username?: string, password?: string, { ignoreCertError, sapClient, odataVersion, isSystem }?: {
+    validateAuth(url: string, username?: string, password?: string, { ignoreCertError, sapClient, odataVersion, isSystem, connectType }?: {
         ignoreCertError?: boolean;
         odataVersion?: ODataVersion;
         sapClient?: string;
         isSystem?: boolean;
+        connectType?: ConnectionType;
     }): Promise<{
         valResult: ValidationResult;
         errorType?: ERROR_TYPE;

package/dist/prompts/connectionValidator.js

@@ -242,10 +242,11 @@ class ConnectionValidator {
      * @param options.ignoreCertError ignore some certificate errors
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
+     * @param options.connectType if specified will determine how a system is authenticated, catalog or metadata request
      * @returns the status code or error returned by the connection attempt
      * @throws an error if the connection attempt fails and the error is a 500 on App Studio or a non-axios error is caught
      */
-    async checkUrl(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion } = {}) {
+    async checkUrl(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion, connectType } = {}) {
         const isBAS = (0, btp_utils_1.isAppStudio)();
         try {
             // Auto add trailing '/' to path
@@ -260,10 +261,13 @@ class ConnectionValidator {
             }
             const axiosConfig = this.createAxiosConfig(url, ignoreCertError, username, password);
             if (isSystem) {
-                await this.createSystemConnection({ axiosConfig, url, odataVersion });
-                const systemInfo = await this.serviceProvider.getSystemInfo();
-                this._connectedUserName = systemInfo?.userName;
-                this._connectedSystemName = systemInfo?.systemID;
+                await this.createSystemConnection({ axiosConfig, url, odataVersion, connectType });
+                // For systems (dest or backend systems) using a service endpoint for auth skip this call
+                if (connectType !== 'odata_path') {
+                    const systemInfo = await this.serviceProvider.getSystemInfo();
+                    this._connectedUserName = systemInfo?.userName;
+                    this._connectedSystemName = systemInfo?.systemID;
+                }
             }
             else {
                 // Full service URL
@@ -392,9 +396,10 @@ class ConnectionValidator {
      * @param connectConfig.serviceInfo the service info
      * @param connectConfig.odataVersion the odata version to restrict the catalog requests if only a specific version is required
      * @param connectConfig.destination the destination to connect with
+     * @param connectConfig.connectType Override the default connection approach if specified
      * @throws an error if the connection attempt fails, callers should handle the error
      */
-    async createSystemConnection({ axiosConfig, url, serviceInfo, destination, odataVersion }) {
+    async createSystemConnection({ axiosConfig, url, serviceInfo, destination, odataVersion, connectType = `abap_catalog` }) {
         this.resetConnectionState(true);
         if (this.systemAuthType === 'reentranceTicket' || this.systemAuthType === 'serviceKey') {
             this._serviceProvider = this.getAbapOnCloudServiceProvider(url, serviceInfo);
@@ -419,24 +424,34 @@ class ConnectionValidator {
         if (this._serviceProvider) {
             logger_helper_1.default.attachAxiosLogger(this._serviceProvider.interceptors);
         }
-        if (!odataVersion || odataVersion === axios_extension_1.ODataVersion.v2) {
-            this._catalogV2 = this._serviceProvider.catalog(axios_extension_1.ODataVersion.v2);
-        }
-        if (!odataVersion || odataVersion === axios_extension_1.ODataVersion.v4) {
-            this._catalogV4 = this._serviceProvider.catalog(axios_extension_1.ODataVersion.v4);
-        }
-        let v4Requested = false;
-        try {
-            if (this._catalogV2) {
-                await this._catalogV2?.listServices();
+        if (connectType === 'abap_catalog') {
+            if (!odataVersion || odataVersion === axios_extension_1.ODataVersion.v2) {
+                this._catalogV2 = this._serviceProvider.catalog(axios_extension_1.ODataVersion.v2);
+            }
+            if (!odataVersion || odataVersion === axios_extension_1.ODataVersion.v4) {
+                this._catalogV4 = this._serviceProvider.catalog(axios_extension_1.ODataVersion.v4);
+            }
+            let v4Requested = false;
+            try {
+                if (this._catalogV2) {
+                    await this._catalogV2?.listServices();
+                }
+                else if (this._catalogV4) {
+                    v4Requested = true;
+                    await this._catalogV4?.listServices();
+                }
             }
-            else if (this._catalogV4) {
-                v4Requested = true;
-                await this._catalogV4?.listServices();
+            catch (error) {
+                await this.handleCatalogError(error, v4Requested);
             }
         }
-        catch (error) {
-            await this.handleCatalogError(error, v4Requested);
+        else if (connectType === 'odata_path' && url) {
+            // System (backend system or destination) that uses a service for auth since catalog may not be accessible
+            // No need to validate service version here as it will be validated by the service prompt
+            // Here we only validate connectivity by throwing and handling request errors
+            logger_helper_1.default.logger.debug(`Using service request: ${url} to validate authentication.`);
+            this._odataService = this._serviceProvider.service(`${url?.pathname}`);
+            await this._odataService.get('');
         }
     }
     /**
@@ -508,7 +523,7 @@ class ConnectionValidator {
         if (this.systemAuthType === 'reentranceTicket' && url) {
             return (0, axios_extension_1.createForAbapOnCloud)({
                 environment: axios_extension_1.AbapCloudEnvironment.EmbeddedSteampunk,
-                url: new URL(url.pathname, url.origin).toString(),
+                url: url.origin,
                 logger: logger_helper_1.default.logger
             });
         }
@@ -572,11 +587,14 @@ class ConnectionValidator {
             // So while we actually dont know we assume its basic for now since thats the only supported mechanism
             this.systemAuthType = destination.Authentication === btp_utils_1.Authentication.NO_AUTHENTICATION ? 'basic' : 'unknown';
             // Since a destination may be a system or a service connection, we need to determine the connection request (catalog or service)
-            if ((0, btp_utils_1.isFullUrlDestination)(destination) || (0, btp_utils_1.isPartialUrlDestination)(destination)) {
+            if ((0, btp_utils_1.isFullUrlDestination)(destination) || (0, btp_utils_1.isPartialUrlDestination)(destination) || servicePath) {
                 return await this.validateOdataServiceDestination(destination, servicePath);
             }
             else {
-                await this.createSystemConnection({ destination, odataVersion });
+                await this.createSystemConnection({
+                    destination,
+                    odataVersion
+                });
             }
             return {
                 valResult: this.getValidationResultFromStatusCode(200)
@@ -642,20 +660,20 @@ class ConnectionValidator {
         };
     }
     /**
-     * Validates an odata service url format as well as its reachability. Note if this function returns true, this is only an indication that the system is reachable
+     * Validates a url format as well as its reachability. Note if this function returns true, this is only an indication that the url or host is reachable
      * not that a connection has been established. The connection may require separate authentication or other steps (it may be reachable but a cert error was returned).
      *
      * @param serviceUrl the url to validate, may be a system or service url.
-     *     Note that if systemAuthType is specified, the url will be treated as a system url (only the origin will be considered)
      * @param options options for the connection validation
      * @param options.ignoreCertError ignore some certificate errors
      * @param options.forceReValidation force re-validation of the url
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url, this value is retained for subsequent calls
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
      * @param options.systemAuthType the system auth type used to create system connections, if not specified or `isSystem` is false or undefined, `basic` is assumed
+     * @param options.connectType if specified will be used to determine the endpoint used for authentication
      * @returns true if the url is reachable, false if not, or an error message string
      */
-    async validateUrl(serviceUrl, { ignoreCertError = false, forceReValidation = false, isSystem = false, odataVersion, systemAuthType } = {}) {
+    async validateUrl(serviceUrl, { ignoreCertError = false, forceReValidation = false, isSystem = false, odataVersion, systemAuthType, connectType } = {}) {
         if (this.isEmptyString(serviceUrl)) {
             this.resetValidity();
             this.validity.urlFormat = false;
@@ -671,10 +689,11 @@ class ConnectionValidator {
             if (url.origin === 'null') {
                 return (0, i18n_1.t)('errors.invalidUrl', { input: serviceUrl });
             }
-            // Dont allow non origin URLs in for re-entrance tickets and system URL's as the error handling would become complex to analyize.
+            // Unless connection type is explicitly `odata_path`, dont allow non origin URLs in for re-entrance tickets and system URL's as the error handling would become complex to analyize. If connectType is `odata_path` only the origin will be used to auth and store backend connections.
             // The connection may succeed but later we will get auth errors since axios-extension does not validate this.
-            // The new system name would also include the additional paths which would not make sense and would cause the issue when storing the system.
-            if ((this.systemAuthType === 'reentranceTicket' || isSystem) &&
+            // The new system name would also include the additional paths which would not make sense and would cause an issue when storing the system.
+            if (connectType !== 'odata_path' &&
+                (this.systemAuthType === 'reentranceTicket' || isSystem) &&
                 !(url.pathname.length === 0 || url.pathname === '/')) {
                 return (0, i18n_1.t)('prompts.validationMessages.systemUrlOriginOnlyWarning');
             }
@@ -690,11 +709,11 @@ class ConnectionValidator {
                 // New URL so reset the validity
                 this.resetValidity();
             }
-            // Ignore path if a system url
             const status = await this.checkUrl(url, undefined, undefined, {
                 ignoreCertError,
                 isSystem,
-                odataVersion
+                odataVersion,
+                connectType
             });
             logger_helper_1.default.logger.debug(`ConnectionValidator.validateUrl() - status: ${status}; url: ${serviceUrl}`);
             this.validity.urlFormat = true;
@@ -837,9 +856,10 @@ class ConnectionValidator {
      * @param options.isSystem if true, the url will be treated as a system url rather than a service url
      * @param options.sapClient the sap client to use for the connection
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
+     * @param options.connectType if specified this will determine how a connection is authenticated, catalog or service metadata, overiding the default approach
      * @returns true if the authentication is successful, false if not, or an error message string
      */
-    async validateAuth(url, username, password, { ignoreCertError = false, sapClient, odataVersion, isSystem = false } = {}) {
+    async validateAuth(url, username, password, { ignoreCertError = false, sapClient, odataVersion, isSystem = false, connectType } = {}) {
         if (!url) {
             return { valResult: false };
         }
@@ -852,7 +872,8 @@ class ConnectionValidator {
             const status = await this.checkUrl(urlObject, username, password, {
                 ignoreCertError: ignoreCertError,
                 isSystem,
-                odataVersion
+                odataVersion,
+                connectType
             });
             logger_helper_1.default.logger.debug(`ConnectionValidator.validateAuth() - status: ${status}; url: ${url}`);
             // Since an exception was not thrown, this is a valid url

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

@@ -88,7 +88,7 @@ function getSystemServiceQuestion(connectValidator, promptNamespace, promptOptio
                     }
                 }
                 else {
-                    logger_helper_1.default.logger.error((0, i18n_1.t)('error.noCatalogOrServiceAvailable'));
+                    logger_helper_1.default.logger.error((0, i18n_1.t)('errors.noCatalogOrServiceAvailable'));
                 }
             }
             return serviceChoices;

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

@@ -21,9 +21,10 @@ export type SystemSelectionAnswerType = {
  * @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 cachedConnectedSystem - if available passing an already connected system connection will prevent re-authentication for re-entrance ticket and service keys connection types
+ * @param connectPath if specified will be used as the authentication path, typically a service path
  * @returns the validation result of the backend system connection
  */
-export declare function connectWithBackendSystem(backendKey: BackendSystemKey, connectionValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion, cachedConnectedSystem?: ConnectedSystem): Promise<ValidationResult>;
+export declare function connectWithBackendSystem(backendKey: BackendSystemKey, connectionValidator: ConnectionValidator, requiredOdataVersion?: OdataVersion, cachedConnectedSystem?: ConnectedSystem, connectPath?: string): Promise<ValidationResult>;
 /**
  * Connects to the specified destination and validates the connection.
  * Note that a destination may be a system or a service connection.

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

@@ -27,9 +27,10 @@ exports.CfAbapEnvServiceChoice = 'cfAbapEnvService';
  * @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 cachedConnectedSystem - if available passing an already connected system connection will prevent re-authentication for re-entrance ticket and service keys connection types
+ * @param connectPath if specified will be used as the authentication path, typically a service path
  * @returns the validation result of the backend system connection
  */
-async function connectWithBackendSystem(backendKey, connectionValidator, requiredOdataVersion, cachedConnectedSystem) {
+async function connectWithBackendSystem(backendKey, connectionValidator, requiredOdataVersion, cachedConnectedSystem, connectPath) {
     // Create a new connection with the selected system
     utils_1.PromptState.resetConnectedSystem();
     let connectValResult = false;
@@ -41,28 +42,36 @@ async function connectWithBackendSystem(backendKey, connectionValidator, require
         if (cachedConnectedSystem && cachedConnectedSystem.backendSystem?.url === backendSystem.url) {
             connectionValidator.setConnectedSystem(cachedConnectedSystem);
         }
+        // If an alternative connection path is specified use this instead of the just the origin (this will imply service auth instead of catalog)
+        const backendSystemUrl = new URL(backendSystem.url);
+        let connectUrl = backendSystemUrl.origin;
+        if (connectPath) {
+            connectUrl = new URL(connectPath, backendSystemUrl.origin).toString();
+        }
         // Assumption: non-BAS systems are BackendSystems
         if (backendSystem.authenticationType === 'reentranceTicket') {
             // Since we previously allowed paths in the stored backend system URLs for Cloud systems, we need to strip them (only use origin in the validator).
-            const backendSystemUrl = new URL(backendSystem.url);
             if (backendSystemUrl.pathname !== '/') {
                 logger_helper_1.default.logger.warn((0, i18n_1.t)('warnings.storedSystemUrlPathNotSupported', { systemUrl: backendSystem.url }));
             }
-            connectValResult = await connectionValidator.validateUrl(backendSystemUrl.origin, {
+            connectValResult = await connectionValidator.validateUrl(connectUrl, {
                 isSystem: true,
                 odataVersion: (0, utils_1.convertODataVersionType)(requiredOdataVersion),
-                systemAuthType: 'reentranceTicket'
+                systemAuthType: 'reentranceTicket',
+                connectType: connectPath ? 'odata_path' : undefined // Assumption that if a connection path is provided its an odata service endpoint
             });
         }
         else if (backendSystem.serviceKeys) {
+            // Legacy backend system support
             connectValResult = await connectionValidator.validateServiceInfo(backendSystem.serviceKeys, (0, utils_1.convertODataVersionType)(requiredOdataVersion));
         }
         else if (backendSystem.authenticationType === 'basic' || !backendSystem.authenticationType) {
             let errorType;
-            ({ valResult: connectValResult, errorType } = await connectionValidator.validateAuth(backendSystem.url, backendSystem.username, backendSystem.password, {
+            ({ valResult: connectValResult, errorType } = await connectionValidator.validateAuth(connectUrl, backendSystem.username, backendSystem.password, {
                 isSystem: true,
                 odataVersion: (0, utils_1.convertODataVersionType)(requiredOdataVersion),
-                sapClient: backendSystem.client
+                sapClient: backendSystem.client,
+                connectType: connectPath ? 'odata_path' : undefined // Assumption that if a connection path is provided its an odata service endpoint
             }));
             // 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.

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

@@ -34,10 +34,11 @@ const systemSelectionPromptNames = {
  * @param systemSelection the selected system to validate
  * @param connectionValidator the active connection validator to use for the connection attempt
  * @param requiredOdataVersion the required OData version for the selected system, only the specified version will be used to request a service catalog
- * @param cachedConnectedSystem - if available passing an already connected system connection will prevent re-authentication for re-entrance ticket and service keys connection types
+ * @param cachedConnectedSystem if available passing an already connected system connection will prevent re-authentication for re-entrance ticket and service keys connection types
+ * @param connectPath if specified will be used as the connection endpoint instead of service catalogs
  * @returns the validation result of the selected system connection attempt
  */
-async function validateSystemSelection(systemSelection, connectionValidator, requiredOdataVersion, cachedConnectedSystem) {
+async function validateSystemSelection(systemSelection, connectionValidator, requiredOdataVersion, cachedConnectedSystem, connectPath) {
     utils_1.PromptState.reset();
     if (systemSelection.type === 'newSystemChoice' || systemSelection.type === 'cfAbapEnvService') {
         // Reset the connection state
@@ -47,7 +48,7 @@ async function validateSystemSelection(systemSelection, connectionValidator, req
     let connectValResult = false;
     if (systemSelection.type === 'backendSystem') {
         const backendKey = store_1.BackendSystemKey.from(systemSelection.system);
-        connectValResult = await (0, prompt_helpers_1.connectWithBackendSystem)(backendKey, connectionValidator, requiredOdataVersion, cachedConnectedSystem);
+        connectValResult = await (0, prompt_helpers_1.connectWithBackendSystem)(backendKey, connectionValidator, requiredOdataVersion, cachedConnectedSystem, connectPath);
     }
     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
@@ -57,7 +58,7 @@ async function validateSystemSelection(systemSelection, connectionValidator, req
             // connectionValidator.resetConnectionState(true);
             return true;
         }
-        connectValResult = await (0, prompt_helpers_1.connectWithDestination)(systemSelection.system, connectionValidator, requiredOdataVersion);
+        connectValResult = await (0, prompt_helpers_1.connectWithDestination)(systemSelection.system, connectionValidator, requiredOdataVersion, connectPath);
     }
     return connectValResult;
 }
@@ -100,6 +101,8 @@ async function getSystemConnectionQuestions(connectionValidator, promptOptions,
     const destinationFilters = promptOptions?.systemSelection?.destinationFilters;
     const systemChoices = await (0, prompt_helpers_1.createSystemChoices)(destinationFilters, promptOptions?.systemSelection?.includeCloudFoundryAbapEnvChoice, promptOptions?.systemSelection?.hideNewSystem);
     let defaultChoiceIndex = (0, prompt_helpers_1.findDefaultSystemSelectionIndex)(systemChoices, promptOptions?.systemSelection?.defaultChoice);
+    // Alternative connection path, will override default authentication path (catalog endpoints)
+    let connectPath;
     const shouldOnlyShowDefaultChoice = promptOptions?.systemSelection?.onlyShowDefaultChoice && promptOptions?.systemSelection?.defaultChoice;
     const questions = [
         {
@@ -117,6 +120,9 @@ async function getSystemConnectionQuestions(connectionValidator, promptOptions,
                     return 0;
                 }
                 defaultChoiceIndex = (0, prompt_helpers_1.findDefaultSystemSelectionIndex)(systemChoices, promptOptions?.systemSelection?.defaultChoice); // Recalc to allow default choice to be bound to ref from another prompt
+                if (defaultChoiceIndex > -1 && typeof promptOptions?.systemSelection?.defaultChoice === 'object') {
+                    connectPath = promptOptions.systemSelection.defaultChoice.connectPath;
+                }
                 return defaultChoiceIndex;
             },
             validate: async (selectedSystem) => {
@@ -128,7 +134,7 @@ async function getSystemConnectionQuestions(connectionValidator, promptOptions,
                 if (promptOptions?.systemSelection?.useAutoComplete && selectedSystem.value) {
                     selectedSystemAnswer = selectedSystem.value;
                 }
-                return (validateSystemSelection(selectedSystemAnswer, connectionValidator, requiredOdataVersion, cachedConnectedSystem) ?? false);
+                return (validateSystemSelection(selectedSystemAnswer, connectionValidator, requiredOdataVersion, cachedConnectedSystem, connectPath) ?? false);
             },
             additionalMessages: async (selectedSystem) => {
                 if (selectedSystem.type === 'backendSystem' &&
@@ -196,7 +202,7 @@ async function getSystemConnectionQuestions(connectionValidator, promptOptions,
                 if (!selectedSystem) {
                     return false;
                 }
-                const connectValResult = await validateSystemSelection(selectedSystem, connectionValidator, requiredOdataVersion);
+                const connectValResult = await validateSystemSelection(selectedSystem, connectionValidator, requiredOdataVersion, undefined, connectPath);
                 // 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) {

package/dist/prompts/edmx/questions.js

@@ -250,14 +250,22 @@ function getTableLayoutQuestions(templateType, odataVersion, isCapService, metad
                 defaultTableType = undefined;
                 return prevAnswers.tableType;
             },
-            additionalMessages: () => {
-                if (defaultTableType === 'AnalyticalTable') {
+            additionalMessages: (selectedTableType) => {
+                // Show responsive table info whenever ResponsiveTable is selected
+                if (selectedTableType === 'ResponsiveTable') {
+                    return {
+                        message: (0, i18n_1.t)('prompts.tableType.responsiveTableInfo'),
+                        severity: yeoman_ui_types_1.Severity.information
+                    };
+                }
+                // Show default type info when the default is selected
+                if (defaultTableType === 'AnalyticalTable' && selectedTableType === 'AnalyticalTable') {
                     return {
                         message: (0, i18n_1.t)('prompts.tableType.analyticalTableDefault'),
                         severity: yeoman_ui_types_1.Severity.information
                     };
                 }
-                else if (defaultTableType === 'TreeTable') {
+                else if (defaultTableType === 'TreeTable' && selectedTableType === 'TreeTable') {
                     return {
                         message: (0, i18n_1.t)('prompts.tableType.treeTableDefault'),
                         severity: yeoman_ui_types_1.Severity.information

package/dist/translations/odata-service-inquirer.i18n.json

@@ -167,7 +167,8 @@
             "choiceResponsive": "Responsive",
             "choiceTree": "Tree",
             "analyticalTableDefault": "The 'Analytical' table type is chosen by default because the selected entity supports it.",
-            "treeTableDefault": "The 'Tree' table type is chosen by default because the selected entity supports it."
+            "treeTableDefault": "The 'Tree' table type is chosen by default because the selected entity supports it.",
+            "responsiveTableInfo": "Only use the responsive table if the total number of items in the table doesn't exceed 200."
         },
         "hierarchyQualifier": {
             "message": "Hierarchy Qualifier",

package/dist/types.d.ts

@@ -286,11 +286,12 @@ export type SystemSelectionPromptOptions = {
      * Provide a default choice for the system selection prompt, this is used to pre-select a system based on the system name.
      * Set as string literal types `NewSystemChoice` or `CfAbapEnvServiceChoice` to specify the default choice to create a new system connection config in VSCode
      * or to select the Cloud Foundry Abap environments service discovery choice in BAS respectively.
-     * Supported as object reference `{ value: }` to allow binding to runtime variables of other prompts or as string
-     *
+     * Supported as object reference `{ value: }` to allow binding to runtime variables of other prompts or as string.
+     * `{ connectPath }`, if specified this path is appended to the default choice system path and will be used to authenticate instead of a making catalog request
      */
     defaultChoice?: string | {
         value?: string;
+        connectPath?: string;
     };
     /**
      * Only show the default choice in the system selection prompt, this is used to skip the system selection prompt if the default choice is already known.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/odata-service-inquirer",
   "description": "Prompts module that can prompt users for inputs required for odata service writing",
-  "version": "2.18.13",
+  "version": "2.19.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",