@sap-ux/fiori-migration-writer 0.0.4 → 0.0.6

package/dist/ProjectMigrator.d.ts

@@ -28,21 +28,29 @@ export declare class ProjectMigrator {
      * @param options - Migration options object
      * @returns Promise with fs editor, migration result, and messages
      */
-    static migrate(// NOSONAR - Overload for backward compatibility; use options object signature instead
-    projectRoot: string, baseUri?: string, ui5SnapshotUrl?: string, importProjectInfo?: ImportProjectInfo, vscode?: any, internalToggle?: boolean, fs?: Editor, strict?: boolean): Promise<{
-        fs: Editor;
-        result: boolean;
-        messages: Message[];
-    }>;
     static migrate(options: MigrateOptions): Promise<{
         fs: Editor;
         result: boolean;
         messages: Message[];
     }>;
+    /**
+     * Run the migration for the resolved project info, dispatching by project type.
+     *
+     * @param editor
+     * @param projectInfo
+     * @param messages
+     * @param opts
+     * @param opts.vscode
+     * @param opts.ui5SnapshotUrl
+     * @param opts.internalToggle
+     * @param opts.strict
+     */
+    private static runMigrationForProjectInfo;
     /**
      * Copy files from templates into the project
      * Orchestrates the migration process through distinct phases
      *
+     * @param fs - mem-fs editor
      * @param projectInfo - Project information
      * @param vscode - VS Code context
      * @param ui5SnapshotUrl - UI5 snapshot URL
@@ -54,6 +62,7 @@ export declare class ProjectMigrator {
     /**
      * Copy files from templates into the project
      *
+     * @param fs - mem-fs editor
      * @param projectInfo
      * @param snapshotUrl
      */
@@ -61,6 +70,7 @@ export declare class ProjectMigrator {
     /**
      * Copy files from templates into the project
      *
+     * @param fs
      * @param projectInfo
      */
     private static copyLibraryFiles;
@@ -69,6 +79,7 @@ export declare class ProjectMigrator {
      * Generates tsconfig.json and TypeScript devDependencies via {@link enableTypescript},
      * then patches ui5-local.yaml and ui5-mock.yaml with the transpile middleware and task.
      *
+     * @param fs - The mem-fs editor.
      * @param rootPath - The project root path.
      * @returns Messages to surface to the user after setup.
      */
@@ -79,6 +90,7 @@ export declare class ProjectMigrator {
      * Falls back to scanning the webapp folder for .ts files directly, since after a download from ABAP
      * the project will not yet have a tsconfig.json — it is added as part of the migration itself.
      *
+     * @param fs - The mem-fs editor.
      * @param rootPath - The project root path.
      * @param webappPath - The relative path to the webapp folder.
      * @returns True if the project contains TypeScript source files.
@@ -86,9 +98,9 @@ export declare class ProjectMigrator {
     private static detectTypeScriptApp;
     /**
      * Scans the webapp folder for a TypeScript source file (.ts, excluding .d.ts).
-     * During migration the downloaded files live in the uncommitted mem-fs editor, so when an
-     * editor with a store is in context the mem-fs store is scanned; otherwise the real disk is read.
+     * The migration tree is loaded into the mem-fs store, so the staged files are scanned.
      *
+     * @param fs - The mem-fs editor.
      * @param webappFullPath - Absolute path to the webapp folder.
      * @returns True if a non-declaration .ts file is present under the webapp folder.
      */

package/dist/ProjectMigrator.js

@@ -1,12 +1,10 @@
 import { FioriElementsVersion, FileName } from './project-spec-types.js';
-import { determineMessage, readFile, updateFile } from './utils/index.js';
-import { createMemFsEditor, getCurrentEditor, runWithEditor, exists, loadProjectIntoEditor } from './utils/fs-adapter.js';
-import { commitFileSystemChanges } from './files/file-system.js';
+import { determineMessage, readFile, updateFile, fileExists } from './utils/index.js';
+import { createMemFsEditor, loadProjectIntoEditor } from './utils/fs-adapter.js';
 import { ui5VersionRequestInfo } from '@sap-ux/ui5-info';
 import { getAppProgrammingLanguage } from '@sap-ux/project-access';
 import { enableTypescript, ui5TSSupport } from '@sap-ux/ui5-application-writer';
 import { UI5Config } from '@sap-ux/ui5-config';
-import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 // Migration-specific functions
 import { determineSourceTemplateType, checkForErrors, createMigrationErrorMessage, prepareConfigurationData, setupProjectStructure, generateAppSettings, applyAllTemplates, postProcessMigration } from './migration-process/index.js';
@@ -22,93 +20,57 @@ import { MigrationTypes } from './utils/constants.js';
 import { hasStore } from './types/mem-fs-types.js';
 import { i18nText, initI18n } from './i18n.js';
 export class ProjectMigrator {
-    // Implementation
-    static async migrate(
-    // NOSONAR - Implementation must support both overload signatures
-    projectRootOrOptions, baseUri, ui5SnapshotUrl, importProjectInfo, vscode, internalToggle, fs, strict) {
-        // Convert old signature to options object if called with positional parameters
-        const options = typeof projectRootOrOptions === 'string'
-            ? {
-                projectRoot: projectRootOrOptions,
-                baseUri: baseUri ?? '',
-                ui5SnapshotUrl: ui5SnapshotUrl ?? '',
-                importProjectInfo,
-                vscode,
-                internalToggle,
-                fs,
-                strict
-            }
-            : projectRootOrOptions;
+    /**
+     * migrate project
+     *
+     * @param options - Migration options object
+     * @returns Promise with fs editor, migration result, and messages
+     */
+    static async migrate(options) {
         const { projectRoot, baseUri: baseUriOpt, ui5SnapshotUrl: ui5SnapshotUrlOpt, importProjectInfo: importProjectInfoOpt, vscode: vscodeOpt, internalToggle: internalToggleOpt = false, fs: fsOpt, strict: strictOpt = false } = options;
         // Create a new isolated editor instance for this migration if not provided
         // This enables concurrent migrations without shared state corruption
         const ownsEditor = !fsOpt;
         const editor = fsOpt ?? createMemFsEditor();
         await initI18n();
-        // Run migration within editor context so all functions have access to it
-        const migrationResult = await runWithEditor(editor, async () => {
-            let messages = [];
-            let result = false;
-            try {
-                // Load the project tree into mem-fs so existence checks see untracked files
-                // on disk and migration writes never silently overwrite them.
-                await loadProjectIntoEditor(editor, projectRoot);
-                // Load or fetch project information
-                const { projectInfo, messages: projectInfoMessages } = await loadOrFetchProjectInfo(projectRoot, importProjectInfoOpt);
-                messages = messages.concat(projectInfoMessages);
-                projectInfo.baseUri = baseUriOpt;
-                // Resolve UI5 versions for migration
-                const ui5Versions = await resolveUI5VersionsForMigration(projectInfo, ui5SnapshotUrlOpt);
-                projectInfo.localUI5Version = ui5Versions?.[0]?.version;
-                if (/^(snapshot(-untested)?)?$/i.test(projectInfo.ui5Version?.trim() ?? '')) {
-                    projectInfo.ui5Version = projectInfo.localUI5Version ?? '';
-                }
-                // Validate project is suitable for migration (not a Fiori app in CAP project)
-                await validateProjectForMigration(projectRoot);
-                if (projectInfo &&
-                    (projectInfo.isSAPApp ||
-                        projectInfo.FEVersion === FioriElementsVersion.v2 ||
-                        projectInfo.FEVersion === FioriElementsVersion.v4 ||
-                        projectInfo.type === MigrationTypes.projectExtension) &&
-                    checkForErrors(messages)) {
-                    // V2 is supported (checkForErrors returns true if no ERROR-level messages)
-                    const { messages: copyMessages, result: isSuccess } = await this.copyCommonFiles(projectInfo, vscodeOpt, ui5SnapshotUrlOpt, internalToggleOpt, strictOpt);
-                    messages = messages.concat(copyMessages);
-                    result = isSuccess;
-                }
-                else if (projectInfo.type === MigrationTypes.library) {
-                    const { fs: updatedFs, messages: copyMessages, result: isSuccess } = await this.copyLibraryFiles(projectInfo);
-                    messages = messages.concat(copyMessages);
-                    result = isSuccess;
-                    // Update editor to the one returned from copyLibraryFiles
-                    return { fs: updatedFs, result, messages };
-                }
-                else if (projectInfo.uiAdaptation) {
-                    const { fs: updatedFs, messages: copyMessages, result: isSuccess } = await this.copyAdaptationFiles(projectInfo, ui5SnapshotUrlOpt);
-                    messages = messages.concat(copyMessages);
-                    result = isSuccess;
-                    // Update editor to the one returned from copyAdaptationFiles
-                    return { fs: updatedFs, result, messages };
-                }
-                else {
-                    messages.push({ type: 'ERROR', description: i18nText('ERROR_FAILED_TO_GET_PROJECT_INFO') });
-                }
-            }
-            catch (e) {
-                const error = e instanceof Error ? e : new Error(String(e));
-                const useMessage = typeof e === 'object' && e !== null && 'useMessage' in e ? Boolean(e.useMessage) : false;
-                messages.push({
-                    type: 'ERROR',
-                    description: `Error during migration: ${determineMessage(error, undefined, useMessage)}`
-                });
-            }
-            // Return fs editor for caller to commit
-            // This matches the pattern used by other open-ux-tools writers
-            return { fs: editor, result, messages };
-        });
+        let messages = [];
+        let result = false;
+        try {
+            // Load the project tree into mem-fs so existence checks see untracked files
+            // on disk and migration writes never silently overwrite them.
+            await loadProjectIntoEditor(editor, projectRoot);
+            // Load or fetch project information
+            const { projectInfo, messages: projectInfoMessages } = await loadOrFetchProjectInfo(projectRoot, importProjectInfoOpt, editor);
+            messages = messages.concat(projectInfoMessages);
+            projectInfo.baseUri = baseUriOpt;
+            // Resolve UI5 versions for migration
+            const ui5Versions = await resolveUI5VersionsForMigration(projectInfo, ui5SnapshotUrlOpt);
+            projectInfo.localUI5Version = ui5Versions?.[0]?.version;
+            // ui5Version left as-is from project/neo-app data
+            // Validate project is suitable for migration (not a Fiori app in CAP project)
+            await validateProjectForMigration(editor, projectRoot);
+            const dispatch = await this.runMigrationForProjectInfo(editor, projectInfo, messages, {
+                vscode: vscodeOpt,
+                ui5SnapshotUrl: ui5SnapshotUrlOpt,
+                internalToggle: internalToggleOpt,
+                strict: strictOpt
+            });
+            messages = dispatch.messages;
+            result = dispatch.result;
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            const useMessage = typeof e === 'object' && e !== null && 'useMessage' in e ? Boolean(e.useMessage) : false;
+            messages.push({
+                type: 'ERROR',
+                description: `Error during migration: ${determineMessage(error, undefined, useMessage)}`
+            });
+        }
+        const migrationResult = { fs: editor, result, messages };
+        // Commit only when we own the editor; otherwise the caller commits (matches other writers).
         if (ownsEditor && migrationResult.result) {
             try {
-                await commitFileSystemChanges(migrationResult.fs);
+                await new Promise((resolve, reject) => migrationResult.fs.commit((error) => (error ? reject(error) : resolve())));
             }
             catch (error) {
                 migrationResult.result = false;
@@ -120,10 +82,45 @@ export class ProjectMigrator {
         }
         return migrationResult;
     }
+    /**
+     * Run the migration for the resolved project info, dispatching by project type.
+     *
+     * @param editor
+     * @param projectInfo
+     * @param messages
+     * @param opts
+     * @param opts.vscode
+     * @param opts.ui5SnapshotUrl
+     * @param opts.internalToggle
+     * @param opts.strict
+     */
+    static async runMigrationForProjectInfo(editor, projectInfo, messages, opts) {
+        const isSupportedApp = projectInfo.isSAPApp ||
+            projectInfo.FEVersion === FioriElementsVersion.v2 ||
+            projectInfo.FEVersion === FioriElementsVersion.v4 ||
+            projectInfo.type === MigrationTypes.projectExtension;
+        if (isSupportedApp && checkForErrors(messages)) {
+            const { messages: copyMessages, result } = await this.copyCommonFiles(editor, projectInfo, opts.vscode, opts.ui5SnapshotUrl, opts.internalToggle, opts.strict);
+            return { result, messages: messages.concat(copyMessages) };
+        }
+        if (projectInfo.type === MigrationTypes.library) {
+            const { messages: copyMessages, result } = await this.copyLibraryFiles(editor, projectInfo);
+            return { result, messages: messages.concat(copyMessages) };
+        }
+        if (projectInfo.uiAdaptation) {
+            const { messages: copyMessages, result } = await this.copyAdaptationFiles(editor, projectInfo, opts.ui5SnapshotUrl);
+            return { result, messages: messages.concat(copyMessages) };
+        }
+        return {
+            result: false,
+            messages: messages.concat({ type: 'ERROR', description: i18nText('ERROR_FAILED_TO_GET_PROJECT_INFO') })
+        };
+    }
     /**
      * Copy files from templates into the project
      * Orchestrates the migration process through distinct phases
      *
+     * @param fs - mem-fs editor
      * @param projectInfo - Project information
      * @param vscode - VS Code context
      * @param ui5SnapshotUrl - UI5 snapshot URL
@@ -131,19 +128,20 @@ export class ProjectMigrator {
      * @param strict - Enable strict validation mode (WARNINGs become ERRORs for critical issues)
      * @returns Migration result with status and messages
      */
-    static async copyCommonFiles(projectInfo, vscode, ui5SnapshotUrl, internalToggle = false, strict = false) {
+    static async copyCommonFiles(fs, projectInfo, vscode, ui5SnapshotUrl, internalToggle = false, strict = false) {
         const messages = [];
         const { isSAPApp = false, rootPath, destination, neoappDestinations, firstNeoAppDestination } = projectInfo;
         try {
             // Detect TypeScript project
-            const isTypeScriptApp = await ProjectMigrator.detectTypeScriptApp(rootPath, projectInfo.webappPath);
+            const isTypeScriptApp = await ProjectMigrator.detectTypeScriptApp(fs, rootPath, projectInfo.webappPath);
             // Prepare configuration data
-            const configData = await prepareConfigurationData(projectInfo, projectInfo.ui5Version, isTypeScriptApp);
+            const configData = await prepareConfigurationData(fs, projectInfo, projectInfo.ui5Version, isTypeScriptApp);
             // Phase 1: Setup project structure
-            const { webappPath, keepIndex } = await setupProjectStructure(projectInfo, rootPath);
+            const { webappPath, keepIndex } = await setupProjectStructure(fs, projectInfo, rootPath);
             projectInfo.webappPath = webappPath;
             // Phase 2: Assemble template data
             const templateContext = await assembleTemplateData({
+                fs,
                 projectInfo,
                 rootPath,
                 projectData: configData.projectData,
@@ -193,6 +191,7 @@ export class ProjectMigrator {
             // Phase 3: Generate app settings
             const sourceTemplateType = determineSourceTemplateType(projectInfo, MigrationTypes);
             await generateAppSettings({
+                fs,
                 rootPath,
                 templateData: templateContext.templateData,
                 destination,
@@ -207,6 +206,7 @@ export class ProjectMigrator {
             });
             // Phase 4: Apply all templates
             await applyAllTemplates({
+                fs,
                 projectInfo,
                 rootPath,
                 templateData: templateContext.templateData,
@@ -220,6 +220,7 @@ export class ProjectMigrator {
             });
             // Phase 5: Post-processing
             await postProcessMigration({
+                fs,
                 projectInfo,
                 rootPath,
                 manifestJSON: templateContext.manifestJSON,
@@ -232,7 +233,7 @@ export class ProjectMigrator {
             });
             // Phase 6: TypeScript setup (if TypeScript app detected)
             if (isTypeScriptApp) {
-                const tsMessages = await ProjectMigrator.setupTypeScript(rootPath);
+                const tsMessages = await ProjectMigrator.setupTypeScript(fs, rootPath);
                 messages.push(...tsMessages);
             }
             return { result: checkForErrors(messages), messages };
@@ -247,32 +248,35 @@ export class ProjectMigrator {
     /**
      * Copy files from templates into the project
      *
+     * @param fs - mem-fs editor
      * @param projectInfo
      * @param snapshotUrl
      */
-    static async copyAdaptationFiles(projectInfo, snapshotUrl) {
-        return copyAdaptationFiles(projectInfo, snapshotUrl, undefined);
+    static async copyAdaptationFiles(fs, projectInfo, snapshotUrl) {
+        return copyAdaptationFiles(fs, projectInfo, snapshotUrl);
     }
     /**
      * Copy files from templates into the project
      *
+     * @param fs
      * @param projectInfo
      */
-    static async copyLibraryFiles(projectInfo) {
-        return copyLibraryFiles(projectInfo);
+    static async copyLibraryFiles(fs, projectInfo) {
+        return copyLibraryFiles(fs, projectInfo);
     }
     /**
      * Configures a downloaded TypeScript app for local development.
      * Generates tsconfig.json and TypeScript devDependencies via {@link enableTypescript},
      * then patches ui5-local.yaml and ui5-mock.yaml with the transpile middleware and task.
      *
+     * @param fs - The mem-fs editor.
      * @param rootPath - The project root path.
      * @returns Messages to surface to the user after setup.
      */
-    static async setupTypeScript(rootPath) {
+    static async setupTypeScript(fs, rootPath) {
         const messages = [];
         try {
-            await enableTypescript(rootPath, getCurrentEditor());
+            await enableTypescript(rootPath, fs);
         }
         catch (err) {
             messages.push({
@@ -284,14 +288,12 @@ export class ProjectMigrator {
         // Check and update ui5*.yaml files sequentially - order doesn't matter but list is small
         for (const yamlName of [FileName.UI5LocalYaml, FileName.UI5MockYaml]) {
             const yamlPath = join(rootPath, yamlName);
-            if (await exists(yamlPath)) {
-                // NOSONAR - Only 2 files, acceptable sequential check
-                // readFile and updateFile are sync mem-fs operations
-                const yamlContent = readFile(yamlPath);
+            if (fileExists(fs, yamlPath)) {
+                const yamlContent = readFile(fs, yamlPath);
                 const yamlConfig = await UI5Config.newInstance(yamlContent); // NOSONAR - Sequential YAML parsing required
                 yamlConfig.addCustomMiddleware([ui5TSSupport.middleware]);
                 yamlConfig.addCustomTasks([ui5TSSupport.task]);
-                updateFile(yamlPath, yamlConfig.toString());
+                updateFile(fs, yamlPath, yamlConfig.toString());
             }
         }
         messages.push({
@@ -306,11 +308,12 @@ export class ProjectMigrator {
      * Falls back to scanning the webapp folder for .ts files directly, since after a download from ABAP
      * the project will not yet have a tsconfig.json — it is added as part of the migration itself.
      *
+     * @param fs - The mem-fs editor.
      * @param rootPath - The project root path.
      * @param webappPath - The relative path to the webapp folder.
      * @returns True if the project contains TypeScript source files.
      */
-    static async detectTypeScriptApp(rootPath, webappPath) {
+    static async detectTypeScriptApp(fs, rootPath, webappPath) {
         const webappFullPath = join(rootPath, webappPath);
         // Try getAppProgrammingLanguage first (needs tsconfig.json and package.json)
         let isTypeScript = false;
@@ -324,39 +327,34 @@ export class ProjectMigrator {
         if (isTypeScript) {
             return true;
         }
-        return ProjectMigrator.webappHasTypeScriptFile(webappFullPath);
+        return ProjectMigrator.webappHasTypeScriptFile(fs, webappFullPath);
     }
     /**
      * Scans the webapp folder for a TypeScript source file (.ts, excluding .d.ts).
-     * During migration the downloaded files live in the uncommitted mem-fs editor, so when an
-     * editor with a store is in context the mem-fs store is scanned; otherwise the real disk is read.
+     * The migration tree is loaded into the mem-fs store, so the staged files are scanned.
      *
+     * @param fs - The mem-fs editor.
      * @param webappFullPath - Absolute path to the webapp folder.
      * @returns True if a non-declaration .ts file is present under the webapp folder.
      */
-    static async webappHasTypeScriptFile(webappFullPath) {
+    static webappHasTypeScriptFile(fs, webappFullPath) {
         const isTypeScriptFile = (filePath) => filePath.endsWith('.ts') && !filePath.endsWith('.d.ts');
-        const editor = getCurrentEditor();
-        if (editor && hasStore(editor)) {
-            // mem-fs mode: scan staged files under the webapp folder (paths use forward slashes)
-            const normalizedPrefix = webappFullPath.replaceAll('\\', '/').replace(/\/?$/, '/');
-            let found = false;
-            editor.store.each((file) => {
-                if (file.state === 'deleted') {
-                    return;
-                }
-                const normalizedFilePath = file.path.replaceAll('\\', '/');
-                if (normalizedFilePath.startsWith(normalizedPrefix) && isTypeScriptFile(normalizedFilePath)) {
-                    found = true;
-                }
-            });
-            return found;
-        }
-        // No editor context: scan the real filesystem
-        if (!(await exists(webappFullPath))) {
+        if (!hasStore(fs)) {
             return false;
         }
-        return (await readdir(webappFullPath, { recursive: true })).some((f) => typeof f === 'string' && isTypeScriptFile(f));
+        // Scan staged files under the webapp folder (paths use forward slashes)
+        const normalizedPrefix = webappFullPath.replaceAll('\\', '/').replace(/\/?$/, '/');
+        let found = false;
+        fs.store.each((file) => {
+            if (file.state === 'deleted') {
+                return;
+            }
+            const normalizedFilePath = file.path.replaceAll('\\', '/');
+            if (normalizedFilePath.startsWith(normalizedPrefix) && isTypeScriptFile(normalizedFilePath)) {
+                found = true;
+            }
+        });
+        return found;
     }
 }
 //# sourceMappingURL=ProjectMigrator.js.map

package/dist/adapters/ui5-config-adapter.js

@@ -37,14 +37,14 @@ function addMockserverMiddleware(orderedYaml, templateData) {
             }
         }
     };
-    // Find index of fiori-tools-proxy and insert before it
+    // Find index of fiori-tools-proxy and insert after it
     const proxyIndex = orderedYaml.server.customMiddleware.findIndex((mw) => mw.name === 'fiori-tools-proxy');
     if (proxyIndex >= 0) {
-        orderedYaml.server.customMiddleware.splice(proxyIndex, 0, mockserverMiddleware);
+        orderedYaml.server.customMiddleware.splice(proxyIndex + 1, 0, mockserverMiddleware);
     }
     else {
-        // If proxy not found, add at beginning
-        orderedYaml.server.customMiddleware.unshift(mockserverMiddleware);
+        // If proxy not found, add at end
+        orderedYaml.server.customMiddleware.push(mockserverMiddleware);
     }
 }
 /**
@@ -202,22 +202,68 @@ export async function generateUI5LocalYamlContent(options) {
  */
 export async function generateUI5MockYamlContent(templateData, webappPath, setUI5Version) {
     const config = await createBaseConfig(templateData);
-    // Add fiori-tools-proxy middleware with UI5 version if provided
-    const proxyConfig = {
-        ignoreCertErrors: false,
-        backend: [],
-        ui5: {
-            path: ['/resources', '/test-resources'],
-            url: templateData.ui5Yaml?.ui5Url || ''
-        }
-    };
-    // Add UI5 version to proxy if provided and setUI5Version is true
-    if (setUI5Version && templateData.ui5Yaml?.ui5Version) {
-        proxyConfig.ui5.version = templateData.ui5Yaml.ui5Version;
-    }
+    // Add fiori-tools-proxy middleware with the main backend (ui5-mock.yaml uses only the
+    // primary backend, not the per-service neo-app destinations that ui5.yaml carries).
+    const mainBackend = buildMainBackend(templateData);
+    const backends = mainBackend ? [mainBackend] : [];
+    const proxyConfig = buildProxyConfig(backends, templateData, setUI5Version);
     config.addFioriToolsProxyMiddleware(proxyConfig);
     // Add fiori-tools-appreload middleware
     config.addFioriToolsAppReloadMiddleware();
-    return postProcessYaml(config.toString(), webappPath);
+    // Add fiori-tools-preview middleware if configured
+    const previewMiddleware = buildPreviewMiddleware(templateData);
+    if (previewMiddleware) {
+        config.addCustomMiddleware(previewMiddleware);
+    }
+    const yamlContent = config.toString();
+    const yamlJson = parse(yamlContent);
+    const orderedYaml = { specVersion: '4.0' };
+    Object.keys(yamlJson).forEach((key) => {
+        orderedYaml[key] = yamlJson[key];
+    });
+    // Add sap-fe-mockserver middleware (the core of ui5-mock.yaml) when a service is configured.
+    if (templateData.ui5Yaml?.servicePath) {
+        addMockServerServicesMiddleware(orderedYaml, templateData);
+    }
+    // Apply webappPath if provided
+    if (webappPath) {
+        setWebappPath(orderedYaml, webappPath);
+        setAppreloadPath(orderedYaml, webappPath);
+    }
+    return stringify(orderedYaml);
+}
+/**
+ * Add a sap-fe-mockserver middleware (mountPath/services[] shape used by ui5-mock.yaml)
+ * before the fiori-tools-proxy middleware.
+ *
+ * @param orderedYaml - Parsed YAML object to mutate
+ * @param templateData - Template data with the service/mock configuration
+ */
+function addMockServerServicesMiddleware(orderedYaml, templateData) {
+    orderedYaml.server ??= { customMiddleware: [] };
+    orderedYaml.server.customMiddleware ??= [];
+    const mockserverMiddleware = {
+        name: 'sap-fe-mockserver',
+        beforeMiddleware: 'fiori-tools-proxy',
+        configuration: {
+            mountPath: '/',
+            services: [
+                {
+                    urlPath: (templateData.ui5Yaml?.servicePath ?? '').replace(/\/$/, ''),
+                    metadataPath: templateData.ui5Yaml?.metadataXmlPath || '',
+                    mockdataPath: templateData.ui5Yaml?.mockdataRootPath || '',
+                    generateMockData: templateData.ui5Yaml?.generateMockData ?? true,
+                    annotations: []
+                }
+            ]
+        }
+    };
+    const proxyIndex = orderedYaml.server.customMiddleware.findIndex((mw) => mw.name === 'fiori-tools-proxy');
+    if (proxyIndex >= 0) {
+        orderedYaml.server.customMiddleware.splice(proxyIndex + 1, 0, mockserverMiddleware);
+    }
+    else {
+        orderedYaml.server.customMiddleware.push(mockserverMiddleware);
+    }
 }
 //# sourceMappingURL=ui5-config-adapter.js.map

package/dist/adapters/ui5-config-helpers.js

@@ -7,12 +7,12 @@
  * @returns Backend configuration or undefined if not configured
  */
 export function buildMainBackend(templateData) {
-    if (!templateData.ui5Yaml?.proxyPath || !templateData.ui5Yaml?.proxyHost) {
+    if (!templateData.ui5Yaml?.proxyPath || (!templateData.ui5Yaml?.proxyHost && !templateData.ui5Yaml?.destination)) {
         return undefined;
     }
     const backend = {
         path: templateData.ui5Yaml.proxyPath,
-        url: templateData.ui5Yaml.proxyHost
+        url: templateData.ui5Yaml.proxyHost ?? ''
     };
     // Add optional properties
     if (templateData.ui5Yaml.client) {
@@ -49,15 +49,8 @@ export function buildProxyConfig(backends, templateData, setUI5Version) {
             url: templateData.ui5Yaml?.ui5Url || ''
         }
     };
-    // Add UI5 version to proxy config when setUI5Version is true
-    // This matches the behavior in tools-suite master for ui5-mock.yaml
-    // Skip if version is a placeholder/fallback value like "snapshot-version"
     if (setUI5Version && templateData.ui5Yaml?.ui5Version) {
-        const version = templateData.ui5Yaml.ui5Version;
-        // Only add real versions, not placeholder values
-        if (version && !version.includes('snapshot-version')) {
-            proxyConfig.ui5.version = version;
-        }
+        proxyConfig.ui5.version = templateData.ui5Yaml.ui5Version;
     }
     return proxyConfig;
 }

package/dist/components/extension.d.ts

@@ -1,10 +1,12 @@
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo } from '../types.js';
 /**
  * Updates the .extconfig.json file for extension projects
  * Handles WebIDE Personal Edition migration and destination updates
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information containing extension settings
  */
-export declare function updateExtConfigJson(rootPath: string, projectInfo: ImportProjectInfo): Promise<void>;
+export declare function updateExtConfigJson(fs: Editor, rootPath: string, projectInfo: ImportProjectInfo): void;
 //# sourceMappingURL=extension.d.ts.map

package/dist/components/extension.js

@@ -5,10 +5,11 @@ import { FileName } from '../project-spec-types.js';
  * Updates the .extconfig.json file for extension projects
  * Handles WebIDE Personal Edition migration and destination updates
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information containing extension settings
  */
-export async function updateExtConfigJson(rootPath, projectInfo) {
+export function updateExtConfigJson(fs, rootPath, projectInfo) {
     let extensionProjectSettingsJSON;
     let deleteProjectJson = false;
     try {
@@ -52,10 +53,10 @@ export async function updateExtConfigJson(rootPath, projectInfo) {
         }
     }
     // write .extconfig.json for extension project
-    updateJSON(join(rootPath, FileName.ExtConfigJson), extensionProjectSettingsJSON);
+    updateJSON(fs, join(rootPath, FileName.ExtConfigJson), extensionProjectSettingsJSON);
     const projectJsonPath = join(rootPath, '.project.json');
-    if (deleteProjectJson && (await fileExists(projectJsonPath))) {
-        deleteFile(projectJsonPath);
+    if (deleteProjectJson && fileExists(fs, projectJsonPath)) {
+        deleteFile(fs, projectJsonPath);
     }
 }
 //# sourceMappingURL=extension.js.map