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

package/dist/utils/project-readers/reuse-lib-utils.d.ts

@@ -1,6 +1,7 @@
 /**
  * Utilities for detecting and processing reuse library projects
  */
+import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '../../project-spec-types.js';
 import { MigrationTypes } from '../constants.js';
 import type { ProjectFolder } from '../../types.js';
@@ -27,10 +28,11 @@ export declare function isSamePath(pathA: string, pathB: string): boolean;
  * same way the workspace discovery path does and returns the library whose root
  * resolves back to projectRoot.
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns The nested manifest and its path, or undefined if none is found
  */
-export declare function findNestedReuseLibManifest(projectRoot: string): Promise<{
+export declare function findNestedReuseLibManifest(fs: Editor, projectRoot: string): Promise<{
     manifest: Manifest;
     manifestPath: string;
 } | undefined>;
@@ -40,16 +42,18 @@ export declare function findNestedReuseLibManifest(projectRoot: string): Promise
  * @param projectRoot - Root path of the project
  * @param type - Optional migration type
  * @param manifest - Optional manifest object
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns True if project is a reuse library
  */
-export declare function checkIfReuseLib(projectRoot: string, type?: MigrationTypes, manifest?: Manifest): Promise<boolean>;
+export declare function checkIfReuseLib(projectRoot: string, type?: MigrationTypes, manifest?: Manifest, fsEditor?: Editor): Promise<boolean>;
 /**
  * Get module name for reuse library
  *
  * @param projectRoot - Root path of the project
  * @param workspaceFolders - Optional workspace folders
  * @param manifest - Optional manifest object
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns Module name
  */
-export declare function getReuseLibModuleName(projectRoot: string, workspaceFolders?: readonly ProjectFolder[], manifest?: Manifest): Promise<string>;
+export declare function getReuseLibModuleName(projectRoot: string, workspaceFolders?: readonly ProjectFolder[], manifest?: Manifest, fsEditor?: Editor): Promise<string>;
 //# sourceMappingURL=reuse-lib-utils.d.ts.map

package/dist/utils/project-readers/reuse-lib-utils.js

@@ -3,6 +3,7 @@
  */
 import { basename, join, relative } from 'node:path';
 import { getReuseLibs, ReuseLibType } from '../file-discovery.js';
+import { createMemFsEditor } from '../fs-adapter.js';
 import { readJSON } from '../../index.js';
 import { FileName } from '../../project-spec-types.js';
 import { MigrationTypes } from '../constants.js';
@@ -32,17 +33,18 @@ export function isSamePath(pathA, pathB) {
  * same way the workspace discovery path does and returns the library whose root
  * resolves back to projectRoot.
  *
+ * @param fs - mem-fs editor
  * @param projectRoot - Root path of the project
  * @returns The nested manifest and its path, or undefined if none is found
  */
-export async function findNestedReuseLibManifest(projectRoot) {
-    const libs = await getReuseLibs([{ uri: URI.file(projectRoot), name: projectRoot, index: 0 }]);
+export async function findNestedReuseLibManifest(fs, projectRoot) {
+    const libs = await getReuseLibs(fs, [{ uri: URI.file(projectRoot), name: projectRoot, index: 0 }]);
     const matchedLib = libs.find((lib) => lib.value.type === ReuseLibType.LIBRARY && isSamePath(lib.value.libRoot, projectRoot));
     if (!matchedLib) {
         return undefined;
     }
     try {
-        const manifest = await readJSON(matchedLib.value.path);
+        const manifest = await readJSON(fs, matchedLib.value.path);
         return { manifest, manifestPath: matchedLib.value.path };
     }
     catch {
@@ -57,17 +59,19 @@ export async function findNestedReuseLibManifest(projectRoot) {
  * @param projectRoot - Root path of the project
  * @param type - Optional migration type
  * @param manifest - Optional manifest object
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns True if project is a reuse library
  */
-export async function checkIfReuseLib(projectRoot, type, manifest) {
+export async function checkIfReuseLib(projectRoot, type, manifest, fsEditor) {
     if (type) {
         return type === MigrationTypes.library;
     }
     if (manifest) {
         return manifest['sap.app']?.type === 'library';
     }
+    const fs = fsEditor ?? createMemFsEditor();
     try {
-        const reuseManifest = await readJSON(join(projectRoot, FileName.Manifest));
+        const reuseManifest = await readJSON(fs, join(projectRoot, FileName.Manifest));
         return reuseManifest['sap.app']?.type === 'library';
     }
     catch {
@@ -82,9 +86,11 @@ export async function checkIfReuseLib(projectRoot, type, manifest) {
  * @param projectRoot - Root path of the project
  * @param workspaceFolders - Optional workspace folders
  * @param manifest - Optional manifest object
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  * @returns Module name
  */
-export async function getReuseLibModuleName(projectRoot, workspaceFolders, manifest) {
+export async function getReuseLibModuleName(projectRoot, workspaceFolders, manifest, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
     let moduleName;
     if (manifest) {
         moduleName = manifest['sap.app']?.id;
@@ -96,7 +102,7 @@ export async function getReuseLibModuleName(projectRoot, workspaceFolders, manif
             name: folder.name,
             index: folder.index
         }));
-        const libs = await getReuseLibs(workspaceFoldersWithUri);
+        const libs = await getReuseLibs(fs, workspaceFoldersWithUri);
         const matchedLib = libs.find((lib) => {
             return isSamePath(lib.value.libRoot, projectRoot);
         });

package/dist/utils/project-readers/webapp-path-resolver.d.ts

@@ -1,11 +1,13 @@
+import type { Editor } from 'mem-fs-editor';
 import { MigrationTypes } from '../constants.js';
 /**
  * Get webapp path for project
  * Tries multiple sources in order of priority
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  * @param type
  * @param libPath
  */
-export declare function getWebappPath(projectRoot: string, type?: MigrationTypes, libPath?: string): Promise<string>;
+export declare function getWebappPath(fs: Editor, projectRoot: string, type?: MigrationTypes, libPath?: string): Promise<string>;
 //# sourceMappingURL=webapp-path-resolver.d.ts.map

package/dist/utils/project-readers/webapp-path-resolver.js

@@ -4,24 +4,26 @@
 import { join } from 'node:path';
 import { parse } from 'yaml';
 import { DirName, FileName } from '../../project-spec-types.js';
-import { fileExists, readJSON, readFile } from '../../index.js';
+import { fileExists, readJSON } from '../../index.js';
+import { readFile } from '../../utils/file-access.js';
 import { sapWattCommonSetting } from '../../types.js';
 import { MigrationTypes } from '../constants.js';
 /**
  * Resolve webapp path from .project.json file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  */
-async function resolveFromProjectJson(projectRoot) {
+async function resolveFromProjectJson(fs, projectRoot) {
     const projectJsonPath = join(projectRoot, '.project.json');
-    if (!(await fileExists(projectJsonPath))) {
+    if (!fileExists(fs, projectJsonPath)) {
         return undefined;
     }
     try {
-        const projectJson = await readJSON(projectJsonPath);
+        const projectJson = await readJSON(fs, projectJsonPath);
         if (projectJson?.hcpdeploy?.entryPath) {
             const projectWebappPath = join(projectRoot, projectJson.hcpdeploy.entryPath);
-            return (await fileExists(projectWebappPath)) ? projectJson.hcpdeploy.entryPath : undefined;
+            return fileExists(fs, projectWebappPath) ? projectJson.hcpdeploy.entryPath : undefined;
         }
     }
     catch (error) {
@@ -32,20 +34,21 @@ async function resolveFromProjectJson(projectRoot) {
 /**
  * Resolve webapp path from .che/project.json file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  */
-async function resolveFromCheProjectJson(projectRoot) {
+async function resolveFromCheProjectJson(fs, projectRoot) {
     const cheProjectJsonPath = join(projectRoot, '.che', 'project.json');
-    if (!(await fileExists(cheProjectJsonPath))) {
+    if (!fileExists(fs, cheProjectJsonPath)) {
         return undefined;
     }
     try {
-        const projectJson = await readJSON(cheProjectJsonPath);
+        const projectJson = await readJSON(fs, cheProjectJsonPath);
         if (projectJson?.attributes?.[sapWattCommonSetting]) {
             const settings = JSON.parse(projectJson.attributes[sapWattCommonSetting]?.[0]);
             if (settings?.hcpdeploy?.entryPath) {
                 const projectWebappPath = join(projectRoot, settings.hcpdeploy.entryPath);
-                return (await fileExists(projectWebappPath)) ? settings.hcpdeploy.entryPath : undefined;
+                return fileExists(fs, projectWebappPath) ? settings.hcpdeploy.entryPath : undefined;
             }
         }
     }
@@ -57,11 +60,12 @@ async function resolveFromCheProjectJson(projectRoot) {
 /**
  * Resolve webapp path from ui5.yaml file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  */
-function resolveFromUi5Yaml(projectRoot) {
+function resolveFromUi5Yaml(fs, projectRoot) {
     try {
-        const yamlContent = readFile(join(projectRoot, FileName.UI5Yaml));
+        const yamlContent = readFile(fs, join(projectRoot, FileName.UI5Yaml));
         return parse(yamlContent)?.resources?.configuration?.paths?.webapp;
     }
     catch (error) {
@@ -86,27 +90,28 @@ function resolveForLibrary(projectRoot, libPath) {
  * Get webapp path for project
  * Tries multiple sources in order of priority
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  * @param type
  * @param libPath
  */
-export async function getWebappPath(projectRoot, type, libPath) {
+export async function getWebappPath(fs, projectRoot, type, libPath) {
     const defaultPath = join(projectRoot, DirName.Webapp);
     // Check if default webapp folder exists
-    if (await fileExists(defaultPath)) {
+    if (fileExists(fs, defaultPath)) {
         return DirName.Webapp;
     }
     // Check if manifest.json is in root (no webapp folder)
-    if (await fileExists(join(projectRoot, FileName.Manifest))) {
+    if (fileExists(fs, join(projectRoot, FileName.Manifest))) {
         return '';
     }
     // Check for legacy Maven/Java structure: src/main/webapp
     const legacyMavenPath = join('src', 'main', DirName.Webapp);
     const legacyMavenFullPath = join(projectRoot, legacyMavenPath);
-    if (await fileExists(legacyMavenFullPath)) {
+    if (fileExists(fs, legacyMavenFullPath)) {
         // Verify it actually has webapp content (manifest.json)
         const legacyManifestPath = join(legacyMavenFullPath, FileName.Manifest);
-        if (await fileExists(legacyManifestPath)) {
+        if (fileExists(fs, legacyManifestPath)) {
             return legacyMavenPath;
         }
     }
@@ -118,17 +123,17 @@ export async function getWebappPath(projectRoot, type, libPath) {
         }
     }
     // Try .project.json
-    const projectJsonPath = await resolveFromProjectJson(projectRoot);
+    const projectJsonPath = await resolveFromProjectJson(fs, projectRoot);
     if (projectJsonPath) {
         return projectJsonPath;
     }
     // Try .che/project.json
-    const cheProjectJsonPath = await resolveFromCheProjectJson(projectRoot);
+    const cheProjectJsonPath = await resolveFromCheProjectJson(fs, projectRoot);
     if (cheProjectJsonPath) {
         return cheProjectJsonPath;
     }
     // Try ui5.yaml
-    const ui5YamlPath = resolveFromUi5Yaml(projectRoot);
+    const ui5YamlPath = resolveFromUi5Yaml(fs, projectRoot);
     if (ui5YamlPath) {
         return ui5YamlPath;
     }

package/dist/utils/service.d.ts

@@ -1,7 +1,8 @@
 import type { Manifest } from '../project-spec-types.js';
+import type { Editor } from 'mem-fs-editor';
 export declare function xmlToJson(metadata: any): JSON | undefined;
-export declare function validateMetadata(rootPath: string, webappPath: string, isSAPApp?: boolean, manifestJSON?: Manifest | undefined): Promise<{
+export declare function validateMetadata(rootPath: string, webappPath: string, isSAPApp?: boolean, manifestJSON?: Manifest | undefined, fsEditor?: Editor): {
     config: boolean;
     fileExists: boolean;
-}>;
+};
 //# sourceMappingURL=service.d.ts.map

package/dist/utils/service.js

@@ -1,4 +1,5 @@
 import { fileExists } from './file-access.js';
+import { createMemFsEditor } from './fs-adapter.js';
 import { XMLValidator, XMLParser } from 'fast-xml-parser';
 import { join } from 'node:path';
 const options = {
@@ -11,7 +12,8 @@ const options = {
 export function xmlToJson(metadata) {
     return XMLValidator.validate(metadata) ? new XMLParser(options).parse(metadata, true) : undefined;
 }
-export async function validateMetadata(rootPath, webappPath, isSAPApp, manifestJSON) {
+export function validateMetadata(rootPath, webappPath, isSAPApp, manifestJSON, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
     if (!manifestJSON) {
         return { config: false, fileExists: false };
     }
@@ -21,7 +23,7 @@ export async function validateMetadata(rootPath, webappPath, isSAPApp, manifestJ
     }
     // Validate datasources if they exist
     if (manifestJSON['sap.app']?.dataSources) {
-        return validateDataSources(manifestJSON['sap.app'].dataSources, rootPath, webappPath);
+        return validateDataSources(fs, manifestJSON['sap.app'].dataSources, rootPath, webappPath);
     }
     return { config: false, fileExists: false };
 }
@@ -30,11 +32,12 @@ export async function validateMetadata(rootPath, webappPath, isSAPApp, manifestJ
  * Preserves last-wins behavior: if multiple datasources have localUri,
  * the result reflects the last one processed
  *
+ * @param fs
  * @param dataSources
  * @param rootPath
  * @param webappPath
  */
-async function validateDataSources(dataSources, rootPath, webappPath) {
+function validateDataSources(fs, dataSources, rootPath, webappPath) {
     const datasourceKeys = Object.keys(dataSources);
     let metadataValidation = { config: false, fileExists: false };
     // Check datasources sequentially - stops at first valid metadata file found
@@ -42,7 +45,7 @@ async function validateDataSources(dataSources, rootPath, webappPath) {
         const datasource = dataSources[datasourceKey];
         // Check OData datasources or datasources without explicit type
         if (datasource.type === 'OData' || datasource.type === undefined) {
-            const result = await checkLocalMetadata(datasource, rootPath, webappPath); // NOSONAR: Last-wins pattern for datasource validation
+            const result = checkLocalMetadata(fs, datasource, rootPath, webappPath);
             if (result.config) {
                 metadataValidation = result;
             }
@@ -53,16 +56,17 @@ async function validateDataSources(dataSources, rootPath, webappPath) {
 /**
  * Check if local metadata file exists for a datasource
  *
+ * @param fs
  * @param datasource
  * @param rootPath
  * @param webappPath
  */
-async function checkLocalMetadata(datasource, rootPath, webappPath) {
+function checkLocalMetadata(fs, datasource, rootPath, webappPath) {
     if (!datasource.settings?.localUri) {
         return { config: false, fileExists: false };
     }
     const metadataPath = join(rootPath, webappPath, datasource.settings.localUri);
-    const exists = await fileExists(metadataPath);
+    const exists = fileExists(fs, metadataPath);
     return {
         config: true,
         fileExists: exists

package/dist/utils/template/template-post-processors.d.ts

@@ -1,4 +1,5 @@
 import type { Data } from 'ejs';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Apply file-specific post-processing handlers
  *
@@ -10,6 +11,7 @@ import type { Data } from 'ejs';
  * - GitIgnore: Merges with existing .gitignore if present
  * - package.json: Merges with existing package.json if present
  *
+ * @param fs - mem-fs editor
  * @param templateName - Name of the template being processed
  * @param templateContent - Rendered template content
  * @param projectRoot - Root directory of the project
@@ -17,5 +19,5 @@ import type { Data } from 'ejs';
  * @param templateData - Original template data (for package.json handler)
  * @returns Post-processed template content
  */
-export declare function applyFileSpecificHandlers(templateName: string, templateContent: string, projectRoot: string, targetFile: string, templateData: Data): Promise<string>;
+export declare function applyFileSpecificHandlers(fs: Editor, templateName: string, templateContent: string, projectRoot: string, targetFile: string, templateData: Data): Promise<string>;
 //# sourceMappingURL=template-post-processors.d.ts.map

package/dist/utils/template/template-post-processors.js

@@ -14,6 +14,7 @@ const packageJsonTmplName = `${FileName.Package}.tmpl`;
  * - GitIgnore: Merges with existing .gitignore if present
  * - package.json: Merges with existing package.json if present
  *
+ * @param fs - mem-fs editor
  * @param templateName - Name of the template being processed
  * @param templateContent - Rendered template content
  * @param projectRoot - Root directory of the project
@@ -21,18 +22,18 @@ const packageJsonTmplName = `${FileName.Package}.tmpl`;
  * @param templateData - Original template data (for package.json handler)
  * @returns Post-processed template content
  */
-export async function applyFileSpecificHandlers(templateName, templateContent, projectRoot, targetFile, templateData) {
+export async function applyFileSpecificHandlers(fs, templateName, templateContent, projectRoot, targetFile, templateData) {
     // Handle LocateReuseLibs template
     if (templateName === TemplateFileName.LocateReuseLibs) {
         return handleLocateReuseLibsFile(templateContent, templateData);
     }
     // Handle .gitignore template
     if (templateName === TemplateFileName.GitIgnoreTmpl) {
-        return handleGitIgnoreFile(targetFile, templateContent);
+        return handleGitIgnoreFile(targetFile, templateContent, fs);
     }
     // Handle package.json template
     if (templateName === packageJsonTmplName) {
-        return handlePackageJsonFile(projectRoot, targetFile, templateContent, templateData);
+        return handlePackageJsonFile(projectRoot, targetFile, templateContent, templateData, fs);
     }
     // No special handling needed
     return templateContent;

package/dist/utils/template/template-renderer.d.ts

@@ -1,10 +1,12 @@
 import type { Data } from 'ejs';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Render a template file
  *
  * Reads the template file and optionally renders it using EJS.
  * If rendering is disabled, returns the raw file content.
  *
+ * @param fs - mem-fs editor
  * @param templateRoot - Root directory containing templates
  * @param fullTemplateName - Full path to template file relative to templateRoot
  * @param templateData - Data to use for template rendering
@@ -13,5 +15,5 @@ import type { Data } from 'ejs';
  * @returns Rendered template content or raw file content
  * @throws Error if template path contains path traversal
  */
-export declare function renderTemplate(templateRoot: string, fullTemplateName: string, templateData: Data, opts: object, isRendered: boolean): string;
+export declare function renderTemplate(fs: Editor, templateRoot: string, fullTemplateName: string, templateData: Data, opts: object, isRendered: boolean): string;
 //# sourceMappingURL=template-renderer.d.ts.map

package/dist/utils/template/template-renderer.js

@@ -30,6 +30,7 @@ function validateTemplatePath(templateRoot, templateName) {
  * Reads the template file and optionally renders it using EJS.
  * If rendering is disabled, returns the raw file content.
  *
+ * @param fs - mem-fs editor
  * @param templateRoot - Root directory containing templates
  * @param fullTemplateName - Full path to template file relative to templateRoot
  * @param templateData - Data to use for template rendering
@@ -38,10 +39,10 @@ function validateTemplatePath(templateRoot, templateName) {
  * @returns Rendered template content or raw file content
  * @throws Error if template path contains path traversal
  */
-export function renderTemplate(templateRoot, fullTemplateName, templateData, opts, isRendered) {
+export function renderTemplate(fs, templateRoot, fullTemplateName, templateData, opts, isRendered) {
     // Validate path to prevent directory traversal attacks
     const safePath = validateTemplatePath(templateRoot, fullTemplateName);
-    const templateFile = readFile(safePath);
+    const templateFile = readFile(fs, safePath);
     return isRendered ? render(templateFile, templateData, { ...DEFAULT_EJS_OPTS, ...opts }) : templateFile;
 }
 //# sourceMappingURL=template-renderer.js.map

package/dist/utils/template-generators/file-handlers.d.ts

@@ -1,10 +1,12 @@
+import type { Editor } from 'mem-fs-editor';
 /**
  * Handle .gitignore file generation - append to existing file
  *
  * @param targetFile
  * @param templateContent
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export declare function handleGitIgnoreFile(targetFile: string, templateContent: string): Promise<string>;
+export declare function handleGitIgnoreFile(targetFile: string, templateContent: string, fsEditor?: Editor): string;
 /**
  * Handle package.json file generation - merge with existing file
  *
@@ -12,8 +14,9 @@ export declare function handleGitIgnoreFile(targetFile: string, templateContent:
  * @param targetFile
  * @param templateContent
  * @param templateData
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export declare function handlePackageJsonFile(projectRoot: string, targetFile: string, templateContent: string, templateData: any): Promise<string>;
+export declare function handlePackageJsonFile(projectRoot: string, targetFile: string, templateContent: string, templateData: any, fsEditor?: Editor): Promise<string>;
 /**
  * Handle locateReuseLibs file - replace mockserver path
  *

package/dist/utils/template-generators/file-handlers.js

@@ -4,6 +4,7 @@
  */
 import { join } from 'node:path';
 import { readFile, fileExists, readJSON, deleteFile } from '../file-access.js';
+import { createMemFsEditor } from '../fs-adapter.js';
 import mergeWith from 'lodash/mergeWith.js';
 import { MigrationTypes } from '../constants.js';
 /**
@@ -11,17 +12,54 @@ import { MigrationTypes } from '../constants.js';
  *
  * @param targetFile
  * @param templateContent
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export async function handleGitIgnoreFile(targetFile, templateContent) {
-    if (!(await fileExists(targetFile))) {
+export function handleGitIgnoreFile(targetFile, templateContent, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
+    if (!fileExists(fs, targetFile)) {
         return templateContent;
     }
-    const currentFileContent = readFile(targetFile);
+    const currentFileContent = readFile(fs, targetFile);
     let mergedContent = `${currentFileContent}\n${templateContent}`;
     // Replace `changes_preview.js` so it can be checked in after migration
     mergedContent = mergedContent.replaceAll(`/changes_preview.js`, '').replaceAll(`changes_preview.js`, '');
     return mergedContent;
 }
+/**
+ * Rename scripts in the existing package.json that collide with template script names,
+ * preserving the originals under a `<name>_old` key.
+ *
+ * @param currentFileContent - Parsed existing package.json (mutated in place)
+ * @param templateContentJSON - Parsed template package.json
+ */
+function renameConflictingScripts(currentFileContent, templateContentJSON) {
+    const oldScripts = {};
+    for (const script in templateContentJSON?.scripts) {
+        if (currentFileContent?.scripts?.[script] && !currentFileContent.scripts[`${script}_old`]) {
+            oldScripts[`${script}_old`] = currentFileContent.scripts[script];
+            delete currentFileContent.scripts[script];
+        }
+        else if (currentFileContent?.scripts?.[script]) {
+            delete currentFileContent.scripts[script];
+        }
+    }
+    for (const oldScript in oldScripts) {
+        currentFileContent.scripts[oldScript] = oldScripts[oldScript];
+    }
+}
+/**
+ * Add the extension-project `start-ui5-flp` script to the template package.json.
+ *
+ * @param templateContentJSON - Parsed template package.json (mutated in place)
+ * @param templateData - Template data with project/service configuration
+ */
+function addExtensionStartScript(templateContentJSON, templateData) {
+    let queryStr = templateData.project.ui5Theme ? `sap-theme=${templateData.project.ui5Theme}&` : '';
+    queryStr = templateData.service.client ? `${queryStr}sap-client=${templateData.service.client}&` : queryStr;
+    templateContentJSON.scripts ??= {};
+    templateContentJSON.scripts['start-ui5-flp'] =
+        `fiori run --open "/test-resources/sap/ushell/shells/sandbox/fioriSandbox.html?${queryStr}sap-ushell-test-url-url=..%2F..%2F..%2F..%2F..%2F..&sap-ushell-test-url-additionalInformation=SAPUI5.Component%3D${templateData.fullyQualifiedProjectName}#Test-url"`;
+}
 /**
  * Handle package.json file generation - merge with existing file
  *
@@ -29,14 +67,17 @@ export async function handleGitIgnoreFile(targetFile, templateContent) {
  * @param targetFile
  * @param templateContent
  * @param templateData
+ * @param fsEditor - optional mem-fs editor; a fresh one is created when omitted
  */
-export async function handlePackageJsonFile(projectRoot, targetFile, templateContent, templateData) {
-    if (!(await fileExists(targetFile))) {
+export async function handlePackageJsonFile(projectRoot, targetFile, templateContent, templateData, fsEditor) {
+    const fs = fsEditor ?? createMemFsEditor();
+    const ownsEditor = !fsEditor;
+    if (!fileExists(fs, targetFile)) {
         return templateContent;
     }
     let currentFileContent;
     try {
-        currentFileContent = await readJSON(targetFile);
+        currentFileContent = await readJSON(fs, targetFile);
     }
     catch (error) {
         // If file can't be read (shouldn't happen after fileExists check, but handle it anyway)
@@ -44,35 +85,15 @@ export async function handlePackageJsonFile(projectRoot, targetFile, templateCon
         return templateContent;
     }
     const templateContentJSON = JSON.parse(templateContent);
-    // Rename old scripts that have same name as new ones
-    const oldScripts = {};
-    for (const script in templateContentJSON?.scripts) {
-        if (currentFileContent?.scripts?.[script] && !currentFileContent.scripts[`${script}_old`]) {
-            oldScripts[`${script}_old`] = currentFileContent.scripts[script];
-            delete currentFileContent.scripts[script];
-        }
-        else if (currentFileContent?.scripts?.[script]) {
-            delete currentFileContent.scripts[script];
-        }
-    }
-    // Add renamed old scripts back
-    for (const oldScript in oldScripts) {
-        currentFileContent.scripts[oldScript] = oldScripts[oldScript];
-    }
+    renameConflictingScripts(currentFileContent, templateContentJSON);
     // Handle extension project special script
     if (templateData.project.type === MigrationTypes.projectExtension) {
-        let queryStr = templateData.project.ui5Theme ? `sap-theme=${templateData.project.ui5Theme}&` : '';
-        queryStr = templateData.service.client ? `${queryStr}sap-client=${templateData.service.client}&` : queryStr;
-        if (!templateContentJSON.scripts) {
-            templateContentJSON.scripts = {};
-        }
-        templateContentJSON.scripts['start-ui5-flp'] =
-            `fiori run --open "/test-resources/sap/ushell/shells/sandbox/fioriSandbox.html?${queryStr}sap-ushell-test-url-url=..%2F..%2F..%2F..%2F..%2F..&sap-ushell-test-url-additionalInformation=SAPUI5.Component%3D${templateData.fullyQualifiedProjectName}#Test-url"`;
+        addExtensionStartScript(templateContentJSON, templateData);
     }
     // Remove conflicting dependencies
     removeLegacyDependencies(currentFileContent, templateContentJSON);
     // Remove legacy Grunt module and file
-    await removeLegacyGruntModule(projectRoot, currentFileContent);
+    removeLegacyGruntModule(fs, projectRoot, currentFileContent);
     // Remove old beta ui5-tooling module
     removeBetaUi5ToolingModule(currentFileContent);
     // Filter duplicate keywords
@@ -83,6 +104,11 @@ export async function handlePackageJsonFile(projectRoot, targetFile, templateCon
             return objValue.concat(srcValue);
         }
     });
+    // When we created the editor ourselves, persist staged side effects (e.g. Gruntfile.js deletion).
+    // When the caller passed an editor, they own the commit (migration flow commits once at the end).
+    if (ownsEditor) {
+        await new Promise((resolve, reject) => fs.commit((err) => (err ? reject(err) : resolve())));
+    }
     return JSON.stringify(mergedContent, null, 2);
 }
 /**
@@ -117,10 +143,11 @@ function removeLegacyDependencies(currentFileContent, templateContentJSON) {
 /**
  * Remove legacy Grunt module and associated file
  *
+ * @param fs - mem-fs editor
  * @param projectRoot
  * @param currentFileContent
  */
-async function removeLegacyGruntModule(projectRoot, currentFileContent) {
+function removeLegacyGruntModule(fs, projectRoot, currentFileContent) {
     const gruntModule = '@sap/grunt-sapui5-bestpractice-build';
     let deleteGruntFile = false;
     if (currentFileContent?.devDependencies?.[gruntModule]) {
@@ -134,8 +161,8 @@ async function removeLegacyGruntModule(projectRoot, currentFileContent) {
     // If dependency exists, also remove the Gruntfile.js
     if (deleteGruntFile) {
         const gruntFilePath = join(projectRoot, 'Gruntfile.js');
-        if (await fileExists(gruntFilePath)) {
-            deleteFile(gruntFilePath);
+        if (fileExists(fs, gruntFilePath)) {
+            deleteFile(fs, gruntFilePath);
         }
     }
 }

package/package.json

@@ -10,7 +10,7 @@
   "bugs": {
     "url": "https://github.com/SAP/open-ux-tools/issues?q=is%3Aopen+is%3Aissue+label%3Abug+label%3Afiori-migration-writer"
   },
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "files": [
@@ -37,17 +37,17 @@
     "uuid": "11.1.1",
     "vscode-uri": "3.1.0",
     "yaml": "2.9.0",
-    "@sap-ux/adp-tooling": "1.0.66",
     "@sap-ux/axios-extension": "2.1.3",
     "@sap-ux/btp-utils": "2.0.8",
     "@sap-ux/i18n": "1.0.6",
     "@sap-ux/launch-config": "1.0.25",
+    "@sap-ux/adp-tooling": "1.0.66",
     "@sap-ux/nodejs-utils": "1.0.12",
     "@sap-ux/project-access": "2.3.1",
-    "@sap-ux/store": "2.0.7",
     "@sap-ux/ui5-application-writer": "2.1.6",
     "@sap-ux/ui5-config": "1.0.10",
-    "@sap-ux/ui5-info": "1.0.7"
+    "@sap-ux/ui5-info": "1.0.7",
+    "@sap-ux/store": "2.0.7"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",