feat(fiori-mcp-server): app-gen common schema

Author: tom-sap

packages/fiori-mcp-server/src/tools/functionalities/fetch-systems/details.ts

@@ -1,29 +1,17 @@
+import type { ExecuteFunctionalityInput, ExecuteFunctionalityOutput } from '../../../types';
+import type { GeneratorConfigCAP } from '../../schemas';
+import type { PackageInfo } from '@sap-ux/nodejs-utils';
+
 import { promises as FSpromises, existsSync } from 'node:fs';
 import { promisify } from 'util';
 import { exec as execAsync } from 'child_process';
 import { dirname, join } from 'node:path';
-import type { ExecuteFunctionalityInput, ExecuteFunctionalityOutput } from '../../../types';
+import { findInstalledPackages } from '@sap-ux/nodejs-utils';
 import { GENERATE_FIORI_UI_APP_ID } from '../../../constant';
-import { findInstalledPackages, type PackageInfo } from '@sap-ux/nodejs-utils';
-import packageJson from '../../../../package.json';
 import { logger } from '../../../utils/logger';
-import { GeneratorConfigSchemaCAP, type GeneratorConfigCAP } from './schema';
+import { generatorConfigCAP } from '../../schemas';
 import { validateWithSchema } from '../../utils';
 
-// Extended type generators API use
-const PREDEFINED_GENERATOR_VALUES = {
-    // Config schema version
-    version: '0.2',
-    telemetryData: {
-        'generationSourceName': packageJson.name,
-        'generationSourceVersion': packageJson.version
-    },
-    project: {
-        sapux: true
-    }
-};
-type GeneratorConfigCAPWithAPI = GeneratorConfigCAP & typeof PREDEFINED_GENERATOR_VALUES;
-
 const exec = promisify(execAsync);
 
 /**
@@ -33,25 +21,13 @@ const exec = promisify(execAsync);
  * @returns Application generation execution output.
  */
 export async function command(params: ExecuteFunctionalityInput): Promise<ExecuteFunctionalityOutput> {
-    const generatorConfigCAP: GeneratorConfigCAP = validateWithSchema(GeneratorConfigSchemaCAP, params?.parameters);
-    const generatorConfig: GeneratorConfigCAPWithAPI = {
-        ...PREDEFINED_GENERATOR_VALUES,
-        ...generatorConfigCAP,
-        project: {
-            ...PREDEFINED_GENERATOR_VALUES.project,
-            ...generatorConfigCAP.project
-        }
-    };
+    const generatorConfig: GeneratorConfigCAP = validateWithSchema(generatorConfigCAP, params?.parameters);
     generatorConfig.project.sapux = generatorConfig.floorplan !== 'FF_SIMPLE';
+
     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.');
     }
-    if (generatorConfig?.service.servicePath) {
-        generatorConfig.service.servicePath = generatorConfig?.service.servicePath?.startsWith('/')
-            ? generatorConfig?.service.servicePath
-            : `/${generatorConfig?.service.servicePath}`;
-    }
     const appName = (generatorConfig?.project.name as string) ?? 'default';
     const appPath = join(projectPath, 'app', appName);
     const targetDir = projectPath;

packages/fiori-mcp-server/src/tools/functionalities/fetch-systems/execute-functionality.ts

@@ -1,13 +1,13 @@
-import { command } from './command';
-import { GeneratorConfigSchemaCAP } from './schema';
-import { GENERATE_FIORI_UI_APP_ID } from '../../../constant';
 import type {
     ExecuteFunctionalityInput,
     ExecuteFunctionalityOutput,
     FunctionalityHandlers,
     GetFunctionalityDetailsOutput
 } from '../../../types';
