@sap-ux/fiori-mcp-server 0.0.1

package/dist/tools/functionalities/controller-extension/index.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createControllerExtensionHandlers = exports.CREATE_CONTROLLER_EXTENSION_FUNCTIONALITY = void 0;
+const src_1 = require("@sap/ux-specification/dist/types/src");
+const page_editor_api_1 = require("../../../page-editor-api");
+const utils_1 = require("../../utils");
+const path_1 = require("path");
+/**
+ * Retrieves the parameter definitions for creating a controller extension.
+ *
+ * @returns An object containing parameter definitions for pageType, pageId, and controllerName.
+ */
+function getParameters() {
+    return {
+        pageType: {
+            id: 'pageType',
+            type: 'string',
+            description: 'Type of page',
+            options: ['ListReport', 'ObjectPage'],
+            defaultValue: 'ListReport',
+            required: true
+        },
+        pageId: {
+            id: 'pageId',
+            type: 'string',
+            description: 'If controller extenison should be assigned for specific page, then pageId should be provided'
+        },
+        controllerName: {
+            id: 'controllerName',
+            type: 'string',
+            description: 'Name of new controller extension file',
+            required: true
+        }
+    };
+}
+exports.CREATE_CONTROLLER_EXTENSION_FUNCTIONALITY = {
+    functionalityId: 'create-controller-extension',
+    name: 'Add new controller extension by creating javascript or typescript file and updates manifest.json with entry',
+    description: 'Add new controller extension by creating javascript or typescript file and updates manifest.json with entry. Controller extensions allow users to extensiate default behaviour with custom controllers code.',
+    parameters: Object.values(getParameters())
+};
+/**
+ * Retrieves the details of the create controller extension functionality.
+ *
+ * @param input - The input parameters for getting functionality details.
+ * @returns A promise that resolves to the functionality details output.
+ */
+async function getFunctionalityDetails(input) {
+    const defaultParameters = getParameters();
+    // Populate options for pageId
+    const project = await (0, utils_1.resolveApplication)(input.appPath);
+    let pageIds = [];
+    if (project?.applicationAccess) {
+        const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(project.applicationAccess);
+        const appData = await ftfsFileIo.readApp();
+        pageIds = Object.keys(appData.config.pages ?? {});
+    }
+    const parameters = [defaultParameters.pageType, defaultParameters.controllerName];
+    if (pageIds.length) {
+        parameters.push({
+            ...defaultParameters.pageId,
+            options: pageIds
+        });
+    }
+    return {
+        ...exports.CREATE_CONTROLLER_EXTENSION_FUNCTIONALITY,
+        parameters
+    };
+}
+/**
+ * Executes the create controller extension functionality.
+ *
+ * @param input - The input parameters for executing the functionality.
+ * @returns A promise that resolves to the execution output.
+ */
+async function executeFunctionality(input) {
+    const { parameters, appPath } = input;
+    const { pageId, controllerName, pageType } = parameters;
+    const project = await (0, utils_1.resolveApplication)(appPath);
+    let changes = [];
+    if (!controllerName || typeof controllerName !== 'string') {
+        throw new Error('Missing or invalid parameter "controllerName"');
+    }
+    if (project?.applicationAccess) {
+        const { appId, root } = project;
+        const ftfsFileIo = new page_editor_api_1.SapuxFtfsFileIO(project.applicationAccess);
+        const exensionPageType = await retrieveControllerExtensionPageType(ftfsFileIo, pageType, pageId);
+        if (exensionPageType && typeof exensionPageType === 'string') {
+            const extension = {
+                pageId: typeof pageId === 'string' ? pageId : undefined,
+                pageType: exensionPageType
+            };
+            changes = await ftfsFileIo.writeFPM({
+                customExtension: src_1.CustomExtensionType.ControllerExtension,
+                basePath: (0, path_1.join)(root, appId),
+                data: {
+                    extension,
+                    folder: (0, utils_1.getDefaultExtensionFolder)(src_1.DirName.Controller),
+                    name: controllerName
+                }
+            });
+        }
+    }
+    return {
+        functionalityId: input.functionalityId,
+        status: changes.length ? 'success' : 'skipped',
+        message: changes.length ? 'Controller extension is created' : 'Controller extension is not created',
+        parameters: parameters,
+        appPath: appPath,
+        changes,
+        timestamp: new Date().toISOString()
+    };
+}
+/**
+ * Retrieves the controller extension page type for a given page or pageType.
+ *
+ * @param appReader - File I/O handler used to read the SAP Fiori application data.
+ * @param pageType - Optional page type value..
+ * @param pageId - Optional page identifier used to look up the page type if `pageType` is not explicitly provided.
+ * @returns A promise resolving to the controller extension page type, or `undefined` if it cannot be determined.
+ */
+async function retrieveControllerExtensionPageType(appReader, pageType, pageId) {
+    if (!pageType && typeof pageId === 'string') {
+        // Find pageType for passed page id
+        const appData = await appReader.readApp();
+        pageType = appData.config.pages?.[pageId]?.pageType;
+    }
+    if (pageType && typeof pageType === 'string') {
+        return pageType;
+    }
+}
+exports.createControllerExtensionHandlers = {
+    getFunctionalityDetails,
+    executeFunctionality
+};
+//# sourceMappingURL=index.js.map

