feat: Enhance system and app prompt validations

packages/adp-tooling/src/base/constants/index.ts

@@ -1,3 +1,13 @@
+export const UI5_CDN_URL = 'https://ui5.sap.com';
+export const UI5_VERSIONS_CDN_URL = 'https://sapui5.hana.ondemand.com/version.json';
+export const UI5_VERSIONS_NEO_CDN_URL = 'https://ui5.sap.com/neo-app.json';
+export const SNAPSHOT_CDN_URL = 'https://sapui5preview-sapui5.dispatcher.int.sap.eu2.hana.ondemand.com:443';
+
+export const CURRENT_SYSTEM_VERSION = '(system version)';
+export const LATEST_VERSION = '(latest)';
+export const SNAPSHOT_VERSION = 'snapshot';
+export const SNAPSHOT_UNTESTED_VERSION = 'snapshot-untested';
+
 export const S4HANA_APPS_PARAMS = {
     'sap.app/type': 'application',
     'sap.fiori/cloudDevAdaptationStatus': 'released',

packages/adp-tooling/src/client/abap-client.ts

@@ -0,0 +1,46 @@
+import { type AbapServiceProvider, AdtCatalogService, UI5RtVersionService } from '@sap-ux/axios-extension';
+import type { FlexUISupportedSystem } from '../types';
+
+/**
+ * Fetches system supports Flex UI features.
+ *
+ * @param provider
+ * @param isCustomerBase
+ * @returns {Promise<FlexUISupportedSystem | undefined>} settings indicating support for onPremise and UI Flex capabilities.
+ */
+export async function getFlexUISupportedSystem(
+    provider: AbapServiceProvider,
+    isCustomerBase: boolean
+): Promise<FlexUISupportedSystem> {
+    if (!isCustomerBase) {
+        return {
+            isOnPremise: true,
+            isUIFlex: true
+        };
+    }
+    const FILTER = {
+        'scheme': 'http://www.sap.com/adt/categories/ui_flex',
+        'term': 'dta_folder'
+    };
+    const acceptHeaders = {
+        headers: {
+            Accept: 'application/*'
+        }
+    };
+    const response = await provider.get(AdtCatalogService.ADT_DISCOVERY_SERVICE_PATH, acceptHeaders);
+
+    return { isOnPremise: response.data.includes(FILTER.term), isUIFlex: response.data.includes(FILTER.scheme) };
+}
+
+/**
+ * Fetches system UI5 Version from UI5RtVersionService.
+ *
+ * @param provider
+ * @returns {string | undefined} system UI5 version
+ */
+export async function getSystemUI5Version(provider: AbapServiceProvider): Promise<string | undefined> {
+    const service = await provider.getAdtService<UI5RtVersionService>(UI5RtVersionService);
+    const version = await service?.getUI5Version();
+
+    return version;
+}

packages/adp-tooling/src/client/index.ts

@@ -1,3 +1,5 @@
 export * from './target-applications';
 export * from './target-systems';
 export * from './abap-provider';
+export * from './abap-client';
+export * from './target-manifest';

packages/adp-tooling/src/client/target-manifest.ts

@@ -0,0 +1,149 @@
+import type { ToolsLogger } from '@sap-ux/logger';
+import type { Manifest } from '@sap-ux/project-access';
+import type { AbapServiceProvider } from '@sap-ux/axios-extension';
+
+import { t } from '../i18n';
+
+/**
+ * Interface representing cached manifest data.
+ */
+export interface ManifestCache {
+    /**
+     * The URL from which the manifest was fetched.
+     */
+    url: string;
+    /**
+     * The parsed manifest data.
+     */
+    manifest: Manifest | undefined;
+}
+
+/**
+ * Service class for handling operations related to application manifests.
+ */
+export class TargetManifest {
+    private manifestCache = new Map<string, ManifestCache>();
+
+    /**
+     * Creates an instance of ManifestManager.
+     *
+     * @param {AbapProvider} provider - The ABAP provider service.
+     * @param {ToolsLogger} [logger] - The logger.
+     */
+    constructor(private readonly provider: AbapServiceProvider, private readonly logger?: ToolsLogger) {}
+
+    /**
+     * Resets the manifest cache.
+     */
+    public resetCache(): void {
+        this.manifestCache = new Map();
+    }
+
+    /**
+     * Retrieves the cached manifest for a specified application.
+     *
+     * @param {string} id - The ID of the application whose manifest is needed.
+     * @returns {Promise<Manifest | undefined>} The cached manifest or null if not available.
+     */
+    public async getManifest(id: string): Promise<Manifest | undefined> {
+        await this.loadManifest(id);
+        return this.manifestCache.get(id)?.manifest;
+    }
+
+    /**
+     * Retrieves the cached manifest URL for a specified application.
+     *
+     * @param {string} id - The ID of the application whose manifest URL is needed.
+     * @returns {Promise<string | undefined>} The cached URL or an empty string if not available.
+     */
+    public async getUrl(id: string): Promise<string | undefined> {
+        await this.loadManifestUrl(id);
+        return this.manifestCache.get(id)?.url;
+    }
+
+    /**
+     * Retrieves and caches the manifest URL and the manifest itself for a specific application.
+     * Uses caching to avoid redundant network requests.
+     *
+     * @param {string} id - The ID of the application for which to load the manifest.
+     * @returns {Promise<void>} The manifest URL.
+     */
+    private async loadManifestUrl(id: string): Promise<void> {
+        const cached = this.manifestCache.get(id);
+        if (cached?.url) {
+            return;
+        }
+
+        const appIndex = this.provider.getAppIndex();
+        const data = await appIndex.getAppInfo(id);
+
+        if (data) {
+            const appInfo = Object.values(data)[0];
+            const url = appInfo?.manifestUrl ?? appInfo?.manifest ?? '';
+            this.manifestCache.set(id, { url, manifest: undefined });
+        }
+    }
+
+    /**
+     * Fetches and stores the application manifest from a URL.
+     *
+     * @param {string} id - The application ID.
+     * @returns {Promise<Manifest>} The fetched manifest.
+     */
+    private async loadManifest(id: string): Promise<void> {
+        let cached = this.manifestCache.get(id);
+
+        if (cached?.manifest) {
+            return;
+        }
+
+        if (!cached?.url) {
+            await this.loadManifestUrl(id);
+            cached = this.manifestCache.get(id);
+        }
+
+        if (!cached?.url) {
+            throw new Error('Manifest URL could not be loaded.');
+        }
+
+        try {
+            const response = await this.provider.request({ url: cached.url });
+
+            const manifest = JSON.parse(response.data) as Manifest;
+
+            if (typeof manifest !== 'object' || manifest === null) {
+                throw new Error('Manifest parsing error. Manifest is not in expected format.');
+            }
+
+            this.manifestCache.set(id, { url: cached.url, manifest });
+        } catch (e) {
+            this.logger?.debug(`Failed to load manifest, error: ${e.message}`);
+            throw new Error(`Failed to load manifest from URL: ${e.message}`);
+        }
+    }
+
+    /**
+     * Determines if the application supports manifest-first approach and manifest url exists.
+     *
+     * @param {string} id - The application ID.
+     * @returns {Promise<boolean>} True if supported, otherwise throws an error.
+     */
+    public async isAppSupported(id: string): Promise<boolean> {
+        const appIndex = this.provider.getAppIndex();
+        const isSupported = await appIndex.getIsManiFirstSupported(id);
+
+        if (!isSupported) {
+            this.logger?.debug(`Application '${id}' is not supported by Adaptation Project`);
+            throw new Error(t('validators.appDoesNotSupportManifest'));
+        }
+
+        const url = await this.getUrl(id);
+
+        if (!url) {
+            this.logger?.debug(`Manifest url for app '${id}' was not found!`);
+            throw new Error(t('validators.adpDoesNotSupportSelectedApp'));
+        }
+
+        return true;
+    }
+}

packages/adp-tooling/src/index.ts

@@ -9,6 +9,7 @@ export * from './base/helper';
 export * from './client';
 export * from './preview/adp-preview';
 export * from './writer/writer-config';
+export * from './ui5';
 export { getCustomConfig } from './writer/project-utils';
 export { generate, migrate } from './writer';
 export { generateChange } from './writer/editors';

packages/adp-tooling/src/translations/adp-tooling.i18n.json

@@ -67,7 +67,9 @@
         "errorDuplicateNamesOData": "OData Service Name must be different from OData Annotation Data Source Name",
         "errorInputInvalidValuePrefix": "{{value}} should start with '{{prefix}}'",
         "errorCustomerEmptyValue": "{{value}} should contain at least one character in addition to '{{prefix}}'",
-        "errorInvalidDataSourceURI": "Invalid URI. Should start and end with '/' and contain no spaces"
+        "errorInvalidDataSourceURI": "Invalid URI. Should start and end with '/' and contain no spaces",
+        "appDoesNotSupportManifest": "Select a different application. The selected application is not supported by Adaptation Project. Please refer to SAPUI5 Adaptation Project documentation for more information.",
+        "adpDoesNotSupportSelectedApp": "Select a different application. Adaptation project doesn't support the selected application."
     },
     "choices": {
         "true": "true",

packages/adp-tooling/src/types.ts

@@ -115,6 +115,22 @@ export interface TargetApplication {
     bspName: string;
 }
 
+export interface FlexUISupportedSystem {
+    isUIFlex: boolean;
+    isOnPremise: boolean;
+}
+
+export interface UI5Version {
+    latest: VersionDetail;
+    [key: string]: VersionDetail;
+}
+
+export interface VersionDetail {
+    version: string;
+    support: string;
+    lts: boolean;
+}
+
 export interface Endpoint extends Partial<Destination> {
     Name: string;
     Url?: string;

packages/adp-tooling/src/ui5/fetchers.ts

@@ -0,0 +1,33 @@
+import type { UI5Version } from '../types';
+import { UI5_VERSIONS_CDN_URL, UI5_VERSIONS_NEO_CDN_URL, LATEST_VERSION } from '../base/constants';
+
+/**
+ * Fetches public UI5 version data from the SAP CDN.
+ *
+ * @returns {Promise<UI5Version>} A promise that resolves to the UI5 version data object.
+ * @throws Will throw an error if the fetch fails.
+ */
+export async function fetchPublicVersions(): Promise<UI5Version> {
+    const response = await fetch(UI5_VERSIONS_CDN_URL);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch public UI5 versions. Status: ${response.status}`);
+    }
+    return await response.json();
+}
+
+/**
+ * Fetches internal UI5 versions from the Neo CDN and maps them to formatted version strings.
+ *
+ * @param {string} latestVersion - The latest public UI5 version.
+ * @returns {Promise<string[]>} A promise that resolves to an array of formatted internal version strings.
+ */
+export async function fetchInternalVersions(latestVersion: string): Promise<string[]> {
+    const response = await fetch(UI5_VERSIONS_NEO_CDN_URL);
+    const data = await response.json();
+
+    return data?.routes?.map((route: { target: { version: string } }) => {
+        return route.target.version === latestVersion
+            ? `${route.target.version} ${LATEST_VERSION}`
+            : route.target.version;
+    });
+}

packages/adp-tooling/src/ui5/index.ts

@@ -0,0 +1,2 @@
+export * from './ui5-version-manager';
+export * from './utils';