-import { convertToSchema } from '../../utils';
+
+import { command } from './command';
+import { generatorConfigCAPJson as parameters } from '../../schemas';
+import { GENERATE_FIORI_UI_APP_ID } from '../../../constant';
 
 export const GENERATE_FIORI_UI_APP: GetFunctionalityDetailsOutput = {
     functionalityId: GENERATE_FIORI_UI_APP_ID,
@@ -18,7 +18,7 @@ export const GENERATE_FIORI_UI_APP: GetFunctionalityDetailsOutput = {
                 The data obtained from either method must then be formatted into a JSON object and passed as the parameters.
                 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: convertToSchema(GeneratorConfigSchemaCAP)
+    parameters
 };
 
 /**

packages/fiori-mcp-server/src/tools/functionalities/fetch-systems/index.ts

@@ -1,23 +1,15 @@
 import type { GetFunctionalityDetailsOutput } from '../../../types';
-import { generatorConfigSchemaNonCAPJson } from './schema';
+import { generatorConfigODataJson as parameters } from '../../schemas';
 
 export default {
     functionalityId: 'generate-fiori-ui-odata-app',
-    name: 'Generate SAP Fiori UI Application for non-CAP Projects',
+    name: 'Generate SAP Fiori UI Application for OData Projects (non-CAP)',
     description: `Creates (generates) a new SAP Fiori UI application within an existing project (RAP or other non-CAP).
                 Crucially, you must first construct the appGenConfig JSON argument.
-
-                If the user has not provided a valid servicePath and host (URL) of the OData service they want to use,
-                you **MUST** first retrieve the list of user stored SAP systems (using the "fetch-system" functionality with "execute_functionality" tool),
-
-                then match the provided name to one of the systems (or ask the user to choose from a list if multiple match),
-                and then retrieve the list of services from that system (using the "fetch-system-services" functionality), and ask the user to select one of the services,
-                and finally retrieve the corresponding servicePath, host, and client from the selected service.
-
+                If the user has not provided a valid servicePath and host (URL) of the OData service they want to use, you **MUST** ask for it.
                 Next you **MUST** query the service metadata endpoint to retrieve the list of available entities.
                 (**IMPORTANT**: service metadata endpoint URL must end with "$metadata". If the provided servicePath does not end with "$metadata", you **MUST** append it.)
-                (**IMPORTANT**: if the service requires authentication, you should use the same username and password that the "fetch-system" functionality returned with the sap-system that the service belongs to.)
-
+                (**IMPORTANT**: if the service requires authentication run 'curl' command to fetch the edmx xml response and allow the user to authenticate if needed).
                 Lastly, using the service edmx (response xml from <serviceurl>/$metadata request), figure out the data model structure, entities, and associations.`,
-    parameters: generatorConfigSchemaNonCAPJson
+    parameters
 } as GetFunctionalityDetailsOutput;

packages/fiori-mcp-server/src/tools/functionalities/generate-fiori-ui-app/command.ts

@@ -1,15 +1,14 @@
 /* eslint-disable no-console */
 import type { ExecuteFunctionalityInput, ExecuteFunctionalityOutput } from '../../../types';
-import type { NonCAPSchema, GeneratorConfigNonCAP } from './schema';
+import type { GeneratorConfigOData } from '../../schemas';
 
 import { promises, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { exec as execAsync } from 'child_process';
 import { promisify } from 'util';
-import { GeneratorConfigSchemaNonCAP } from './schema';
-import details from './details';
+import { generatorConfigOData } from '../../schemas';
 import { validateWithSchema } from '../../utils';
-import packageJson from '../../../../package.json';
+import details from './details';
 
 const exec = promisify(execAsync);
 
@@ -20,15 +19,7 @@ const exec = promisify(execAsync);
  * @returns Application generation execution output.
  */
 export default async function (params: ExecuteFunctionalityInput): Promise<ExecuteFunctionalityOutput> {
-    const nonCAPConfig: NonCAPSchema = validateWithSchema(GeneratorConfigSchemaNonCAP, params?.parameters);
-    const generatorConfig: GeneratorConfigNonCAP = nonCAPConfig?.appGenConfig;
-
-    generatorConfig.telemetryData = {
-        generationSourceName: packageJson.name,
-        generationSourceVersion: packageJson.version
-    };
-    generatorConfig.project.sapux = generatorConfig.floorplan !== 'FF_SIMPLE';
-
+    const generatorConfig: GeneratorConfigOData = validateWithSchema(generatorConfigOData, params?.parameters);
     const projectPath = generatorConfig?.project?.targetFolder ?? params.appPath;
 
     if (!projectPath || typeof projectPath !== 'string') {

packages/fiori-mcp-server/src/tools/functionalities/generate-fiori-ui-app/generate-fiori-ui-app.ts

@@ -1,41 +1,33 @@
 import * as z from 'zod';
-import { LATEST_UI5_VERSION } from '../../../constant';
-import { convertToSchema } from '../../utils';
+import { LATEST_UI5_VERSION } from '../../constant';
+import packageJson from '../../../package.json';
 
-const projectPath = z
-    .string()
-    .describe('The path to the non-CAP project folder. By default the currently opened project folder should be used.');
+export const version = z.string().default('0.2').describe('Config schema version.');
 
-const version = z.string().default('0.2').describe('Config schema version.');
-
-const floorplan = z
+export const floorplan = z
     .literal(['FE_FPM', 'FE_LROP', 'FE_OVP', 'FE_ALP', 'FE_FEOP', 'FE_WORKLIST', 'FF_SIMPLE'])
     .describe('SAP Fiori Elements floor plan type.');
 
-const projectType = z
+export const projectType = z
     .literal(['LIST_REPORT_OBJECT_PAGE', 'FORM_ENTRY_OBJECT_PAGE', 'FLEXIBLE_PROGRAMMING_MODEL'])
     .describe('SAP Fiori Elements project type. Corresponds to the SAP Fiori Elements floor plan.');
 
-const project = z.object({
+export const project = z.object({
     name: z
         .string()
         .describe("Must be lowercase with dashes, e.g., 'sales-order-management'.")
         .regex(/^[a-z0-9-]+$/),
     title: z.optional(z.string()),
     description: z.string(),
-    targetFolder: z.string().describe('Absolute path to the non-CAP project folder (projectPath).'),
+    targetFolder: z.string().describe('Absolute path to the project folder (projectPath).'),
     ui5Version: z.string().default(LATEST_UI5_VERSION),
     sapux: z.boolean().default(true)
 });
 
-const service = z.object({
+export const serviceOdata = z.object({
     servicePath: z
         .string()
-        .describe(
-            'The odata endpoint as provided by the cds mcp. If the parameter is not provided, ' +
-                'the agent should ask the user for it. Some service endpoints require authentication ' +
-                '- in that case, the agent should ask the user for the necessary credentials.'
-        )
+        .describe('The odata endpoint. If the parameter is not provided, the agent should ask the user for it.')
         .meta({
             examples: [
                 'odata/v4/<servicename>/',
@@ -56,7 +48,26 @@ const service = z.object({
     edmx: z.string().describe('The service metadata in the stringified XML format.')
 });
 
-const entityConfig = z.object({
+export const serviceCap = z.object({
+    capService: z.object({
+        projectPath: z.string(),
+        serviceName: z.string(),
+        serviceCdsPath: z
+            .string()
+            .describe('The path to the service cds file')
+            .meta({
+                examples: [
+                    'srv/service.cds',
+                    'srv/my-service.cds',
+                    'path/to/srv/service.cds',
+                    'path/to/srv/my-service.cds'
+                ]
+            }),
+        capType: z.optional(z.literal(['Node.js', 'Java']))
+    })
+});
+
+export const entityConfig = z.object({
     mainEntity: z.object({
         entityName: z
             .string()
@@ -67,26 +78,7 @@ const entityConfig = z.object({
     generateLROPAnnotations: z.boolean()
 });
 
-const telemetryData = z.object({
-    generationSourceName: z.string().default('AI Headless MCP'),
-    generationSourceVersion: z.string().default('1.0.0')
+export const telemetryData = z.object({
+    generationSourceName: z.string().default(packageJson.name),
+    generationSourceVersion: z.string().default(packageJson.version)
 });
-
-const appGenConfig = z.object({
-    version,
-    floorplan,
-    projectType,
-    project,
-    service,
-    entityConfig,
-    telemetryData
-}).describe(`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 (if a project exists).`);
-
-export const GeneratorConfigSchemaNonCAP = z.object({ projectPath, appGenConfig });
-
-export const generatorConfigSchemaNonCAPJson = convertToSchema(GeneratorConfigSchemaNonCAP);
-
-export type NonCAPSchema = z.infer<typeof GeneratorConfigSchemaNonCAP>;
-export type GeneratorConfigNonCAP = z.infer<typeof appGenConfig>;