@sap/ux-ui5-tooling 1.20.3 → 1.21.0

package/dist/preview-middleware/dist/client/cpe/odata-health/odata-health-checker.ts

@@ -0,0 +1,150 @@
+import type * as ManifestNamespace from '@ui5/manifest/types/manifest';
+import Log from 'sap/base/Log';
+import ODataModelV2 from 'sap/ui/model/odata/v2/ODataModel';
+import ODataModelV4 from 'sap/ui/model/odata/v4/ODataModel';
+import RuntimeAuthoring from 'sap/ui/rta/RuntimeAuthoring';
+import { ODataDownStatus, ODataHealthStatus, ODataMetadata, ODataUpStatus } from './odata-health-status';
+
+type Manifest = ManifestNamespace.SAPJSONSchemaForWebApplicationManifestFile;
+type DataSource = ManifestNamespace.DataSource;
+
+/**
+ * The OData version type.
+ */
+type ODataVersion = 'v2' | 'v4' | '2.0' | '4.0' | '4.01';
+
+/**
+ * Describes an OData service instance.
+ */
+interface ODataServiceInfo {
+    /**
+     * The URL of the OData service.
+     */
+    serviceUrl: string;
+    /**
+     * The OData protocol version.
+     */
+    oDataVersion: ODataVersion;
+}
+
+/**
+ * Use this class to do a health check for all available OData services, supports both v2 and v4
+ * format. This health checker ensures not only that $metadata is valid, but also that the UI5 framework
+ * itself can consume the service via its models.
+ */
+export class ODataHealthChecker {
+    /**
+     * The OData type.
+     */
+    private static readonly ODATA_TYPE: string = 'OData';
+
+    /**
+     * The default OData version.
+     */
+    private static readonly DEFAULT_ODATA_VERSION: ODataVersion = 'v2';
+
+    /**
+     * Use this helper function to filter the OData data source items from the manifest.
+     * @param src The service data source.
+     * @returns True if the data source represents an OData service.
+     */
+    private readonly isOdataService = (src: DataSource): boolean => src.type === ODataHealthChecker.ODATA_TYPE;
+
+    /**
+     * Use this helper function to map the OData data source to the internal structure
+     * used in this class.
+     * @param src The OData service data source.
+     * @returns The OData service info object.
+     */
+    private readonly toOdataServiceInfo = (src: DataSource): ODataServiceInfo => ({
+        serviceUrl: src.uri,
+        oDataVersion: src.settings?.odataVersion ?? ODataHealthChecker.DEFAULT_ODATA_VERSION
+    });
+
+    constructor(private readonly rta: RuntimeAuthoring) {}
+
+    /**
+     * Does a health check to all available OData services.
+     *
+     * @returns Resolves with an array containing the health
+     * status for each OData service.
+     */
+    async getHealthStatus(): Promise<ODataHealthStatus[]> {
+        const oDataHealthCheckStartTime = Date.now();
+
+        const services = this.getServices();
+        const metadataPromises = await Promise.allSettled(
+            services.map(({ serviceUrl, oDataVersion }) => this.getServiceMetadata(serviceUrl, oDataVersion))
+        );
+
+        const oDataHealthCheckDurationInSec = ((Date.now() - oDataHealthCheckStartTime) / 1000).toFixed(2);
+        Log.info(`OData service health check took ${oDataHealthCheckDurationInSec} sec.`);
+
+        return metadataPromises.map((metadataPromise, idx) =>
+            metadataPromise.status === 'fulfilled'
+                ? new ODataUpStatus(services[idx].serviceUrl)
+                : new ODataDownStatus(services[idx].serviceUrl, metadataPromise.reason)
+        );
+    }
+
+    /**
+     * This method does a strong health check (with the ODataModel). This ensures not only
+     * that the $metadata is valid, but also that the UI5 framework itself can consume the service via its models.
+     * Some services may have valid $metadata but still fail in the UI5’s ODataModel
+     * (e.g., weird annotations, CORS issues, etc.).
+     *
+     * @param serviceUrl The OData service url.
+     * @param oDataVersion The OData version.
+     * @returns Resolved with valid metadata.
+     */
+    private getServiceMetadata(serviceUrl: string, oDataVersion: ODataVersion): Promise<ODataMetadata> {
+        switch (oDataVersion) {
+            case 'v2':
+            case '2.0':
+                return this.getServiceV2Metadata(serviceUrl);
+            case 'v4':
+            case '4.0':
+            case '4.01':
+                return this.getServiceV4Metadata(serviceUrl);
+        }
+    }
+
+    private getServiceV2Metadata(serviceUrl: string): Promise<ODataMetadata> {
+        const oModel = new ODataModelV2({
+            serviceUrl,
+            json: true,
+            // We do not want the annotations concatenated to the final result.
+            loadAnnotationsJoined: false
+        });
+        // This method actually returns promise which is resolved with the metadata.
+        return oModel.metadataLoaded(true).finally(
+            // Do clean up in case the helath check is done multiple times.
+            () => oModel.destroy()
+        );
+    }
+
+    private getServiceV4Metadata(serviceUrl: string): Promise<ODataMetadata> {
+        const oModel = new ODataModelV4({
+            serviceUrl,
+            // Only metadata loaded. We only want the model to load $metadata,
+            // not fetch entity data or bind to any UI controls.
+            synchronizationMode: 'None'
+        });
+        // This method actually returns promise which is resolved with the metadata.
+        return oModel
+            .getMetaModel()
+            .requestObject('/')
+            .finally(
+                // Do clean up in case the helath check is done multiple times.
+                () => oModel.destroy()
+            );
+    }
+
+    private getServices(): ODataServiceInfo[] {
+        const manifest: Manifest = this.rta.getRootControlInstance().getManifest() as unknown as Manifest;
+        const dataSources = manifest?.['sap.app']?.dataSources;
+        return Object.values(dataSources ?? {})
+            .filter(this.isOdataService)
+            .map(this.toOdataServiceInfo);
+    }
+}