package/dist/tools/functionalities/functionalities.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionalityHandlers } from '../../types';
+export declare const FUNCTIONALITIES_DETAILS: import("../../types").GetFunctionalityDetailsOutput[];
+export declare const FUNCTIONALITIES_HANDLERS: Map<string, FunctionalityHandlers>;
+//# sourceMappingURL=functionalities.d.ts.map

package/dist/tools/functionalities/functionalities.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FUNCTIONALITIES_HANDLERS = exports.FUNCTIONALITIES_DETAILS = void 0;
+const page_1 = require("./page");
+const controller_extension_1 = require("./controller-extension");
+const generate_fiori_ui_app_1 = require("./generate-fiori-ui-app");
+exports.FUNCTIONALITIES_DETAILS = [
+    page_1.ADD_PAGE_FUNCTIONALITY,
+    generate_fiori_ui_app_1.GENERATE_FIORI_UI_APP,
+    page_1.DELETE_PAGE_FUNCTIONALITY,
+    controller_extension_1.CREATE_CONTROLLER_EXTENSION_FUNCTIONALITY
+];
+exports.FUNCTIONALITIES_HANDLERS = new Map([
+    [page_1.ADD_PAGE_FUNCTIONALITY.functionalityId, page_1.addPageHandlers],
+    [page_1.DELETE_PAGE_FUNCTIONALITY.functionalityId, page_1.deletePageHandlers],
+    [generate_fiori_ui_app_1.GENERATE_FIORI_UI_APP.functionalityId, generate_fiori_ui_app_1.generateFioriUIAppHandlers],
+    [controller_extension_1.CREATE_CONTROLLER_EXTENSION_FUNCTIONALITY.functionalityId, controller_extension_1.createControllerExtensionHandlers]
+]);
+//# sourceMappingURL=functionalities.js.map

package/dist/tools/functionalities/generate-fiori-ui-app/command.d.ts

@@ -0,0 +1,9 @@
+import type { ExecuteFunctionalitiesInput, ExecuteFunctionalityOutput } from '../../../types';
+/**
+ * Method to generate fiori app.
+ *
+ * @param params Input parameters for application generation.
+ * @returns Application generation execution output.
+ */
+export declare function command(params: ExecuteFunctionalitiesInput): Promise<ExecuteFunctionalityOutput>;
+//# sourceMappingURL=command.d.ts.map

