@sap-ux/odata-service-inquirer 0.5.28 → 0.5.30

package/dist/prompts/connectionValidator.js

@@ -15,10 +15,11 @@ const prompt_helpers_1 = require("./prompt-helpers");
 // Cert errors that may be ignored by prompt user
 const ignorableCertErrors = [error_handler_1.ERROR_TYPE.CERT_SELF_SIGNED, error_handler_1.ERROR_TYPE.CERT_SELF_SIGNED_CERT_IN_CHAIN];
 /**
- * Class that validates the connection to a service url or catalog url.
- * This will determine if authentication is required and if the service/catalog is reachable, generating messages to guide the user.
- * It is optimized for re-validation of the same url, so that the validation is not repeated if not required.
- *
+ * 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.
+ * Certain types of certificate errors can be ignored if required. However, the end-user should be warned about the risks using a prompt message.
+ * Catalog requests may be made multiple times for the same url, but the underlying connectivity module (@sap-ux/axios-extension) will cache the results to avoid repeated network requests.
+ * The class also stores the current connection state, including the service provider, odata service, and catalog services.
  */
 class ConnectionValidator {
     validity = {};
@@ -31,6 +32,11 @@ class ConnectionValidator {
     _axiosConfig;
     _catalogV2;
     _catalogV4;
+    _systemAuthType;
+    _serviceInfo;
+    _connectedUserName;
+    _connectedSystemName;
+    _refreshToken;
     /**
      * Getter for the axios configuration.
      *
@@ -65,6 +71,83 @@ class ConnectionValidator {
     get serviceProvider() {
         return this._serviceProvider;
     }
+    /**
+     * The auth type used to create an authenticated connection to the system.
+     *
+     * @returns the system auth type
+     */
+    get systemAuthType() {
+        return this._systemAuthType;
+    }
+    /**
+     * The auth type used to create an authenticated connection to the system.
+     *
+     * @param value the system auth type
+     */
+    set systemAuthType(value) {
+        this._systemAuthType = value;
+    }
+    /**
+     * Get the validated url. This is the url that has been successfully validated (not necessarily connected). Use validity to check if the url is reachable.
+     *
+     * @returns the validated url
+     */
+    get validatedUrl() {
+        return this._validatedUrl;
+    }
+    /**
+     * Get the service info used to connect to the system.
+     *
+     * @returns the service info
+     */
+    get serviceInfo() {
+        return this._serviceInfo;
+    }
+    /**
+     * Set the service info used to connect to the system.
+     *
+     * @param serviceInfo the service info
+     */
+    set serviceInfo(serviceInfo) {
+        this._serviceInfo = serviceInfo;
+    }
+    /**
+     * Get the connected user name.
+     *
+     * @returns the connected user name
+     */
+    get connectedUserName() {
+        return this._connectedUserName;
+    }
+    /**
+     * Get the refresh token.
+     *
+     * @returns the refresh token
+     */
+    get refreshToken() {
+        return this._refreshToken;
+    }
+    /**
+     * Get the connected system name. If previously set this will be used, otherwise the name is determined
+     * by the system auth type, or the validated url.
+     *
+     * @returns the connected system name
+     */
+    get connectedSystemName() {
+        if (this._connectedSystemName) {
+            return this._connectedSystemName;
+        }
+        if (this.systemAuthType === 'serviceKey') {
+            return this.serviceInfo?.systemid;
+        }
+        return this.validatedUrl;
+    }
+    /**
+     *
+     */
+    set connectedSystemName(value) {
+        this._connectedSystemName = value;
+    }
     /**
      * Calls a given service or system url to test its reachability and authentication requirements.
      * If the url is a system url, it will attempt to use the catalog service to get the service info.
@@ -78,7 +161,7 @@ class ConnectionValidator {
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
      * @returns the status code or error returned by the connection attempt
      */
-    async checkSapService(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion } = {}) {
+    async checkSapServiceUrl(url, username, password, { ignoreCertError = false, isSystem = false, odataVersion } = {}) {
         const isBAS = (0, btp_utils_1.isAppStudio)();
         try {
             // Auto add trailing '/' to path
@@ -92,13 +175,12 @@ class ConnectionValidator {
                 url.searchParams.append('saml2', 'disabled');
             }
             const axiosConfig = this.createAxiosConfig(url, ignoreCertError, username, password);
-            // If system, use catalog service to get the services info
             if (isSystem) {
-                await this.createSystemConnection(axiosConfig, odataVersion);
+                await this.createSystemConnection({ axiosConfig, url, odataVersion });
             }
             else {
                 // Full service URL
-                await this.createServiceConnection(axiosConfig, url.pathname);
+                await this.createOdataServiceConnection(axiosConfig, url.pathname);
             }
             this._validatedClient = url.searchParams.get(types_1.SAP_CLIENT_KEY) ?? undefined;
             return 200;
@@ -135,7 +217,8 @@ class ConnectionValidator {
             params: Object.fromEntries(url.searchParams),
             ignoreCertErrors: ignoreCertError,
             cookies: '',
-            baseURL: url.origin
+            baseURL: url.origin,
+            url: url.pathname
         };
         if (username && password) {
             axiosConfig = Object.assign(axiosConfig, {
@@ -153,35 +236,67 @@ class ConnectionValidator {
      * @param axiosConfig the axios request configuration
      * @param servicePath the service path without the origin
      */
-    async createServiceConnection(axiosConfig, servicePath) {
+    async createOdataServiceConnection(axiosConfig, servicePath) {
         this._axiosConfig = axiosConfig;
         this._serviceProvider = (0, axios_extension_1.create)(this._axiosConfig);
         this._odataService = this._serviceProvider.service(servicePath);
         logger_helper_1.default.attachAxiosLogger(this._serviceProvider.interceptors);
         await this._odataService.get('');
     }
+    resetConnectionState() {
+        this._serviceProvider = undefined;
+        this._odataService = undefined;
+        this._catalogV2 = undefined;
+        this._catalogV4 = undefined;
+        this._serviceInfo = undefined;
+        this._connectedUserName = undefined;
+        this._refreshToken = undefined;
+        this._connectedSystemName = undefined;
+        this.resetValidity();
+    }
     /**
-     * Create the connection for a system url. The system url should be provided as a base url axios config property.
+     * Create the connection for a system url, the specified axios config or the specified service info.
      *
-     * @param axiosConfig the axios request configuration
-     * @param odataVersion the odata version to restrict the catalog requests if only a specific version is required
+     * @param connectConfig the connection configuration
+     * @param connectConfig.axiosConfig the axios request configuration
+     * @param connectConfig.url the system url
+     * @param connectConfig.serviceInfo the service info
+     * @param connectConfig.odataVersion the odata version to restrict the catalog requests if only a specific version is required
      */
-    async createSystemConnection(axiosConfig, odataVersion) {
-        this._axiosConfig = axiosConfig;
-        this._serviceProvider = (0, axios_extension_1.createForAbap)(this._axiosConfig);
-        logger_helper_1.default.attachAxiosLogger(this._serviceProvider.interceptors);
+    async createSystemConnection({ axiosConfig, url, serviceInfo, odataVersion }) {
+        this.resetConnectionState();
+        if (this.systemAuthType === 'reentranceTicket' || this.systemAuthType === 'serviceKey') {
+            this._serviceProvider = this.getAbapOnCloudServiceProvider(url, serviceInfo);
+        }
+        else if (axiosConfig) {
+            this._axiosConfig = axiosConfig;
+            this._serviceProvider = (0, axios_extension_1.createForAbap)(axiosConfig);
+        }
+        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 {
-            this._catalogV2 ? await this._catalogV2.listServices() : await this._catalogV4.listServices();
+            if (this._catalogV2) {
+                await this._catalogV2?.listServices();
+            }
+            else if (this._catalogV4) {
+                v4Requested = true;
+                await this._catalogV4?.listServices();
+            }
         }
         catch (error) {
-            // We will try the v4 catalog if v2 returns a 404
-            if (error.response?.status === 404 && this._catalogV4) {
+            // We will try the v4 catalog if v2 returns a 404 or an auth code. Try the v4 catalog with the credentials provided also
+            // as the user may not be authorized for the v2 catalog specifically.
+            if (this._catalogV4 &&
+                !v4Requested &&
+                this.shouldAttemptV4Catalog(error.response?.status)) {
                 await this._catalogV4.listServices();
             }
             else {
@@ -190,13 +305,87 @@ class ConnectionValidator {
         }
     }
     /**
-     * Validates the service url format as well as its reachability.
+     * Check if we should attempt to use the v4 catalog service as a fallback.
      *
-     * @param serviceUrl the odata service url to validate
+     * @param statusCode http status code, if not provided will return false as we cannot determine the reason for v2 catalog request failure
+     * @returns true if we should attempt the v4 catalog service
+     */
+    shouldAttemptV4Catalog(statusCode) {
+        if (!statusCode) {
+            return false;
+        }
+        const errorType = error_handler_1.ErrorHandler.getErrorType(statusCode);
+        return errorType === error_handler_1.ERROR_TYPE.NOT_FOUND || errorType === error_handler_1.ERROR_TYPE.AUTH;
+    }
+    /**
+     * Callback for when the refresh token changes.
+     *
+     * @param refreshToken the new refresh token
+     */
+    async refreshTokenChangedCb(refreshToken) {
+        logger_helper_1.default.logger.debug(`ConnectionValidator.refreshTokenChangedCb()`);
+        this._refreshToken = refreshToken;
+    }
+    /**
+     * Get the service provider for the Abap on Cloud environment.
+     *
+     * @param url the system url
+     * @param serviceInfo the service info
+     * @returns the service provider
+     */
+    getAbapOnCloudServiceProvider(url, serviceInfo) {
+        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()
+            });
+        }
+        if (this.systemAuthType === 'serviceKey' && serviceInfo) {
+            return (0, axios_extension_1.createForAbapOnCloud)({
+                environment: axios_extension_1.AbapCloudEnvironment.Standalone,
+                service: serviceInfo,
+                refreshTokenChangedCb: this.refreshTokenChangedCb.bind(this)
+            });
+        }
+        throw new Error('Invalid system auth type');
+    }
+    /**
+     * Validate the system connectivity with the specified service info (containing UAA details).
+     *
+     * @param serviceInfo the service info containing the UAA details
+     * @param odataVersion the odata version to restrict the catalog requests if only a specific version is required
+     * @returns true if the system is reachable, false if not, or an error message string
+     */
+    async validateServiceInfo(serviceInfo, odataVersion) {
+        if (!serviceInfo) {
+            return false;
+        }
+        try {
+            this.systemAuthType = 'serviceKey';
+            await this.createSystemConnection({ serviceInfo, odataVersion });
+            // Cache the user info
+            this._connectedUserName = await this.serviceProvider.user();
+            this._serviceInfo = serviceInfo;
+            this._validatedUrl = serviceInfo.url;
+            return this.getValidationResultFromStatusCode(200);
+        }
+        catch (error) {
+            logger_helper_1.default.logger.debug(`ConnectionValidator.validateServiceInfo() - error: ${error.message}`);
+            if (error?.isAxiosError) {
+                this.getValidationResultFromStatusCode(error?.response?.status || error?.code);
+            }
+            return prompt_helpers_1.errorHandler.getErrorMsg(error) ?? false;
+        }
+    }
+    /**
+     * Validates the system or service url format as well as its reachability.
+     *
+     * @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 even if the same url has been prevously validated
-     * @param options.isSystem if true, the url will be treated as a system url rather than a service url
+     * @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
      * @returns true if the url is reachable, false if not, or an error message string
      */
@@ -214,7 +403,7 @@ class ConnectionValidator {
                 return (0, i18n_1.t)('errors.invalidUrl');
             }
             // Ignore path if a system url
-            const status = await this.checkSapService(url, undefined, undefined, {
+            const status = await this.checkSapServiceUrl(url, undefined, undefined, {
                 ignoreCertError,
                 isSystem,
                 odataVersion
@@ -228,7 +417,7 @@ class ConnectionValidator {
             // More helpful context specific error
             if (error_handler_1.ErrorHandler.getErrorType(error) === error_handler_1.ERROR_TYPE.CONNECTION) {
                 this.validity.reachable = false;
-                return prompt_helpers_1.errorHandler.logErrorMsgs((0, i18n_1.t)('errors.systemOrserviceUrlNotFound', { url: serviceUrl }));
+                return prompt_helpers_1.errorHandler.logErrorMsgs((0, i18n_1.t)('errors.systemOrServiceUrlNotFound', { url: serviceUrl }));
             }
             this.resetValidity();
             const errorMsg = prompt_helpers_1.errorHandler.getErrorMsg(error);
@@ -236,11 +425,11 @@ class ConnectionValidator {
         }
     }
     /**
-     * Translate the status code into a validation result.
+     * Converts the http status code into 'validty' and returns true if the status code indicates that the URL was reachable.
      * Sets the instance validity state based on the status code.
      *
      * @param status a http request status code used to determine the validation result
-     * @returns true if the url is reachable, false if not, or an error message string
+     * @returns true, if the status code indicates the url is reachable, false if not, or an error message string
      */
     getValidationResultFromStatusCode(status) {
         if (status === 200) {
@@ -298,9 +487,9 @@ class ConnectionValidator {
      * Check whether basic auth is required for the given url, or for the previously validated url if none specified.
      * This will also set the validity state for the url. This will not validate the URL.
      *
-     * @param urlString - the url to validate, if not provided the previously validated url will be used
-     * @param client - optional, sap client code, if not provided the previously validated client will be used
-     * @param ignoreCertError
+     * @param urlString the url to validate, if not provided the previously validated url will be used
+     * @param client optional, sap client code, if not provided the previously validated client will be used
+     * @param ignoreCertError ignore some certificate errors
      * @returns true if basic auth is required, false if not
      */
     async isAuthRequired(urlString = this._validatedUrl, client = this._validatedClient, ignoreCertError = false) {
@@ -319,8 +508,13 @@ class ConnectionValidator {
             if (client) {
                 url.searchParams.append(types_1.SAP_CLIENT_KEY, client);
             }
-            this.validity.authRequired = this.validity.reachable =
-                error_handler_1.ErrorHandler.getErrorType(await this.checkSapService(url, undefined, undefined, { ignoreCertError })) === error_handler_1.ERROR_TYPE.AUTH;
+            const authError = error_handler_1.ErrorHandler.getErrorType(await this.checkSapServiceUrl(url, undefined, undefined, { ignoreCertError })) === error_handler_1.ERROR_TYPE.AUTH;
+            // Only if we get the specific auth error so we know that auth is required, otherwise we cannot determine so leave as undefined
+            if (authError) {
+                this.validity.authRequired = true;
+                this.validity.reachable = true;
+            }
+            // Returning undefined if we cannot determine if auth is required
             return this.validity.authRequired;
         }
         catch (error) {
@@ -329,7 +523,7 @@ class ConnectionValidator {
         }
     }
     /**
-     * Test the connectivity with the specified service url using the provided credentials.
+     * Test the connectivity with the specified service url using the provided credentials (basic authentication).
      *
      * @param url the url to validate
      * @param username user name
@@ -341,7 +535,7 @@ class ConnectionValidator {
      * @param options.odataVersion if specified will restrict catalog requests to only the specified odata version
      * @returns true if the authentication is successful, false if not, or an error message string
      */
-    async validateAuth(url, username, password, { ignoreCertError = false, isSystem = false, sapClient, odataVersion } = {}) {
+    async validateAuth(url, username, password, { ignoreCertError = false, sapClient, odataVersion, isSystem = false } = {}) {
         if (!url) {
             return false;
         }
@@ -350,7 +544,8 @@ class ConnectionValidator {
             if (sapClient) {
                 urlObject.searchParams.append(types_1.SAP_CLIENT_KEY, sapClient);
             }
-            const status = await this.checkSapService(urlObject, username, password, {
+            this.systemAuthType = 'basic';
+            const status = await this.checkSapServiceUrl(urlObject, username, password, {
                 ignoreCertError,
                 isSystem,
                 odataVersion

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

@@ -0,0 +1,9 @@
+import type { ServiceInstanceInfo } from '@sap/cf-tools';
+import type { ListChoiceOptions } from 'inquirer';
+/**
+ * Get the name sorted list of ABAP instance choices from an active CF login. If not logged in, an error message is logged.
+ *
+ * @returns The list of ABAP instance choices
+ */
+export declare function getABAPInstanceChoices(): Promise<ListChoiceOptions<ServiceInstanceInfo>[]>;
+//# sourceMappingURL=cf-helper.d.ts.map

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getABAPInstanceChoices = void 0;
+const cf_tools_1 = require("@sap/cf-tools");
+const error_handler_1 = require("../../../../error-handler/error-handler");
+const i18n_1 = require("../../../../i18n");
+const prompt_helpers_1 = require("../../../prompt-helpers");
+const AbapEnvType = {
+    ABAP: 'abap',
+    ABAP_TRIAL: 'abap-trial',
+    ABAP_CANARY: 'abap-canary',
+    ABAP_OEM: 'abap-oem',
+    ABAP_OEM_CANARY: 'abap-oem-canary',
+    ABAP_HAAS: 'abap-haas',
+    ABAP_STAGING: 'abap-staging',
+    ABAP_INTERNAL_STAGING: 'abap-internal-staging',
+    DESTINATION: 'destination'
+};
+/**
+ * Get the name sorted list of ABAP instance choices from an active CF login. If not logged in, an error message is logged.
+ *
+ * @returns The list of ABAP instance choices
+ */
+async function getABAPInstanceChoices() {
+    const choices = [];
+    try {
+        const filteredInstances = [
+            AbapEnvType.ABAP,
+            AbapEnvType.ABAP_TRIAL,
+            AbapEnvType.ABAP_CANARY,
+            AbapEnvType.ABAP_OEM,
+            AbapEnvType.ABAP_OEM_CANARY,
+            AbapEnvType.ABAP_HAAS,
+            AbapEnvType.ABAP_STAGING,
+            AbapEnvType.ABAP_INTERNAL_STAGING
+        ];
+        const serviceInstanceInfo = await (0, cf_tools_1.apiGetServicesInstancesFilteredByType)(filteredInstances);
+        if (serviceInstanceInfo.length > 0) {
+            serviceInstanceInfo.forEach((service) => {
+                choices.push({ name: service['label'], value: service });
+            });
+        }
+        else {
+            // No envs found
+            prompt_helpers_1.errorHandler.logErrorMsgs(error_handler_1.ERROR_TYPE.NO_ABAP_ENVS, (0, i18n_1.t)('errors.noAbapEnvsInCFSpace'));
+        }
+    }
+    catch (error) {
+        // Cannot connect to CF
+        prompt_helpers_1.errorHandler.logErrorMsgs(error_handler_1.ERROR_TYPE.NO_ABAP_ENVS, (0, i18n_1.t)('errors.abapEnvsCFDiscoveryFailed'));
+    }
+    return choices.sort((a, b) => (a.name ? a.name.localeCompare(b.name ?? '') : 0));
+}
+exports.getABAPInstanceChoices = getABAPInstanceChoices;
+//# sourceMappingURL=cf-helper.js.map

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

@@ -0,0 +1,34 @@
+import type { ServiceInstanceInfo } from '@sap/cf-tools';
+import type { Question } from 'inquirer';
+import { type OdataServiceAnswers, type OdataServicePromptOptions } from '../../../../types';
+import { ConnectionValidator } from '../../../connectionValidator';
+declare const systemUrlPromptName: "abapOnBtp:newSystemUrl";
+declare const abapOnBtpPromptNames: {
+    readonly abapOnBtpAuthType: "abapOnBtpAuthType";
+    readonly serviceKey: "serviceKey";
+    readonly cloudFoundryAbapSystem: "cloudFoundryAbapSystem";
+};
+export type AbapOnBTPType = 'cloudFoundry' | 'serviceKey' | 'reentranceTicket';
+interface AbapOnBtpAnswers extends Partial<OdataServiceAnswers> {
+    [abapOnBtpPromptNames.abapOnBtpAuthType]?: AbapOnBTPType;
+    [systemUrlPromptName]?: string;
+    [abapOnBtpPromptNames.serviceKey]?: string;
+    [abapOnBtpPromptNames.cloudFoundryAbapSystem]?: ServiceInstanceInfo;
+}
+/**
+ * Get the questions for the ABAP on BTP system. The questions will prompt the user for the system type (Cloud Foundry, Service Key, Re-entrance Ticket).
+ *
+ * @param promptOptions The prompt options which control the service selection and system name]
+ * @returns The list of questions for the ABAP on BTP system
+ */
+export declare function getAbapOnBTPSystemQuestions(promptOptions?: OdataServicePromptOptions): Question<AbapOnBtpAnswers>[];
+/**
+ * Get the Cloud Foundry Abap system discovery prompt. This prompt will list all available ABAP environments in the connected Cloud Foundry space.
+ * If the Cloud Foundry connection fails, a warning message will be displayed.
+ *
+ * @param connectionValidator The connection validator
+ * @returns The Cloud Foundry ABAP system discovery prompt
+ */
+export declare function getCFDiscoverPrompts(connectionValidator: ConnectionValidator): Question[];
+export {};
+//# sourceMappingURL=questions.d.ts.map