package/dist/preview-middleware/dist/client/cpe/odata-health/odata-health-status.js

@@ -0,0 +1,63 @@
+"use strict";
+
+sap.ui.define([], function () {
+  "use strict";
+
+  /**
+   * Represents the status for a healthy OData service.
+   */
+  class ODataUpStatus {
+    /**
+     * Creates an instance representing a healthy OData service.
+     *
+     * @param serviceUrl The service url.
+     */
+    constructor(serviceUrl) {
+      this.serviceUrl = serviceUrl;
+    }
+  }
+
+  /**
+   * Represents the status for an unhealthy OData service.
+   */
+  class ODataDownStatus {
+    /**
+     * Creates an instance representing an unhealthy OData service.
+     *
+     * @param serviceUrl The service url.
+     * @param reason The provided reason for the failure.
+     */
+    constructor(serviceUrl, reason) {
+      this.serviceUrl = serviceUrl;
+      this.reason = reason;
+      this.errorMessage = this.formatReason(reason);
+    }
+
+    /**
+     * Formats the reason.
+     *
+     * @param reason The provided reason for the failure.
+     * @returns Formatted reason as string.
+     */
+    formatReason(reason) {
+      if (reason instanceof Error) {
+        return reason.message;
+      }
+      if (typeof reason === 'string') {
+        return reason;
+      }
+      try {
+        return JSON.stringify(reason);
+      } catch {
+        return String(reason);
+      }
+    }
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.ODataUpStatus = ODataUpStatus;
+  __exports.ODataDownStatus = ODataDownStatus;
+  return __exports;
+});
+//# sourceMappingURL=odata-health-status.js.map

package/dist/preview-middleware/dist/client/cpe/odata-health/odata-health-status.ts

@@ -0,0 +1,52 @@
+export type ODataMetadata = Record<string, unknown>;
+
+/**
+ * Represents the status for a healthy OData service.
+ */
+export class ODataUpStatus {
+    /**
+     * Creates an instance representing a healthy OData service.
+     *
+     * @param serviceUrl The service url.
+     */
+    constructor(public readonly serviceUrl: string) {}
+}
+
+/**
+ * Represents the status for an unhealthy OData service.
+ */
+export class ODataDownStatus {
+    readonly errorMessage: string;
+
+    /**
+     * Creates an instance representing an unhealthy OData service.
+     *
+     * @param serviceUrl The service url.
+     * @param reason The provided reason for the failure.
+     */
+    constructor(public readonly serviceUrl: string, public readonly reason: unknown) {
+        this.errorMessage = this.formatReason(reason);
+    }
+
+    /**
+     * Formats the reason.
+     *
+     * @param reason The provided reason for the failure.
+     * @returns Formatted reason as string.
+     */
+    private formatReason(reason: unknown): string {
+        if (reason instanceof Error) {
+            return reason.message;
+        }
+        if (typeof reason === 'string') {
+            return reason;
+        }
+        try {
+            return JSON.stringify(reason);
+        } catch {
+            return String(reason);
+        }
+    }
+}
+
+export type ODataHealthStatus = ODataUpStatus | ODataDownStatus;

package/dist/preview-middleware/dist/client/cpe/outline/editable.js

@@ -0,0 +1,38 @@
+"use strict";
+
+sap.ui.define(["../control-data", "../utils", "sap/ui/dt/OverlayUtil", "sap/ui/dt/OverlayRegistry", "../../utils/core"], function (___control_data, ___utils, OverlayUtil, OverlayRegistry, ____utils_core) {
+  "use strict";
+
+  const buildControlData = ___control_data["buildControlData"];
+  const getRuntimeControl = ___utils["getRuntimeControl"];
+  const getComponent = ____utils_core["getComponent"];
+  const isEditable = (changeService, id = '') => {
+    let editable = false;
+    const control = sap.ui.getCore().byId(id);
+    if (!control) {
+      const component = getComponent(id);
+      if (component) {
+        return editable;
+      }
+    } else {
+      let controlOverlay = OverlayRegistry.getOverlay(control);
+      if (!controlOverlay?.getDomRef()) {
+        //look for closest control
+        controlOverlay = OverlayUtil.getClosestOverlayFor(control);
+      }
+      if (controlOverlay) {
+        const runtimeControl = getRuntimeControl(controlOverlay);
+        const controlData = buildControlData(runtimeControl, changeService, controlOverlay);
+        const prop = controlData.properties.find(item => item.isEnabled === true);
+        editable = prop !== undefined;
+      }
+    }
+    return editable;
+  };
+  var __exports = {
+    __esModule: true
+  };
+  __exports.isEditable = isEditable;
+  return __exports;
+});
+//# sourceMappingURL=editable.js.map

package/dist/preview-middleware/dist/client/cpe/outline/editable.ts

@@ -0,0 +1,30 @@
+import { buildControlData } from '../control-data';
+import { getRuntimeControl } from '../utils';
+import OverlayUtil from 'sap/ui/dt/OverlayUtil';
+import OverlayRegistry from 'sap/ui/dt/OverlayRegistry';
+import { getComponent } from '../../utils/core';
+import type { ChangeService } from '../changes';
+
+export const isEditable = (changeService: ChangeService, id = ''): boolean => {
+    let editable = false;
+    const control = sap.ui.getCore().byId(id);
+    if (!control) {
+        const component = getComponent(id);
+        if (component) {
+            return editable;
+        }
+    } else {
+        let controlOverlay = OverlayRegistry.getOverlay(control);
+        if (!controlOverlay?.getDomRef()) {
+            //look for closest control
+            controlOverlay = OverlayUtil.getClosestOverlayFor(control);
+        }
+        if (controlOverlay) {
+            const runtimeControl = getRuntimeControl(controlOverlay);
+            const controlData = buildControlData(runtimeControl, changeService, controlOverlay);
+            const prop = controlData.properties.find((item) => item.isEnabled === true);
+            editable = prop !== undefined;
+        }
+    }
+    return editable;
+};

package/dist/preview-middleware/dist/client/cpe/outline/nodes.js

@@ -0,0 +1,212 @@
+"use strict";
+
+sap.ui.define(["sap/base/Log", "../../utils/core", "../../utils/error", "../utils", "./editable", "../../utils/fe-v4"], function (Log, ____utils_core, ____utils_error, ___utils, ___editable, ____utils_fe_v4) {
+  "use strict";
+
+  const getControlById = ____utils_core["getControlById"];
+  const getError = ____utils_error["getError"];
+  const getOverlay = ___utils["getOverlay"];
+  const isEditable = ___editable["isEditable"];
+  const getConfigMapControlIdMap = ____utils_fe_v4["getConfigMapControlIdMap"];
+  const getPageName = ____utils_fe_v4["getPageName"];
+  /**
+   * Retrieves additional data for a given control ID.
+   *
+   * @param id The unique identifier of the control.
+   * @returns An object containing the text and the technical name of the control.
+   */
+  function getAdditionalData(id) {
+    const control = getControlById(id);
+    if (!control) {
+      return {};
+    }
+    const metadata = control.getMetadata();
+    const details = {};
+    const technicalName = metadata.getElementName();
+    if (technicalName) {
+      details.technicalName = technicalName;
+    }
+    if (metadata.getProperty('text')) {
+      const text = control.getProperty('text');
+      if (typeof text === 'string' && text.trim() !== '') {
+        details.text = text;
+      }
+    }
+    return details;
+  }
+
+  /**
+   * Gets the children nodes of an aggregation type node.
+   *
+   * @param current The current node to retrieve children from
+   * @returns An array of children nodes, or an empty array if none are found
+   */
+  function getChildren(current) {
+    return (current.elements ?? []).flatMap(element => {
+      if (element.type === 'aggregation') {
+        return element.elements ?? [];
+      } else if (element.type === 'extensionPoint') {
+        return [element];
+      }
+      return [];
+    });
+  }
+
+  /**
+   * Adds a new child node to the extension point's children array based on the given control ID.
+   *
+   * @param {string} id - The unique identifier of the control to be added as a child node.
+   * @param {OutlineNode[]} children - The array of children nodes to which the new node will be added.
+   * @param {ChangeService} changeService - Change service for change stack event handling.
+   */
+  function addChildToExtensionPoint(id, children, changeService) {
+    const {
+      text,
+      technicalName
+    } = getAdditionalData(id);
+    const editable = isEditable(changeService, id);
+    children.push({
+      controlId: id,
+      controlType: technicalName ?? 'sap.ui.extensionpoint.child',
+      name: text ?? id,
+      visible: true,
+      editable,
+      children: [],
+      hasDefaultContent: false
+    });
+  }
+  /**
+   * Creates control index for all controls in the app.
+   *
+   * @param {ControlTreeIndex} controlIndex - Control index for the ui5 app.
+   * @param {OutlineNode} node - control node added to the outline.
+   */
+  function indexNode(controlIndex, node) {
+    const indexedControls = controlIndex[node.controlType];
+    if (indexedControls) {
+      indexedControls.push(node);
+    } else {
+      controlIndex[node.controlType] = [node];
+    }
+  }
+  function addToPropertyIdMap(node, propertyIdMap) {
+    const control = getControlById(node.controlId);
+    if (control) {
+      const overlay = getOverlay(control);
+      const overlayData = overlay?.getDesignTimeMetadata().getData();
+      if (!overlayData?.manifestPropertyPath) {
+        return;
+      }
+      if (overlayData) {
+        const path = overlayData?.manifestPropertyPath?.(control);
+        const pageName = getPageName(control);
+        const key = getConfigMapControlIdMap(pageName, path.split('/').filter(item => item));
+        if (key) {
+          if (!propertyIdMap.get(key)) {
+            propertyIdMap.set(key, []);
+          }
+          propertyIdMap.get(key)?.push(node.controlId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Transform node.
+   *
+   * @param input outline view node
+   * @param scenario type of project
+   * @param controlIndex Control tree index
+   * @param changeService ChangeService for change stack event handling.
+   * @param propertyIdMap ChangeService for change stack event handling.
+   * @returns transformed outline tree nodes
+   */
+  async function transformNodes(input, scenario, controlIndex, changeService, propertyIdMap) {
+    const stack = [...input];
+    const items = [];
+    while (stack.length) {
+      try {
+        const current = stack.shift();
+        const editable = isEditable(changeService, current?.id);
+        const isAdp = scenario === 'ADAPTATION_PROJECT';
+        const isExtPoint = current?.type === 'extensionPoint';
+        if (current?.type === 'element') {
+          const children = getChildren(current);
+          const {
+            text
+          } = getAdditionalData(current.id);
+          const technicalName = current.technicalName.split('.').slice(-1)[0];
+          const transformedChildren = isAdp ? await handleDuplicateNodes(children, scenario, controlIndex, changeService, propertyIdMap) : await transformNodes(children, scenario, controlIndex, changeService, propertyIdMap);
+          const node = {
+            controlId: current.id,
+            controlType: current.technicalName,
+            name: text ?? technicalName,
+            editable,
+            visible: current.visible ?? true,
+            children: transformedChildren
+          };
+          indexNode(controlIndex, node);
+          addToPropertyIdMap(node, propertyIdMap);
+          items.push(node);
+        }
+        if (isAdp && isExtPoint) {
+          const {
+            defaultContent = [],
+            createdControls = []
+          } = current.extensionPointInfo;
+          const children = [];
+          // We can combine both because there can only be either defaultContent or createdControls for one extension point node.
+          [...defaultContent, ...createdControls].forEach(id => {
+            addChildToExtensionPoint(id, children, changeService);
+          });
+          const node = {
+            controlId: `${current.id}--${current.name ?? ''}`,
+            controlType: current.technicalName,
+            name: current.name ?? '',
+            editable,
+            visible: current.visible ?? true,
+            children,
+            hasDefaultContent: defaultContent.length > 0
+          };
+          items.push(node);
+        }
+      } catch (error) {
+        Log.error('Failed to transform outline node!', getError(error));
+      }
+    }
+    return items;
+  }
+
+  /**
+   * Handles duplicate nodes that are retrieved from extension point default content and created controls,
+   * if they exist under an extension point these controls are removed from the children array
+   *
+   * @param children outline view node children
+   * @param scenario type of project
+   * @param controlIndex Control tree index
+   * @param changeService ChangeService for change stack event handling.
+   * @param propertyIdMap  Map<string, string[]>.
+   * @returns transformed outline tree nodes
+   */
+  async function handleDuplicateNodes(children, scenario, controlIndex, changeService, propertyIdMap) {
+    const extPointIDs = new Set();
+    children.forEach(child => {
+      if (child.type === 'extensionPoint') {
+        const {
+          defaultContent = [],
+          createdControls = []
+        } = child.extensionPointInfo;
+        [...defaultContent, ...createdControls].forEach(id => extPointIDs.add(id));
+      }
+    });
+    const uniqueChildren = children.filter(child => !extPointIDs.has(child.id));
+    return transformNodes(uniqueChildren, scenario, controlIndex, changeService, propertyIdMap);
+  }
+  var __exports = {
+    __esModule: true
+  };
+  __exports.transformNodes = transformNodes;
+  __exports.handleDuplicateNodes = handleDuplicateNodes;
+  return __exports;
+});
+//# sourceMappingURL=nodes.js.map