package/dist/tools/functionalities/generate-fiori-ui-app/command.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = command;
+const fs_1 = require("fs");
+const util_1 = require("util");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const constant_1 = require("../../../constant");
+const nodejs_utils_1 = require("@sap-ux/nodejs-utils");
+const z = __importStar(require("zod"));
+const GeneratorConfigSchemaCAP = z.object({
+    projectPath: z.optional(z.string()),
+    appGenConfig: z.object({
+        version: z.string(),
+        floorplan: z.literal(['FE_FPM', 'FE_LROP', 'FE_OVP', 'FE_ALP', 'FE_FEOP', 'FE_WORKLIST', 'FF_SIMPLE']),
+        project: z.object({
+            name: z.string(),
+            targetFolder: z.string(),
+            namespace: z.optional(z.string()),
+            title: z.optional(z.string()),
+            description: z.string(),
+            ui5Theme: z.optional(z.string()),
+            ui5Version: z.string(),
+            localUI5Version: z.optional(z.string()),
+            sapux: z.boolean(),
+            skipAnnotations: z.optional(z.boolean()),
+            enableCodeAssist: z.optional(z.boolean()),
+            enableEslint: z.optional(z.boolean()),
+            enableTypeScript: z.optional(z.boolean())
+        }),
+        service: z.object({
+            servicePath: z.string(),
+            capService: z.object({
+                projectPath: z.string(),
+                serviceName: z.string(),
+                serviceCdsPath: z.string(),
+                capType: z.optional(z.literal(['Node.js', 'Java']))
+            })
+        }),
+        entityConfig: z.object({
+            mainEntity: z.object({
+                entityName: z.string()
+            }),
+            generateFormAnnotations: z.boolean(),
+            generateLROPAnnotations: z.boolean()
+        }),
+        telemetryData: z.object({
+            generationSourceName: z.string(),
+            generationSourceVersion: z.string()
+        })
+    })
+});
+const exec = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Method to generate fiori app.
+ *
+ * @param params Input parameters for application generation.
+ * @returns Application generation execution output.
+ */
+async function command(params) {
+    let generatorConfigCAP;
+    try {
+        generatorConfigCAP = GeneratorConfigSchemaCAP.parse(params.parameters);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new Error(`Missing required fields in generatorConfig. ${JSON.stringify(error.issues, null, 4)}`);
+        }
+    }
+    const generatorConfig = generatorConfigCAP?.appGenConfig;
+    const projectPath = generatorConfig?.project?.targetFolder ?? params.appPath;
+    if (!projectPath || typeof projectPath !== 'string') {
+        throw new Error('Please provide a valid path to the CAP project folder.');
+    }
+    const appName = generatorConfig?.project.name ?? 'default';
+    const appPath = (0, path_1.join)(projectPath, 'app', appName);
+    const targetDir = projectPath;
+    const configPath = `${appName}-generator-config.json`;
+    const outputPath = (0, path_1.join)(targetDir, configPath);
+    const generatorName = '@sap/generator-fiori';
+    const generatorVersion = '1.18.5';
+    const packages = await (0, nodejs_utils_1.findInstalledPackages)(generatorName, { minVersion: generatorVersion });
+    if (packages?.length < 1) {
+        throw new Error(`Fiori generator not found. Please install the Fiori generator >=${generatorVersion} with 'npm install -g ${generatorName}' and retry this call`);
+    }
+    try {
+        const content = JSON.stringify(generatorConfig, null, 4);
+        await fs_1.promises.mkdir((0, path_1.dirname)(outputPath), { recursive: true });
+        await fs_1.promises.writeFile(outputPath, content, { encoding: 'utf8' });
+        const command = `npx -y yo@4 @sap/fiori:headless ${configPath} --force --skipInstall`.trim();
+        const { stdout, stderr } = await exec(command, { cwd: targetDir });
+        console.log(stdout);
+        if (stderr) {
+            console.error(stderr);
+        }
+    }
+    catch (error) {
+        console.error('Error generating application:', error);
+        return {
+            functionalityId: constant_1.GENERATE_FIORI_UI_APP_ID,
+            status: 'Error',
+            message: 'Error generating application: ' + error.message,
+            parameters: params.parameters,
+            appPath,
+            changes: [],
+            timestamp: new Date().toISOString()
+        };
+    }
+    finally {
+        //clean up temp config file used for the headless generator
+        if ((0, fs_1.existsSync)(outputPath)) {
+            await fs_1.promises.unlink(outputPath);
+        }
+    }
+    return {
+        functionalityId: constant_1.GENERATE_FIORI_UI_APP_ID,
+        status: 'Success',
+        message: 'Generation completed successfully: ' + appPath,
+        parameters: params.parameters,
+        appPath,
+        changes: [],
+        timestamp: new Date().toISOString()
+    };
+}
+//# sourceMappingURL=command.js.map

package/dist/tools/functionalities/generate-fiori-ui-app/generate-fiori-ui-app.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionalityHandlers, GetFunctionalityDetailsOutput } from '../../../types';
+export declare const GENERATE_FIORI_UI_APP: GetFunctionalityDetailsOutput;
+export declare const generateFioriUIAppHandlers: FunctionalityHandlers;
+//# sourceMappingURL=generate-fiori-ui-app.d.ts.map

