@sap-ux/fiori-mcp-server 0.0.1

package/dist/tools/functionalities/page/application.js

@@ -0,0 +1,616 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = exports.DELETE_PAGE_FUNCTIONALITY = exports.ADD_PAGE_FUNCTIONALITY = void 0;
+const src_1 = require("@sap/ux-specification/dist/types/src");
+const page_editor_api_1 = require("../../../page-editor-api");
+const serviceStore_1 = require("./serviceStore");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const project_access_1 = require("@sap-ux/project-access");
+const path_1 = require("path");
+const constant_1 = require("../../../constant");
+const utils_2 = require("../../utils");
+exports.ADD_PAGE_FUNCTIONALITY = {
+    functionalityId: constant_1.ADD_PAGE,
+    name: 'Add new page to application by updating manifest.json',
+    description: 'Create new fiori elements page like ListReport, ObjectPage, CustomPage',
+    parameters: []
+};
+exports.DELETE_PAGE_FUNCTIONALITY = {
+    functionalityId: constant_1.DELETE_PAGE,
+    name: 'Delete page from application by updating manifest.json',
+    description: 'Remove existing fiori elements page from the application',
+    parameters: []
+};
+/**
+ * Represents an application instance with its metadata, access configuration and functionality details.
+ */
+class Application {
+    serviceName;
+    appData;
+    appId;
+    applicationAccess;
+    params;
+    /**
+     * Creates a new instance of the Application class.
+     *
+     * @param root0 - The constructor arguments.
+     * @param root0.params - Input parameters for functionality details.
+     * @param root0.applicationAccess - The application access object.
+     * @param root0.appId - The unique identifier of the application.
+     * @param root0.serviceName - The service name associated with the application.
+     * @param root0.appData - Metadata and configuration data for the application.
+     */
+    constructor({ params, applicationAccess, appId, serviceName, appData }) {
+        this.params = params;
+        this.serviceName = serviceName;
+        this.appData = appData;
+        this.appId = appId;
+        this.applicationAccess = applicationAccess;
+    }
+    /**
+     * Gets the name of an allowed navigation option.
+     *
+     * @param navigation - The allowed navigation option.
+     * @returns The name of the navigation option.
+     */
+    getAllowedNavigationsName(navigation) {
+        return navigation.name;
+    }
+    /**
+     * Generates a string representation of all allowed navigation options.
+     *
+     * @param navigations - An array of allowed navigation options.
+     * @returns A comma-separated string of navigation names.
+     */
+    getAllowedNavigationsOutput(navigations) {
+        return navigations.map((navigation) => this.getAllowedNavigationsName(navigation)).join(', ');
+    }
+    /**
+     * Generates an error message for missing navigation.
+     *
+     * @param reason - The reason for the missing navigation.
+     * @param navigations - An array of allowed navigation options.
+     * @param parentPageId - Optional ID of the parent page.
+     * @returns An error message string.
+     */
+    getMissingNavigationMessage(reason, navigations, parentPageId) {
+        let message = '';
+        switch (reason) {
+            case types_1.MissingNavigationReason.NoAnyNavigationsForParent: {
+                message = 'page does not have valid navigation for add';
+                break;
+            }
+            case types_1.MissingNavigationReason.NotFoundNavigationForParent: {
+                message = `provided 'navigation' was not found. ${parentPageId} has following navigations available: ${this.getAllowedNavigationsOutput(navigations)}`;
+                break;
+            }
+            case types_1.MissingNavigationReason.NoEntityProvided: {
+                message = `provide 'entitySet' for very first page`;
+                break;
+            }
+            case types_1.MissingNavigationReason.NotFoundEntity: {
+                message = `provided 'entitySet' was not found. Following entitySets available: ${this.getAllowedNavigationsOutput(navigations)}`;
+                break;
+            }
+        }
+        return message;
+    }
+    /**
+     * Calculates the context path for a page.
+     *
+     * @param parentPage - Optional parent page definition.
+     * @param navigationProperty - Optional navigation property.
+     * @param entitySet - Optional entity set.
+     * @returns The calculated context path or undefined.
+     */
+    calculateContextPath(parentPage, navigationProperty, entitySet) {
+        let contextPath;
+        if (!parentPage || parentPage.pageType === src_1.PageTypeV4.ListReport) {
+            contextPath = `/${entitySet}`;
+        }
+        else if (parentPage.contextPath) {
+            contextPath =
+                navigationProperty && parentPage.routePattern !== ':?query:'
+                    ? `${parentPage.contextPath}/${navigationProperty}`
+                    : `/${entitySet}`;
+        }
+        else if (parentPage.entitySet) {
+            contextPath = this.calculateContextPathBasedOnEntitySet(parentPage, navigationProperty);
+        }
+        return contextPath;
+    }
+    /**
+     * Calculates the context path based on the entity set of the parent page.
+     *
+     * @param parentPage - The parent page definition.
+     * @param navigationProperty - Optional navigation property.
+     * @returns The calculated context path or undefined.
+     */
+    calculateContextPathBasedOnEntitySet(parentPage, navigationProperty) {
+        let contextPath;
+        const routePattern = parentPage.routePattern;
+        const convertedParentPattern = routePattern?.replace(':?query:', '').replace(/\({[^}]*}\)/g, '');
+        if (!convertedParentPattern) {
+            contextPath =
+                navigationProperty && navigationProperty !== ''
+                    ? `/${parentPage.entitySet}/${navigationProperty}`
+                    : `/${parentPage.entitySet}`;
+        }
+        else {
+            contextPath =
+                navigationProperty && navigationProperty !== ''
+                    ? `/${convertedParentPattern}/${navigationProperty}`
+                    : `/${convertedParentPattern}`;
+        }
+        return contextPath;
+    }
+    /**
+     * Creates an error response object.
+     *
+     * @param message - The error message.
+     * @returns An ExecuteFunctionalityOutput object with error details.
+     */
+    createErrorResponse(message) {
+        return {
+            functionalityId: constant_1.ADD_PAGE,
+            status: 'Failed',
+            message,
+            parameters: [],
+            appPath: this.params.appPath,
+            changes: [],
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * Validates the input for page creation.
+     *
+     * @param newPage - The new page details.
+     * @param pages - Existing pages in the application.
+     * @param viewName - Optional view name for custom pages.
+     * @returns A promise that resolves to an ExecuteFunctionalityOutput object if there's an error, or null if validation passes.
+     */
+    async validatePageCreationInput(newPage, pages, viewName) {
+        if (pages.length && !newPage.parent) {
+            return this.createErrorResponse('Provide "parentPage" for page creation');
+        }
+        if (newPage.pageType === src_1.PageTypeV4.CustomPage) {
+            const validationError = this.validateCustomPageViewName(viewName);
+            if (validationError) {
+                return validationError;
+            }
+        }
+        return null;
+    }
+    /**
+     * Validates the view name for a custom page.
+     *
+     * @param viewName - The view name to validate.
+     * @returns An ExecuteFunctionalityOutput object if there's an error, or null if validation passes.
+     */
+    validateCustomPageViewName(viewName) {
+        const standardEnding = '.view.xml';
+        const cleanViewName = viewName?.endsWith(standardEnding) ? viewName.slice(0, -standardEnding.length) : viewName;
+        if (!cleanViewName) {
+            return this.createErrorResponse('Provide "viewName" for CustomPage');
+        }
+        if (!/^[a-z][a-z0-9_-]*$/i.exec(cleanViewName)) {
+            return this.createErrorResponse(`'viewName' must not contain spaces, must start with an upper-case letter, and may contain letters, digits, and underscores.`);
+        }
+        return null;
+    }
+    /**
+     * Validates the navigation input for page creation.
+     *
+     * @param parentPage - The parent page definition, if any.
+     * @param navigation - Optional navigation string.
+     * @param entitySet - Optional entity set.
+     * @param pages - Array of existing page definitions.
+     * @returns A promise that resolves to an ExecuteFunctionalityOutput object if there's an error, or null if validation passes.
+     */
+    async validateNavigationInput(parentPage, navigation, entitySet, pages = []) {
+        if (pages.length && !parentPage) {
+            return this.createErrorResponse('provided "parentPage" was not found');
+        }
+        const navigations = await this.getAllowedNavigations(parentPage);
+        if (parentPage && !navigations.length) {
+            const message = this.getMissingNavigationMessage(types_1.MissingNavigationReason.NoAnyNavigationsForParent, navigations);
+            return this.createErrorResponse(message);
+        }
+        const targetNavigation = this.findTargetNavigation(navigations, navigation, entitySet);
+        if (parentPage && !targetNavigation) {
+            const message = this.getMissingNavigationMessage(types_1.MissingNavigationReason.NotFoundNavigationForParent, navigations, parentPage.pageId);
+            return this.createErrorResponse(message);
+        }
+        if (!parentPage && !entitySet) {
+            const message = this.getMissingNavigationMessage(types_1.MissingNavigationReason.NoEntityProvided, navigations);
+            return this.createErrorResponse(message);
+        }
+        if (!parentPage && !targetNavigation) {
+            const message = this.getMissingNavigationMessage(types_1.MissingNavigationReason.NotFoundEntity, navigations);
+            return this.createErrorResponse(message);
+        }
+        return null;
+    }
+    /**
+     * Finds the target navigation option based on the provided navigation or entity set.
+     *
+     * @param navigations - Array of allowed navigation options.
+     * @param navigation - Optional navigation string to search for.
+     * @param entitySet - Optional entity set to search for.
+     * @returns The matching AllowedNavigationOptions object or undefined if not found.
+     */
+    findTargetNavigation(navigations, navigation, entitySet) {
+        return navigations.find((checkNavigation) => {
+            const name = checkNavigation.name.toLocaleLowerCase();
+            return name === navigation?.toLocaleLowerCase() || name === entitySet?.toLocaleLowerCase();
+        });
+    }
+    /**
+     * Generates a new page using the FPM writer.
+     *
+     * @param newPage - The new page details.
+     * @param parentPage - The parent page, if any.
+     * @param targetNavigation - The target navigation option.
+     * @param pages - Existing pages in the application.
+     * @param viewName - Optional view name for custom pages.
+     * @param entitySet - Optional entity set for the new page.
+     * @returns A promise that resolves to an object containing the new page ID and changes made.
+     */
+    async generatePageWithFPMWriter(newPage, parentPage, targetNavigation, pages, viewName, entitySet) {
+        const fpnNavigation = parentPage
+            ? {
+                sourceEntity: parentPage.entitySet,
+                sourcePage: parentPage.pageId,
+                navEntity: targetNavigation?.name,
+                navKey: true
+            }
+            : undefined;
+        const contextPath = this.calculateContextPath(parentPage, targetNavigation?.name, targetNavigation?.entitySet ?? entitySet);
+        const id = (0, utils_1.generatePageId)({
+            entitySet: targetNavigation?.entitySet ?? entitySet ?? '',
+            pageId: '',
+            pageType: newPage.pageType,
+            contextPath: contextPath,
+            viewName
+        }, parentPage?.pageId, pages, targetNavigation?.name);
+        const pageApi = {
+            id,
+            entity: targetNavigation?.entitySet ?? entitySet ?? '',
+            navigation: fpnNavigation,
+            contextPath
+        };
+        const changes = await this.writeFPM(newPage.pageType, pageApi, viewName);
+        return { pageID: id, changes };
+    }
+    /**
+     * Writes the Flexible Programming Model (FPM) configuration.
+     *
+     * @param pageType - The type of the page.
+     * @param fpmData - The page API configuration.
+     * @param viewName - Optional view name for custom pages.
+     * @returns A promise that resolves to an array of strings representing the changes made.
+     */
+    async writeFPM(pageType, fpmData, viewName) {
+        const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(this.applicationAccess);
+        let customExtension = src_1.CustomExtensionType.ListReport;
+        if (pageType === src_1.PageTypeV4.ObjectPage) {
+            customExtension = src_1.CustomExtensionType.ObjectPage;
+        }
+        if (pageType === src_1.PageTypeV4.CustomPage && viewName) {
+            customExtension = src_1.CustomExtensionType.CustomPage;
+        }
+        const folder = (0, utils_2.getDefaultExtensionFolder)(project_access_1.DirName.View);
+        return ftfsFileIo.writeFPM({
+            customExtension,
+            basePath: (0, path_1.join)(this.applicationAccess.project.root, this.appId),
+            data: { ...fpmData, folder }
+        });
+    }
+    /**
+     * Deletes navigation links for a given page.
+     *
+     * @param navigation - The navigation object containing links.
+     * @param pageName - The name of the page to remove links for.
+     */
+    deleteNavigationLinks(navigation, pageName) {
+        if (navigation) {
+            for (const key in navigation) {
+                const navigationPage = this.findPageByNavigation(navigation, key);
+                if (navigationPage === pageName) {
+                    delete navigation[key];
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Function to evaluate the navigation entry of a page.
+     * Old format (spec version <=3): <target page name>: <route name>.
+     * New format (spec version >=4): <route name>: { route: <target page name>}.
+     *
+     * @param pageObjNavigation - Page data.
+     * @param key - key in schema for the route definition.
+     * @returns the target page name from the route definition.
+     */
+    findPageByNavigation(pageObjNavigation, key) {
+        const navigationEntry = pageObjNavigation?.[key];
+        return typeof navigationEntry === 'string' ? key : navigationEntry?.route;
+    }
+    /**
+     * Method which deletes pages recursively by looping through navigation.
+     *
+     * @param app - Content of 'app.json'.
+     * @param pageName - page's name to remove
+     */
+    deletePageRecursively(app, pageName) {
+        if (!pageName) {
+            return;
+        }
+        const { pages } = app;
+        const settings = app.settings ?? {};
+        if (pages?.[pageName]) {
+            const page = pages?.[pageName];
+            delete pages[pageName];
+            // Delete controller extension of page
+            const extensionId = `${page.pageType}#${pageName}`;
+            if (settings.controllerExtensions?.[extensionId]) {
+                delete settings.controllerExtensions[extensionId];
+            }
+            // Delete child pages
+            if (page.navigation) {
+                for (const key in page.navigation) {
+                    const subPage = this.findPageByNavigation(page.navigation, key);
+                    this.deletePageRecursively(app, subPage);
+                }
+            }
+        }
+    }
+    /**
+     * Retrieves all pages defined in the application.
+     *
+     * @returns An array of PageDef objects representing the pages in the application.
+     */
+    getPages() {
+        const { config } = this.appData;
+        const { pages = {} } = config;
+        const result = [];
+        for (const pageId in pages) {
+            const page = pages[pageId];
+            result.push({
+                pageId,
+                pageType: page.pageType ?? src_1.PageTypeV4.ListReport,
+                entitySet: page.entitySet ?? '',
+                contextPath: page.contextPath,
+                routePattern: 'routePattern' in page && typeof page.routePattern === 'string' ? page.routePattern : undefined
+            });
+        }
+        return result;
+    }
+    /**
+     * Retrieves allowed navigation options for a given parent page.
+     *
+     * @param parentPage - Optional parent page definition.
+     * @param refresh - Whether to refresh the data from the service.
+     * @returns A promise that resolves to an array of AllowedNavigationOptions.
+     */
+    async getAllowedNavigations(parentPage, refresh = false) {
+        if (!parentPage || parentPage?.pageType === 'ListReport') {
+            // Entities from zero page or from list report
+            return this.getRootPageNavigationOptions(refresh);
+        }
+        // Navigation from object page or custom page
+        const service = await (0, serviceStore_1.getService)({
+            appName: this.appId,
+            project: this.applicationAccess.project,
+            serviceName: this.serviceName
+        });
+        return (await service.getAllowedNavigations(parentPage?.entitySet, parentPage?.entitySet, refresh)).map((navigation) => ({ ...navigation, isNavigation: true }));
+    }
+    /**
+     * Retrieves navigation options for the root page.
+     *
+     * @param refresh - Whether to refresh the data from the service.
+     * @returns A promise that resolves to an array of AllowedNavigationOptions.
+     */
+    async getRootPageNavigationOptions(refresh = false) {
+        const service = await (0, serviceStore_1.getService)({
+            appName: this.appId,
+            project: this.applicationAccess.project,
+            serviceName: this.serviceName
+        });
+        const entities = await service.getAllowedEntities(refresh);
+        return entities.map((entity) => {
+            return {
+                entitySet: entity.entitySet,
+                name: entity.entitySet
+            };
+        });
+    }
+    /**
+     * Retrieves creation options for a new page.
+     *
+     * @param pageType - Optional page type to get specific creation options.
+     * @returns A promise that resolves to GetFunctionalityDetailsOutput containing creation options.
+     */
+    async getCreationOptions(pageType) {
+        exports.ADD_PAGE_FUNCTIONALITY.parameters = [];
+        const pages = this.getPages();
+        if (pages.length) {
+            // Validate navigation
+            const navigationsMap = {};
+            let refreshNavigations = true;
+            for (const page of pages) {
+                const navigations = await this.getAllowedNavigations(page, refreshNavigations);
+                navigationsMap[page.pageId] = this.getAllowedNavigationsOutput(navigations);
+                // Pass with refresh only once
+                refreshNavigations = false;
+            }
+            if (pageType === src_1.PageTypeV4.CustomPage) {
+                exports.ADD_PAGE_FUNCTIONALITY.parameters.push({
+                    id: 'pageViewName',
+                    type: 'string',
+                    description: `Name of custom view file. First try to extract view name from user input that satisfies the pattern, if not possible ask user to provide view name`,
+                    pattern: '/^[a-zA-Z][a-zA-Z0-9_-]{0,}$/i',
+                    required: true
+                });
+            }
+            exports.ADD_PAGE_FUNCTIONALITY.parameters = [
+                {
+                    id: 'parentPage',
+                    type: 'string',
+                    description: `Parent page is id/name of parent page. First try to extract parent page from user input in a format defined in example, if not possible suggest content defined in options`,
+                    options: Object.keys(navigationsMap),
+                    required: true,
+                    examples: ['parentPage: ' + Object.keys(navigationsMap)[0]]
+                },
+                {
+                    id: 'pageNavigation',
+                    type: 'string',
+                    description: `Page navigation option for parent page. First try to extract navigation option from user input in a format defined in example, if not possible suggest content defined in options`,
+                    options: Object.keys(navigationsMap).map((item) => `for ${item}: available navigation(s) is/are one of: ${navigationsMap[item]}`),
+                    examples: ['pageNavigation: ' + Object.values(navigationsMap)[0].split(',')[0]],
+                    required: true
+                },
+                {
+                    id: 'pageType',
+                    type: 'string',
+                    description: `Type of page to be created. First try to extract page type from user input in a format defined in example, if not possible suggest content defined in options.`,
+                    options: Object.keys(src_1.PageTypeV4),
+                    examples: ['pageType: ' + Object.keys(src_1.PageTypeV4)[0]],
+                    required: true
+                }
+            ];
+            return exports.ADD_PAGE_FUNCTIONALITY;
+        }
+        // Creation of very first page
+        const entities = await this.getAllowedNavigations();
+        exports.ADD_PAGE_FUNCTIONALITY.parameters = [
+            {
+                id: 'entitySet',
+                type: 'string',
+                description: `Entity set for the new page. First try to extract entity from user input in a format defined in example, if not possible suggest content defined in options.`,
+                options: entities.map((entity) => this.getAllowedNavigationsName(entity)),
+                examples: ['entitySet: ' + entities.map((entity) => this.getAllowedNavigationsName(entity))[0]],
+                required: true
+            },
+            {
+                id: 'pageType',
+                type: 'string',
+                description: `Type of page to be created. First try to extract page type from user input in a format defined in example, if not possible suggest content defined in options.`,
+                options: Object.keys(src_1.PageTypeV4),
+                examples: ['pageType: ' + Object.keys(src_1.PageTypeV4)[0]],
+                required: true
+            }
+        ];
+        return exports.ADD_PAGE_FUNCTIONALITY;
+    }
+    /**
+     * Creates a new page in the application.
+     *
+     * @param newPage - Details of the new page to be created.
+     * @returns A promise that resolves to ExecuteFunctionalityOutput containing the result of the page creation.
+     */
+    async createPage(newPage) {
+        const { parent, navigation, pageType, entitySet } = newPage;
+        const viewName = newPage.pageType === src_1.PageTypeV4.CustomPage ? newPage.viewName : undefined;
+        const pages = this.getPages();
+        // Validate input parameters
+        const validationError = await this.validatePageCreationInput(newPage, pages, viewName);
+        if (validationError) {
+            return validationError;
+        }
+        // Find parent page and validate navigation
+        const parentPage = pages.find((page) => page.pageId === parent);
+        const navigationValidationError = await this.validateNavigationInput(parentPage, navigation, entitySet, pages);
+        if (navigationValidationError) {
+            return navigationValidationError;
+        }
+        // Generate the page
+        const navigations = await this.getAllowedNavigations(parentPage);
+        const targetNavigation = this.findTargetNavigation(navigations, navigation, entitySet);
+        const { pageID, changes } = await this.generatePageWithFPMWriter(newPage, parentPage, targetNavigation, pages, viewName, entitySet);
+        return {
+            functionalityId: constant_1.ADD_PAGE,
+            status: changes.length ? 'success' : 'skipped',
+            message: changes.length
+                ? `Page with id '${pageID}' of type '${pageType}' was created successfully in application '${this.appId}'`
+                : `No changes were made for '${pageType}'`,
+            parameters: [],
+            appPath: this.params.appPath,
+            changes,
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * Retrieves options for deleting a page.
+     *
+     * @returns A promise that resolves to GetFunctionalityDetailsOutput containing delete options.
+     */
+    async getDeleteOptions() {
+        exports.DELETE_PAGE_FUNCTIONALITY.parameters = [];
+        const pages = this.getPages();
+        exports.DELETE_PAGE_FUNCTIONALITY.parameters.push({
+            id: 'pageId',
+            type: 'string',
+            description: `Page id to be deleted. First try to extract page id from user input in a format defined in example, if not possible suggest content defined in options`,
+            options: pages.map((page) => page.pageId),
+            examples: ['pageId: ' + pages.map((page) => page.pageId)[0]],
+            required: true
+        });
+        return exports.DELETE_PAGE_FUNCTIONALITY;
+    }
+    /**
+     * Deletes a page from the application.
+     *
+     * @param page - The page to be deleted.
+     * @param page.pageId - The ID of the page to be deleted.
+     * @returns A promise that resolves to ExecuteFunctionalityOutput containing the result of the page deletion.
+     */
+    async deletePage(page) {
+        const { pageId } = page;
+        const appData = structuredClone(this.appData);
+        const { config } = appData;
+        let deleteHappened = false;
+        const { pages = {} } = config;
+        if (pages?.[pageId]) {
+            // Remove reference in 'navigation' to page from parent
+            for (const parentPage in pages) {
+                if (pages[parentPage].navigation) {
+                    this.deleteNavigationLinks(pages[parentPage].navigation, pageId);
+                }
+            }
+            // Delete page recursively together with all child pages
+            this.deletePageRecursively(config, pageId);
+            deleteHappened = true;
+        }
+        // delete home property if last page has been deleted
+        if (Object.keys(pages).length === 0) {
+            delete config.home;
+        }
+        if (deleteHappened) {
+            const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(this.applicationAccess);
+            await ftfsFileIo.writeApp(appData);
+            return {
+                functionalityId: constant_1.DELETE_PAGE,
+                status: 'success',
+                message: `Page with id '${pageId}' was deleted successfully in application '${this.appId}'`,
+                parameters: [],
+                appPath: this.params.appPath,
+                changes: [],
+                timestamp: new Date().toISOString()
+            };
+        }
+        return {
+            functionalityId: constant_1.DELETE_PAGE,
+            status: 'unchanged',
+            message: `Page with id '${pageId}' was not found in application '${this.appId}'`,
+            parameters: [],
+            appPath: this.params.appPath,
+            changes: [],
+            timestamp: new Date().toISOString()
+        };
+    }
+}
+exports.Application = Application;
+//# sourceMappingURL=application.js.map

package/dist/tools/functionalities/page/delete-page.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionalityHandlers } from '../../../types';
+export declare const deletePageHandlers: FunctionalityHandlers;
+export { DELETE_PAGE_FUNCTIONALITY } from './application';
+//# sourceMappingURL=delete-page.d.ts.map

package/dist/tools/functionalities/page/delete-page.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE_PAGE_FUNCTIONALITY = exports.deletePageHandlers = void 0;
+const application_1 = require("./application");
+const page_editor_api_1 = require("../../../page-editor-api");
+const utils_1 = require("../../utils");
+const constant_1 = require("../../../constant");
+/**
+ * Retrieves the details of the Delete Page functionality.
+ *
+ * @param params - The input parameters for getting functionality details.
+ * @returns A promise resolving to the functionality details output.
+ */
+async function getFunctionalityDetails(params) {
+    const { appPath } = params;
+    const appDetails = await (0, utils_1.resolveApplication)(appPath);
+    if (!appDetails?.applicationAccess) {
+        return {
+            functionalityId: constant_1.DELETE_PAGE,
+            name: 'Invalid Project Root or Application Path',
+            description: `To delete a page, provide a valid project root or application path. "${appPath}" is not valid`,
+            parameters: []
+        };
+    }
+    const { appId, applicationAccess } = appDetails;
+    const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(applicationAccess);
+    const appData = await ftfsFileIo.readApp();
+    const serviceName = await (0, page_editor_api_1.getServiceName)(applicationAccess);
+    const application = new application_1.Application({ params, applicationAccess, serviceName, appId, appData });
+    return application.getDeleteOptions();
+}
+/**
+ * Executes the Delete Page functionality.
+ *
+ * @param params - The input parameters for executing the functionality.
+ * @returns A promise resolving to the execution output.
+ */
+async function executeFunctionality(params) {
+    const { appPath, parameters } = params;
+    const { pageId } = parameters;
+    if (!pageId || typeof pageId !== 'string') {
+        throw new Error('Missing or invalid parameter "pageId"');
+    }
+    const appDetails = await (0, utils_1.resolveApplication)(appPath);
+    if (!appDetails?.applicationAccess) {
+        return {
+            functionalityId: constant_1.DELETE_PAGE,
+            status: 'Failed',
+            message: `Project root not found for app path: ${appPath}`,
+            parameters: [],
+            appPath: appPath,
+            changes: [],
+            timestamp: new Date().toISOString()
+        };
+    }
+    const { appId, applicationAccess } = appDetails;
+    const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(applicationAccess);
+    const appData = await ftfsFileIo.readApp();
+    const serviceName = await (0, page_editor_api_1.getServiceName)(applicationAccess);
+    const application = new application_1.Application({ params, applicationAccess, serviceName, appId, appData });
+    return application.deletePage({
+        pageId
+    });
+}
+exports.deletePageHandlers = {
+    getFunctionalityDetails,
+    executeFunctionality
+};
+var application_2 = require("./application");
+Object.defineProperty(exports, "DELETE_PAGE_FUNCTIONALITY", { enumerable: true, get: function () { return application_2.DELETE_PAGE_FUNCTIONALITY; } });
+//# sourceMappingURL=delete-page.js.map