@sap-ux/fiori-mcp-server 0.0.1

package/dist/page-editor-api/parser/tree.js

@@ -0,0 +1,464 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOOLEAN_DISPLAY_FALSE = exports.BOOLEAN_DISPLAY_TRUE = void 0;
+exports.getNodeId = getNodeId;
+exports.getGenericBase = getGenericBase;
+exports.getPropertyData = getPropertyData;
+exports.traverseTree = traverseTree;
+exports.getTree = getTree;
+exports.findNodeByAnnotationNodeId = findNodeByAnnotationNodeId;
+exports.findByPath = findByPath;
+const src_1 = require("@sap/ux-specification/dist/types/src");
+const model_1 = require("./model");
+exports.BOOLEAN_DISPLAY_TRUE = 'True';
+exports.BOOLEAN_DISPLAY_FALSE = 'False';
+const NOT_ALLOWED_IN_FOOTER_AGGREGATION_NAMES = [model_1.DATA_FIELD_FOR_INTENT_BASED_NAVIGATION, model_1.DATA_FIELD_FOR_ACTION_GROUP];
+/**
+ * Method returns dom id for node.
+ *
+ * @param path Node path.
+ * @returns Outline node id.
+ */
+function getNodeId(path) {
+    return `outline-node${path.replace(/\//g, '-')}`;
+}
+/**
+ * Creates a generic `TreeNodeProperty` object from a property or aggregation.
+ *
+ * @param name - The name of the property.
+ * @param displayName - The display name of the property.
+ * @param property - The source property or aggregation.
+ * @param schemaPath - The schema path for the property.
+ * @returns The generated tree node property.
+ */
+function getGenericBase(name, displayName, property, schemaPath) {
+    return {
+        schemaPath,
+        artifactType: property.artifactType,
+        description: property.description ?? '',
+        name,
+        displayName,
+        // Default
+        type: 'string',
+        value: property.value
+    };
+}
+/**
+ * Method checks if passed value is a valid number.
+ *
+ * @param value Value as unknown type.
+ * @returns Is nummber value.
+ */
+const isNumber = (value) => {
+    return !isNaN(value) && !isNaN(value - 0);
+};
+/**
+ * Method returns options for passed enum entries.
+ *
+ * @param entries Enum entries.
+ * @returns Array of options.
+ */
+const getEnumOptions = (entries) => {
+    const options = [];
+    // Empty value for deletion
+    options.push({
+        key: '',
+        text: ''
+    });
+    for (const option of entries) {
+        let optionDisplay = option;
+        if (typeof option === 'boolean') {
+            // For boolean type display appropriate string entry
+            optionDisplay = option ? exports.BOOLEAN_DISPLAY_TRUE : exports.BOOLEAN_DISPLAY_FALSE;
+            options.push({
+                key: option,
+                text: optionDisplay
+            });
+        }
+        else if (typeof option === 'string') {
+            if (isNumber(parseFloat(option))) {
+                options.push({
+                    key: parseFloat(option),
+                    text: option?.toString()
+                });
+            }
+            else {
+                options.push({
+                    key: option,
+                    text: option
+                });
+            }
+        }
+        else if (typeof option === 'number' && isNumber(option)) {
+            options.push({
+                key: option,
+                text: option?.toString()
+            });
+        }
+    }
+    return options;
+};
+/**
+ * Updates a string property definition based on its JSON Schema.
+ *
+ * @param property The tree node property being updated.
+ * @param schema The JSON Schema definition for the property.
+ */
+function updateStringProperty(property, schema) {
+    if (schema.enum || schema.oneOf) {
+        let options = [];
+        if (schema.enum) {
+            options = getEnumOptions(schema.enum);
+        }
+        else if (schema.oneOf) {
+            options = schema.oneOf.map((entry) => {
+                const text = entry.const;
+                return {
+                    key: entry.const,
+                    text
+                };
+            });
+            // Empty value for deletion
+            options.unshift({
+                key: '',
+                text: '',
+                reset: true
+            });
+        }
+        property.options = options;
+    }
+}
+/**
+ * Generates a `TreeNodeProperty` with type-specific configurations based on a `SettingOption`.
+ *
+ * @param name - The name of the property.
+ * @param displayName - The display name of the property.
+ * @param property - The source property.
+ * @param schemaPath - The schema path for the property.
+ * @returns The configured tree node property, or `undefined` if unhandled.
+ */
+function getPropertyData(name, displayName, property, schemaPath) {
+    const type = property.schema.type;
+    const propertyInstance = getGenericBase(name, displayName, property, schemaPath);
+    switch (type) {
+        case 'string':
+            propertyInstance.type = 'string';
+            updateStringProperty(propertyInstance, property.schema);
+            break;
+        case 'number': {
+            propertyInstance.type = 'number';
+            break;
+        }
+        case 'boolean': {
+            propertyInstance.type = 'boolean';
+            propertyInstance.options = [
+                {
+                    key: undefined,
+                    text: ''
+                },
+                {
+                    key: true,
+                    text: 'True'
+                },
+                {
+                    key: false,
+                    text: 'False'
+                }
+            ];
+            break;
+        }
+        default: {
+            if (property.schema.enum) {
+                getEnumOptions(property.schema.enum);
+            }
+            else {
+                console.warn('Unhandled property', property);
+            }
+            break;
+        }
+    }
+    return propertyInstance;
+}
+/**
+ * Recursively collects properties from an aggregation and its child aggregations,
+ * converting them into `TreeNodeProperty` objects.
+ *
+ * @param aggregation - The root aggregation to extract properties from.
+ * @param breadCrumbs - The chain of parent aggregations leading to this aggregation (used for recursive context).
+ * @returns A flat list of properties and nested object properties derived from the aggregation.
+ */
+function getProperties(aggregation, breadCrumbs = []) {
+    const properties = [];
+    // Standard properties on same level as visible aggregation
+    const names = Object.keys(aggregation.properties);
+    if (names.length) {
+        names.forEach((name) => {
+            const property = aggregation.properties[name];
+            const schemaPath = aggregation.path.concat(name);
+            const genericProperty = getPropertyData(name, property.name, property, schemaPath);
+            if (genericProperty) {
+                properties.push(genericProperty);
+            }
+        });
+    }
+    // Complex properties which is on deeper level
+    for (const name in aggregation.aggregations) {
+        const childAggregation = aggregation.aggregations[name];
+        if (childAggregation.isViewNode) {
+            continue;
+        }
+        const objectProperty = getGenericBase(name, childAggregation.name ?? name, childAggregation, childAggregation.path);
+        objectProperty.type = 'object';
+        const subProperties = getProperties(childAggregation, [...breadCrumbs, aggregation]);
+        if (subProperties.length) {
+            objectProperty.properties = subProperties;
+        }
+        properties.push(objectProperty);
+    }
+    return properties;
+}
+/**
+ * Recursive method goes through aggregation tree and creates tree node.
+ *
+ * @param aggregation Start Aggregation.
+ * @param traverseNodeData Traverse data contains traverse context information.
+ * @returns Outline tree node.
+ */
+function traverseTree(aggregation, traverseNodeData) {
+    const { text, level, model } = traverseNodeData;
+    let { path } = traverseNodeData;
+    const children = [];
+    const aggregationKeys = aggregation.getAggregationKeys(true);
+    // Apply received filter to nodes
+    const id = getNodeId(aggregation === model.root ? 'root-node' : `${path}-node`);
+    if (aggregation.virtual && model.pageType === src_1.PageTypeV4.FPMCustomPage) {
+        // Root virtual node should be ignored during path resolution
+        // Macros within Custom Page does not have separate property in config.json,
+        // in result to match ids between outline and properties panel - id path should be reset
+        path = '';
+    }
+    for (const name of aggregationKeys) {
+        const aggregationPath = path + '/' + name;
+        const childAggregation = aggregation.aggregations[name];
+        // external/app I18n bundle is not supported currently
+        // const appI18n = getAppI18nBundle();
+        // const i18nBundle = getRelevantI18nBundle(childAggregation, appI18n.bundles, appI18n.projectType);
+        // const displayText = childAggregation.getDisplayName(i18nBundle);
+        const displayText = childAggregation.getDisplayName();
+        const node = traverseTree(childAggregation, {
+            ...traverseNodeData,
+            level: level + 1,
+            path: aggregationPath,
+            text: displayText
+        });
+        children.push(node);
+    }
+    let annotationNodeId = aggregation.annotationNodeId;
+    if (!annotationNodeId && (aggregation instanceof model_1.RootAggregation || aggregation instanceof model_1.ViewsAggregation)) {
+        annotationNodeId = [];
+    }
+    return {
+        id: id,
+        path: aggregation.path.map((subPath) => subPath),
+        children,
+        text: text,
+        additionalText: aggregation.additionalText,
+        moveProps: getMovable(model, aggregation),
+        title: aggregation.getTechnicalName(),
+        properties: getProperties(aggregation),
+        annotationNodeId,
+        type: getNodeType(aggregation),
+        value: aggregation.value
+    };
+}
+/**
+ * Method returns node's movable props.
+ *
+ * @param model Edit model.
+ * @param aggregation Aggregation object.
+ * @returns Movable props.
+ */
+function getMovable(model, aggregation) {
+    // Custom extensions are movable, but annotation nodes depends if annotation support feature is enabled
+    if (model.root !== aggregation) {
+        const isMovable = true;
+        const moveProps = {
+            movable: aggregation.sortableItem === model_1.SortingOptions.Enabled && isMovable,
+            allowedParents: getAllowedParentPaths(model.root, aggregation),
+            allowedChildTypes: aggregation.sortableList && aggregation.sortableCollection
+                ? [aggregation.sortableCollection]
+                : undefined,
+            type: aggregation.sortableCollection
+        };
+        if (aggregation.sortableItem === model_1.SortingOptions.Excluded) {
+            moveProps.dropRestricted = true;
+        }
+        return moveProps;
+    }
+    return undefined;
+}
+/**
+ * Method returns array of node paths, which are allowed to drop/move in.
+ *
+ * @param root Root aggregation.
+ * @param aggregation Target aggregation to get alowed parents.
+ * @returns Array of diagnostic messages for passed aggregation.
+ */
+function getAllowedParentPaths(root, aggregation) {
+    let result;
+    if (aggregation.custom) {
+        const allowedDropRange = aggregation.parent?.getAllowedDropRange(aggregation);
+        result = [];
+        if (aggregation.parent && allowedDropRange) {
+            result.push({
+                path: aggregation.parent.path,
+                allowedRanges: allowedDropRange
+            });
+        }
+    }
+    else if (aggregation.dropUINodes) {
+        let allowedParents = root.findAllowedDropAggregations(aggregation);
+        if (NOT_ALLOWED_IN_FOOTER_AGGREGATION_NAMES.some((aggName) => aggregation.name?.startsWith(aggName))) {
+            // restrict moving navigation node to footer - special case
+            allowedParents = allowedParents.filter((allowedParent) => !(0, model_1.isArrayEqual)(allowedParent.path, ['footer', 'actions']));
+        }
+        result = allowedParents.map((allowedParent) => ({
+            path: allowedParent.path,
+            allowedRanges: allowedParent.range
+        }));
+    }
+    return result;
+}
+/**
+ * Determines the aggregation node type for a given `ObjectAggregation`.
+ *
+ * @param aggregation - The aggregation instance to evaluate.
+ * @returns The corresponding node type, or `undefined` if not recognized.
+ */
+function getNodeType(aggregation) {
+    let type;
+    if (aggregation.custom) {
+        if (aggregation instanceof model_1.ActionAggregation) {
+            type = model_1.AggregationNodeType.customAction;
+        }
+        else if (aggregation instanceof model_1.ColumnAggregation) {
+            type = model_1.AggregationNodeType.customColumn;
+        }
+        else if (aggregation instanceof model_1.FilterFieldAggregation) {
+            type = model_1.AggregationNodeType.customFilterField;
+        }
+        else if (aggregation instanceof model_1.SectionAggregation) {
+            type = model_1.AggregationNodeType.customSection;
+        }
+    }
+    else if (aggregation.path.length === 0) {
+        type = model_1.AggregationNodeType.rootNode;
+    }
+    else if (aggregation instanceof model_1.ViewsAggregation) {
+        type = model_1.AggregationNodeType.views;
+    }
+    return type;
+}
+/**
+ * Method creates tree for passed edit model.
+ *
+ * @param schema Page or application schema.
+ * @param data Configuration file mapped to schema.
+ * @param pageType Page type. If pageType is not passed, then considered as application.
+ * @param annotation Page annotations.
+ * @returns Outline tree.
+ */
+function getTree(schema, data, pageType, annotation) {
+    const model = new model_1.PageEditModel('Root', pageType, data, schema, annotation ?? {
+        dynamicNodes: {},
+        nodes: []
+    });
+    const node = traverseTree(model.root, {
+        level: 0,
+        path: '',
+        text: model.name,
+        model
+    });
+    // Update root node
+    node.root = true;
+    return node;
+}
+/**
+ * Method finds node by passed annotation nodeId.
+ *
+ * @param tree Nodes tree to lookup.
+ * @param nodeId Annotation node id.
+ * @returns Found node information.
+ */
+function findNodeByAnnotationNodeId(tree, nodeId) {
+    for (const node of tree) {
+        if ((0, model_1.isArrayEqual)(node.annotationNodeId, nodeId)) {
+            // If the current node is the target, return it and its parent as null
+            return node;
+        }
+        else if (node.children) {
+            // If the current node has children, search for the target in each child
+            const foundNode = findNodeByAnnotationNodeId(node.children, nodeId);
+            if (foundNode) {
+                // If the target is found in a child, return the child as the node and the current node as the parent
+                return foundNode;
+            }
+        }
+    }
+    // If the target is not found
+    return undefined;
+}
+/**
+ * Finds a node or property in a tree by its property path.
+ *
+ * @param tree - The tree of nodes to search.
+ * @param propertyPath - The path of the property to find.
+ * @returns The matching node or property if found, otherwise `undefined`.
+ */
+function findByPath(tree, propertyPath) {
+    for (const node of tree) {
+        // Check if the node itself matches
+        if ((0, model_1.isArrayEqual)(node.path, propertyPath)) {
+            return { node };
+        }
+        // Check direct properties of the node
+        for (const property of node.properties) {
+            if ((0, model_1.isArrayEqual)(property.schemaPath, propertyPath)) {
+                return { property };
+            }
+            // Recursively search in nested properties
+            const result = searchProperty(property, propertyPath);
+            if (result) {
+                return { node, property: result };
+            }
+        }
+        // Recursively search in children nodes
+        const result = node.children ? findByPath(node.children, propertyPath) : undefined;
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}
+/**
+ * Recursively searches nested properties of a `TreeNodeProperty` for a matching schema path.
+ *
+ * @param property - The property to search within.
+ * @param propertyPath - The schema path to match.
+ * @returns The matching nested property if found, otherwise `undefined`.
+ */
+function searchProperty(property, propertyPath) {
+    if (property.properties) {
+        for (const child of property.properties) {
+            if ((0, model_1.isArrayEqual)(child.schemaPath, propertyPath)) {
+                return child;
+            }
+            const result = searchProperty(child, propertyPath);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=tree.js.map

package/dist/page-editor-api/project.d.ts

@@ -0,0 +1,40 @@
+import type { ApplicationAccess, Manifest } from '@sap-ux/project-access';
+import type { FileData } from '@sap/ux-specification/dist/types/src';
+/**
+ * Method returns main service of the application.
+ *
+ * @param appAccess Application access.
+ * @returns main service name
+ */
+export declare function getMainService(appAccess: ApplicationAccess): string;
+/**
+ * Retrieves the service name for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to the service name
+ */
+export declare function getServiceName(appAccess: ApplicationAccess): Promise<string>;
+/**
+ * Reads annotation files for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to an array of FileData objects
+ */
+export declare function readAnnotationFiles(appAccess: ApplicationAccess): Promise<FileData[]>;
+/**
+ * Retrieves the manifest file for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to the Manifest object or undefined if not found
+ */
+export declare function getManifest(appAccess: ApplicationAccess): Promise<Manifest | undefined>;
+/**
+ * Returns the project's ui5version.
+ * It reads the vesion from minUI5Version in the manifest.json.
+ * If the minUI5Version is not a number, then 'latest' is returned as default value in case of exceptions.
+ *
+ * @param appAccess - application access object.
+ * @returns Resolved UI5 version for passed application.
+ */
+export declare function getUI5Version(appAccess: ApplicationAccess): Promise<string>;
+//# sourceMappingURL=project.d.ts.map

package/dist/page-editor-api/project.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMainService = getMainService;
+exports.getServiceName = getServiceName;
+exports.readAnnotationFiles = readAnnotationFiles;
+exports.getManifest = getManifest;
+exports.getUI5Version = getUI5Version;
+const project_access_1 = require("@sap-ux/project-access");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Method returns main service of the application.
+ *
+ * @param appAccess Application access.
+ * @returns main service name
+ */
+function getMainService(appAccess) {
+    const appId = appAccess.getAppId();
+    const project = appAccess.project;
+    let mainService;
+    if (appId === undefined) {
+        const appIds = Object.keys(project.apps);
+        mainService = project.apps[appIds[0]].mainService;
+    }
+    else {
+        const app = project.apps[appId];
+        if (!app) {
+            throw new Error('ERROR_INVALID_APP_ID');
+        }
+        mainService = app.mainService;
+    }
+    return mainService ?? 'mainService';
+}
+/**
+ * Retrieves the service name for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to the service name
+ */
+async function getServiceName(appAccess) {
+    let serviceName = getMainService(appAccess);
+    if (appAccess.projectType === 'CAPJava' || appAccess.projectType === 'CAPNodejs') {
+        // get CDS service name
+        serviceName = await (0, project_access_1.getCapServiceName)(appAccess.project.root, appAccess.app?.services?.[serviceName].uri ?? '');
+    }
+    return serviceName;
+}
+/**
+ * Reads annotation files for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to an array of FileData objects
+ */
+async function readAnnotationFiles(appAccess) {
+    const annotationData = [];
+    const mainServiceName = getMainService(appAccess);
+    const mainService = appAccess.app?.services?.[mainServiceName];
+    if (!mainService) {
+        return [];
+    }
+    if (mainService.uri && (appAccess.projectType === 'CAPJava' || appAccess.projectType === 'CAPNodejs')) {
+        const serviceUri = mainService?.uri ?? '';
+        if (serviceUri) {
+            const edmx = await (0, project_access_1.readCapServiceMetadataEdmx)(appAccess.root, serviceUri);
+            annotationData.push({
+                fileContent: edmx,
+                dataSourceUri: serviceUri
+            });
+        }
+    }
+    else {
+        if (mainService.local) {
+            const serviceFile = await (0, promises_1.readFile)(mainService.local);
+            annotationData.push({
+                dataSourceUri: mainService.local,
+                fileContent: serviceFile.toString()
+            });
+        }
+        const { annotations = [] } = mainService;
+        for (const annotation of annotations) {
+            if (annotation.local) {
+                const annotationFile = await (0, promises_1.readFile)(annotation.local);
+                annotationData.push({
+                    dataSourceUri: annotation.local,
+                    fileContent: annotationFile.toString()
+                });
+            }
+        }
+    }
+    return annotationData;
+}
+/**
+ * Retrieves the manifest file for the application.
+ *
+ * @param appAccess - The application access object
+ * @returns A promise that resolves to the Manifest object or undefined if not found
+ */
+async function getManifest(appAccess) {
+    const absoluteWebappPath = await (0, project_access_1.getWebappPath)(appAccess.app.appRoot);
+    const manifest = (0, path_1.join)(absoluteWebappPath, project_access_1.FileName.Manifest);
+    if (!(0, fs_1.existsSync)(manifest)) {
+        return undefined;
+    }
+    const file = await (0, promises_1.readFile)(manifest);
+    return JSON.parse(file.toString());
+}
+/**
+ * Returns the project's ui5version.
+ * It reads the vesion from minUI5Version in the manifest.json.
+ * If the minUI5Version is not a number, then 'latest' is returned as default value in case of exceptions.
+ *
+ * @param appAccess - application access object.
+ * @returns Resolved UI5 version for passed application.
+ */
+async function getUI5Version(appAccess) {
+    const manifest = await getManifest(appAccess);
+    let ui5Version = manifest ? (0, project_access_1.getMinimumUI5Version)(manifest) : undefined;
+    if (ui5Version !== undefined && isNaN(parseFloat(ui5Version))) {
+        ui5Version = 'latest';
+    }
+    return ui5Version ?? 'latest';
+}
+//# sourceMappingURL=project.js.map