package/dist/tools/functionalities/generate-fiori-ui-app/generate-fiori-ui-app.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFioriUIAppHandlers = exports.GENERATE_FIORI_UI_APP = void 0;
+const command_1 = require("./command");
+const constant_1 = require("../../../constant");
+exports.GENERATE_FIORI_UI_APP = {
+    functionalityId: constant_1.GENERATE_FIORI_UI_APP_ID,
+    name: 'Generate SAP Fiori UI Application',
+    description: `Creates (generates) a new SAP Fiori UI application within an existing CAP project.
+                Crucially, you must first construct the appGenConfig JSON argument.
+                To do this, you **MUST** use the ***CDS MCP*** to search the model for service definitions, entities, associations, and UI annotations.
+                As a fallback, only if no such tool is available, you should manually read and parse all .cds files in the projectPath to extract this information.
+                The data obtained from either method must then be formatted into a JSON object and passed as the appGenConfig parameter.`,
+    parameters: [
+        {
+            id: 'projectPath',
+            type: 'string',
+            description: 'The path to the CAP project folder. By default the currently opened project folder should be used.',
+            required: true
+        },
+        {
+            id: 'appGenConfig',
+            type: 'object',
+            description: `The configuration that will be used for the Application UI generation.
+                        The configuration **MUST** be a valid JSON object corresponding to the inputSchema of the tool.
+                        The configuration **MUST** be based on the project files in the projectPath.`,
+            parameters: [
+                {
+                    id: 'version',
+                    type: 'string',
+                    options: ['0.2'],
+                    description: 'Config schema version.',
+                    required: true
+                },
+                {
+                    id: 'floorplan',
+                    type: 'string',
+                    options: ['FE_LROP', 'FE_FEOP', 'FE_FPM'],
+                    description: 'SAP Fiori Elements floor plan type.',
+                    required: true
+                },
+                {
+                    id: 'projectType',
+                    type: 'string',
+                    options: ['LIST_REPORT_OBJECT_PAGE', 'FORM_ENTRY_OBJECT_PAGE', 'FLEXIBLE_PROGRAMMING_MODEL'],
+                    description: 'Corresponds to the SAP Fiori Elements floor plan.',
+                    required: true
+                },
+                {
+                    id: 'project',
+                    type: 'object',
+                    parameters: [
+                        {
+                            id: 'name',
+                            type: 'string',
+                            description: "Must be lowercase with dashes, e.g., 'sales-order-management'.",
+                            pattern: '^[a-z0-9-]+$',
+                            required: true
+                        },
+                        {
+                            id: 'title',
+                            type: 'string',
+                            required: false
+                        },
+                        {
+                            id: 'description',
+                            type: 'string',
+                            required: true
+                        },
+                        {
+                            id: 'namespace',
+                            type: 'string',
+                            required: false
+                        },
+                        {
+                            id: 'ui5Theme',
+                            type: 'string',
+                            required: false
+                        },
+                        {
+                            id: 'targetFolder',
+                            type: 'string',
+                            description: 'Absolute path to the CAP project folder (projectPath).',
+                            required: true
+                        },
+                        {
+                            id: 'ui5Version',
+                            type: 'string',
+                            options: [constant_1.LATEST_UI5_VERSION],
+                            required: true
+                        },
+                        {
+                            id: 'localUI5Version',
+                            type: 'string',
+                            options: [constant_1.LATEST_UI5_VERSION],
+                            required: false
+                        },
+                        {
+                            id: 'sapux',
+                            type: 'boolean',
+                            defaultValue: true,
+                            required: true
+                        }
+                    ],
+                    required: true
+                },
+                {
+                    id: 'service',
+                    type: 'object',
+                    parameters: [
+                        {
+                            id: 'servicePath',
+                            type: 'string',
+                            examples: [
+                                'odata/v4/<servicename>/',
+                                'odata/v4/MyRiskService/',
+                                'odata/v2/MyOdataV2Service/',
+                                'odata/v4/MyOdataV4Service/',
+                                "odata/v4/<relative '@path' annotation from service cds file>/",
+                                "<absolute '@path' annotation from service cds file>/",
+                                'myAbsolutePathFromServiceCdsFile/'
+                            ],
+                            description: 'The odata endpoint as provided by the cds mcp or as fallback in case that tool is not available from the service cds file.',
+                            required: true
+                        },
+                        {
+                            id: 'capService',
+                            type: 'object',
+                            parameters: [
+                                {
+                                    id: 'projectPath',
+                                    type: 'string',
+                                    required: true
+                                },
+                                {
+                                    id: 'serviceName',
+                                    type: 'string',
+                                    required: true
+                                },
+                                {
+                                    id: 'serviceCdsPath',
+                                    type: 'string',
+                                    examples: [
+                                        'srv/service.cds',
+                                        'srv/my-service.cds',
+                                        'path/to/srv/service.cds',
+                                        'path/to/srv/my-service.cds'
+                                    ],
+                                    description: 'The path to the service cds file',
+                                    required: true
+                                },
+                                {
+                                    id: 'capType',
+                                    type: 'string',
+                                    options: ['Node.js', 'Java'],
+                                    required: false
+                                }
+                            ],
+                            required: true
+                        }
+                    ],
+                    required: true
+                },
+                {
+                    id: 'entityConfig',
+                    type: 'object',
+                    parameters: [
+                        {
+                            id: 'mainEntity',
+                            type: 'object',
+                            parameters: [
+                                {
+                                    id: 'entityName',
+                                    type: 'string',
+                                    examples: ["'SalesOrder'", "'PurchaseOrderHeader'", "'MyEntity'"],
+                                    description: "The name of the main entity, e.g. 'SalesOrder'",
+                                    required: true
+                                }
+                            ],
+                            required: true
+                        },
+                        {
+                            id: 'generateFormAnnotations',
+                            type: 'boolean',
+                            required: true
+                        },
+                        {
+                            id: 'generateLROPAnnotations',
+                            type: 'boolean',
+                            required: true
+                        }
+                    ],
+                    required: true
+                },
+                {
+                    id: 'telemetryData',
+                    type: 'object',
+                    parameters: [
+                        {
+                            id: 'generationSourceName',
+                            type: 'string',
+                            options: ['AI Headless MCP'],
+                            required: true
+                        },
+                        {
+                            id: 'generationSourceVersion',
+                            type: 'string',
+                            options: ['1.0.0'],
+                            required: true
+                        }
+                    ],
+                    required: true
+                }
+            ],
+            required: true
+        }
+    ]
+};
+/**
+ * Retrieves the details of the Generate SAP Fiori UI Application functionality.
+ *
+ * @returns A promise that resolves to the functionality details output.
+ */
+async function getFunctionalityDetails() {
+    return exports.GENERATE_FIORI_UI_APP;
+}
+/**
+ * Executes the Generate SAP Fiori UI Application functionality.
+ *
+ * @param params - The input parameters for executing the functionality.
+ * @returns A promise that resolves to the execution output.
+ */
+async function executeFunctionality(params) {
+    return (0, command_1.command)(params);
+}
+exports.generateFioriUIAppHandlers = {
+    getFunctionalityDetails,
+    executeFunctionality
+};
+//# sourceMappingURL=generate-fiori-ui-app.js.map

package/dist/tools/functionalities/generate-fiori-ui-app/index.d.ts

@@ -0,0 +1,2 @@
+export { GENERATE_FIORI_UI_APP, generateFioriUIAppHandlers } from './generate-fiori-ui-app';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/functionalities/generate-fiori-ui-app/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFioriUIAppHandlers = exports.GENERATE_FIORI_UI_APP = void 0;
+var generate_fiori_ui_app_1 = require("./generate-fiori-ui-app");
+Object.defineProperty(exports, "GENERATE_FIORI_UI_APP", { enumerable: true, get: function () { return generate_fiori_ui_app_1.GENERATE_FIORI_UI_APP; } });
+Object.defineProperty(exports, "generateFioriUIAppHandlers", { enumerable: true, get: function () { return generate_fiori_ui_app_1.generateFioriUIAppHandlers; } });
+//# sourceMappingURL=index.js.map

package/dist/tools/functionalities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './functionalities';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/functionalities/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./functionalities"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import type { FunctionalityHandlers } from '../../../types';
+import { ADD_PAGE_FUNCTIONALITY } from './application';
+export declare const addPageHandlers: FunctionalityHandlers;
+export { ADD_PAGE_FUNCTIONALITY };
+//# sourceMappingURL=add-page.d.ts.map