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

package/dist/migration-process/legacy.js

@@ -2,69 +2,73 @@
  * Helper functions for migrating legacy Fiori Elements folder structures
  * Handles migration from /src/main/webapp to /webapp structure
  */
-import { join } from 'node:path';
+import { join, sep } from 'node:path';
 import { readFile, updateFile, readJSON, updateJSON, fileExists } from '../utils/index.js';
-import { exists, copyFile, deleteFile } from '../utils/fs-adapter.js';
+import { editorHasPath } from '../utils/fs-adapter.js';
 import { TemplateFileName } from '../index.js';
 import { FileName } from '../project-spec-types.js';
 import { legacyPath, getFFTestSuiteMap, MigrationError } from '../utils/common.js';
 import { ProjectAccess } from '../utils/Project.js';
+import { hasStore } from '../types/mem-fs-types.js';
 import { buildLegacyPaths, tryGitMove, fallbackFsMove, cleanupEmptyDirs } from './legacy-helpers.js';
 /**
  * Migrate project from legacy Fiori Elements folder structure (/src/main/webapp) to new structure (/webapp)
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information including current webapp path
  * @param rootPath - Root path of the project
  * @returns Object containing updated keepIndex flag and updated webapp path
  */
-export async function migrateLegacyFolderStructure(projectInfo, rootPath) {
+export async function migrateLegacyFolderStructure(fs, projectInfo, rootPath) {
     let keepIndex = false;
     // Check if project uses legacy folder structure
     if (!join(projectInfo.webappPath).includes(legacyPath)) {
         return { keepIndex, webappPath: projectInfo.webappPath };
     }
     const paths = buildLegacyPaths(rootPath, legacyPath);
-    if (!(await exists(paths.ffLegacyWebappPath))) {
+    if (!fileExists(fs, paths.ffLegacyWebappPath)) {
         return { keepIndex, webappPath: projectInfo.webappPath };
     }
     // Try to use git to move files (preserves history)
-    await tryGitMove(rootPath, paths);
+    await tryGitMove(fs, rootPath, paths);
     // Fallback using node fs to move folders (handles cases where git fails or isn't available)
     await fallbackFsMove(rootPath, paths);
     // Remove old src dirs if empty
     await cleanupEmptyDirs(rootPath, legacyPath, paths);
     // Update webapp path after migration
-    const updatedWebappPath = await ProjectAccess.getWebappPath(rootPath);
+    const updatedWebappPath = await ProjectAccess.getWebappPath(rootPath, undefined, undefined, fs);
     const ffTestMap = getFFTestSuiteMap(updatedWebappPath);
     // Process legacy qunit runner file
-    await processLegacyQunitRunner(paths.ffNewTestPath, ffTestMap);
+    processLegacyQunitRunner(fs, paths.ffNewTestPath, ffTestMap);
     // Update ModulePathForTests.js files
-    await updateModulePathForTests(paths.ffNewTestPath);
+    await updateModulePathForTests(fs, paths.ffNewTestPath);
     // Update paths in test files
-    if (await exists(paths.ffNewTestPath)) {
-        await updateTestFilePaths(paths.ffNewTestPath);
+    if (editorHasPath(fs, paths.ffNewTestPath)) {
+        updateTestFilePaths(fs, paths.ffNewTestPath);
     }
     // Update various config files
-    await Promise.all([updateGitignore(rootPath), updateNeoApp(rootPath), updateProjectJson(rootPath)]);
+    updateGitignore(fs, rootPath);
+    await Promise.all([updateNeoApp(fs, rootPath), updateProjectJson(fs, rootPath)]);
     // Check for mockserver in index.html
-    keepIndex = await checkForMockserver(rootPath, updatedWebappPath);
+    keepIndex = checkForMockserver(fs, rootPath, updatedWebappPath);
     return { keepIndex, webappPath: updatedWebappPath };
 }
 /**
  * Process legacy qunit runner file and generate new test suite
  *
+ * @param fs
  * @param ffNewTestPath
  * @param ffTestMap
  */
-async function processLegacyQunitRunner(ffNewTestPath, ffTestMap) {
+function processLegacyQunitRunner(fs, ffNewTestPath, ffTestMap) {
     const qunitRunner = 'qunit.runner.testsuite.html';
     const legacyRunner = join(ffNewTestPath, qunitRunner);
-    if (!(await fileExists(legacyRunner))) {
+    if (!fileExists(fs, legacyRunner)) {
         return;
     }
     let legacyRunnerContent = '';
     try {
-        legacyRunnerContent = readFile(legacyRunner);
+        legacyRunnerContent = readFile(fs, legacyRunner);
     }
     catch (e) {
         throw new MigrationError(e, qunitRunner);
@@ -98,36 +102,37 @@ async function processLegacyQunitRunner(ffNewTestPath, ffTestMap) {
     }
     // Handle testsuite.qunit.html file
     const testSuiteRunner = join(ffNewTestPath, TemplateFileName.TestsuiteQunitHtml);
-    if (!(await fileExists(testSuiteRunner))) {
-        updateFile(testSuiteRunner, legacyRunnerContent);
+    if (!fileExists(fs, testSuiteRunner)) {
+        updateFile(fs, testSuiteRunner, legacyRunnerContent);
         delete ffTestMap[TemplateFileName.TestsuiteQunitHtml];
     }
     else {
         // Rename using copy+delete pattern (mem-fs compatible)
         const oldTestSuite = join(ffNewTestPath, 'testsuite_old.qunit.html');
-        copyFile(testSuiteRunner, oldTestSuite);
-        deleteFile(testSuiteRunner);
+        fs.copy(testSuiteRunner, oldTestSuite);
+        fs.delete(testSuiteRunner);
         // Update references to testsuite.qunit.html
         if (legacyRunnerContent.includes('testsuite.qunit.html')) {
             legacyRunnerContent = legacyRunnerContent.replaceAll('testsuite.qunit.html', 'testsuite_old.qunit.html');
         }
-        updateFile(testSuiteRunner, legacyRunnerContent);
+        updateFile(fs, testSuiteRunner, legacyRunnerContent);
         delete ffTestMap[TemplateFileName.TestsuiteQunitHtml];
     }
 }
 /**
  * Update ModulePathForTests.js files to fix path calculations for new structure
  *
+ * @param fs
  * @param ffNewTestPath
  */
-async function updateModulePathForTests(ffNewTestPath) {
+async function updateModulePathForTests(fs, ffNewTestPath) {
     const { findAll } = await import('../utils/file-discovery.js');
     const moduleFilePath = [];
     await findAll(ffNewTestPath, TemplateFileName.ModulePathForTests, moduleFilePath, []);
     for (const path of moduleFilePath) {
         let moduleFileContent;
         try {
-            moduleFileContent = readFile(join(path, TemplateFileName.ModulePathForTests));
+            moduleFileContent = readFile(fs, join(path, TemplateFileName.ModulePathForTests));
         }
         catch (e) {
             throw new MigrationError(e, TemplateFileName.ModulePathForTests);
@@ -140,7 +145,7 @@ async function updateModulePathForTests(ffNewTestPath) {
             if (functionStart !== -1 && posReturn !== -1) {
                 const replaceContent = "\r\n\t\tvar number = window.location.href.indexOf(\"/webapp/test/\") !== -1 ? 3 : 1;\r\n\t\tvar iGoUp = URI(window.location.href).segment().length - number;\r\n\t\tvar sRel = '';\r\n\t\tfor (var i = 0; i < iGoUp; i++) {\r\n\t\t\tsRel += '../';\r\n\t\t}\r\n\t\t";
                 moduleFileContent = `${moduleFileContent.slice(0, functionStart + funcBracket.length)}${replaceContent}${moduleFileContent.slice(posReturn)}`;
-                updateFile(join(path, TemplateFileName.ModulePathForTests), moduleFileContent);
+                updateFile(fs, join(path, TemplateFileName.ModulePathForTests), moduleFileContent);
             }
         }
     }
@@ -148,75 +153,54 @@ async function updateModulePathForTests(ffNewTestPath) {
 /**
  * Update paths in test HTML files from legacy structure to new structure
  *
+ * @param fs
  * @param ffNewTestPath
  */
-async function updateTestFilePaths(ffNewTestPath) {
-    const { getCurrentEditor } = await import('../utils/fs-adapter.js');
-    const { hasStore } = await import('../types/mem-fs-types.js');
-    const { sep } = await import('node:path');
-    const editor = getCurrentEditor();
-    // Use mem-fs store.each() to iterate over files (works in mem-fs mode)
-    // hasStore is a type guard that narrows editor to EditorWithStore
-    if (editor && hasStore(editor)) {
-        const htmlFiles = [];
-        editor.store.each((file) => {
-            const filePath = file.path;
-            // Check if file is directly under ffNewTestPath (not nested) and ends with .html
-            if (filePath.startsWith(ffNewTestPath + sep) && filePath.endsWith('.html')) {
-                // Only include files directly in the test path (no further path separators after the base)
-                const relativePath = filePath.substring(ffNewTestPath.length + 1);
-                if (!relativePath.includes(sep)) {
-                    htmlFiles.push(filePath);
-                }
-            }
-        });
-        for (const filePath of htmlFiles) {
-            let content;
-            try {
-                content = readFile(filePath);
-            }
-            catch (e) {
-                throw new MigrationError(e, filePath);
-            }
-            content = content.replaceAll('../../main/webapp', '../../webapp');
-            content = content.replaceAll('/src/test/qunit', '/webapp/test');
-            content = content.replace('<script src="../../webapp/test-resources/sap/ushell/shells/sandbox/fioriSandboxConfig.js"></script>', '');
-            updateFile(filePath, content);
-        }
+function updateTestFilePaths(fs, ffNewTestPath) {
+    if (!hasStore(fs)) {
         return;
     }
-    // Fallback to fs.promises.readdir when not in mem-fs mode (e.g., direct disk operations)
-    const { readdir } = await import('node:fs/promises');
-    const htmlFiles = (await readdir(ffNewTestPath)).filter((file) => file.endsWith('.html'));
-    for (const file of htmlFiles) {
-        const filePath = join(ffNewTestPath, file);
+    const htmlFiles = [];
+    fs.store.each((file) => {
+        const filePath = file.path;
+        // Check if file is directly under ffNewTestPath (not nested) and ends with .html
+        if (filePath.startsWith(ffNewTestPath + sep) && filePath.endsWith('.html')) {
+            // Only include files directly in the test path (no further path separators after the base)
+            const relativePath = filePath.substring(ffNewTestPath.length + 1);
+            if (!relativePath.includes(sep)) {
+                htmlFiles.push(filePath);
+            }
+        }
+    });
+    for (const filePath of htmlFiles) {
         let content;
         try {
-            content = readFile(filePath);
+            content = readFile(fs, filePath);
         }
         catch (e) {
-            throw new MigrationError(e, file);
+            throw new MigrationError(e, filePath);
         }
         content = content.replaceAll('../../main/webapp', '../../webapp');
         content = content.replaceAll('/src/test/qunit', '/webapp/test');
         content = content.replace('<script src="../../webapp/test-resources/sap/ushell/shells/sandbox/fioriSandboxConfig.js"></script>', '');
-        updateFile(filePath, content);
+        updateFile(fs, filePath, content);
     }
 }
 /**
  * Update .gitignore to remove legacy path references
  *
+ * @param fs
  * @param rootPath
  */
-async function updateGitignore(rootPath) {
+function updateGitignore(fs, rootPath) {
     const gitignore = join(rootPath, '.gitignore');
-    if (!(await fileExists(gitignore))) {
+    if (!fileExists(fs, gitignore)) {
         return;
     }
     try {
-        let gitignoreContent = readFile(gitignore);
+        let gitignoreContent = readFile(fs, gitignore);
         gitignoreContent = gitignoreContent.replaceAll('/src/main', '');
-        updateFile(gitignore, gitignoreContent);
+        updateFile(fs, gitignore, gitignoreContent);
     }
     catch (e) {
         throw new MigrationError(e, '.gitignore');
@@ -227,15 +211,16 @@ async function updateGitignore(rootPath) {
  * Updates path properties structurally rather than via string replacement
  * to avoid corrupting other string-valued properties.
  *
+ * @param fs
  * @param rootPath
  */
-async function updateNeoApp(rootPath) {
+async function updateNeoApp(fs, rootPath) {
     const neoapp = join(rootPath, FileName.NeoApp);
-    if (!(await fileExists(neoapp))) {
+    if (!fileExists(fs, neoapp)) {
         return;
     }
     try {
-        const neoappContent = await readJSON(neoapp);
+        const neoappContent = await readJSON(fs, neoapp);
         if (Array.isArray(neoappContent.routes)) {
             neoappContent.routes = neoappContent.routes.map((route) => ({
                 ...route,
@@ -250,7 +235,7 @@ async function updateNeoApp(rootPath) {
                     : route.target
             }));
         }
-        updateJSON(neoapp, neoappContent);
+        updateJSON(fs, neoapp, neoappContent);
     }
     catch (e) {
         throw new MigrationError(e, FileName.NeoApp);
@@ -260,22 +245,23 @@ async function updateNeoApp(rootPath) {
  * Update .project.json (WEB IDE) to remove legacy path references.
  * Updates path properties structurally rather than via string replacement.
  *
+ * @param fs
  * @param rootPath
  */
-async function updateProjectJson(rootPath) {
+async function updateProjectJson(fs, rootPath) {
     const projectJson = join(rootPath, '.che', 'project.json');
-    if (!(await fileExists(projectJson))) {
+    if (!fileExists(fs, projectJson)) {
         return;
     }
     try {
-        const projectJsonContent = await readJSON(projectJson);
+        const projectJsonContent = await readJSON(fs, projectJson);
         if (projectJsonContent.contentRoot) {
             projectJsonContent.contentRoot = projectJsonContent.contentRoot.replace('src/main', '');
         }
         if (projectJsonContent.path) {
             projectJsonContent.path = projectJsonContent.path.replace('src/main', '');
         }
-        updateJSON(projectJson, projectJsonContent);
+        updateJSON(fs, projectJson, projectJsonContent);
     }
     catch (e) {
         throw new MigrationError(e, 'project.json');
@@ -285,17 +271,18 @@ async function updateProjectJson(rootPath) {
  * Check if index.html contains mockserver references
  * If it does, the file should be preserved and new index will be named index_new.html
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param webappPath - Updated webapp path
  * @returns true if mockserver found and index.html should be preserved
  */
-async function checkForMockserver(rootPath, webappPath) {
+function checkForMockserver(fs, rootPath, webappPath) {
     const indexPath = join(rootPath, webappPath, TemplateFileName.IndexHtml);
-    if (!(await fileExists(indexPath))) {
+    if (!fileExists(fs, indexPath)) {
         return false;
     }
     try {
-        const indexFile = readFile(indexPath);
+        const indexFile = readFile(fs, indexPath);
         // Check if mockserver is referenced (case-insensitive)
         if (indexFile.toLowerCase().includes('mockserver')) {
             // Found mockserver reference - mark that index.html should be renamed

package/dist/migration-process/migration-phases.d.ts

@@ -6,10 +6,12 @@
  */
 import type { ImportProjectInfo, Message, TemplateData, NeoappDestination } from '../types.js';
 import type { SapAppSourceTemplate } from '../project-spec-types.js';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Configuration for generating app settings phase
  */
 export interface GenerateAppSettingsConfig {
+    fs: Editor;
     rootPath: string;
     templateData: TemplateData;
     destination: string;
@@ -26,6 +28,7 @@ export interface GenerateAppSettingsConfig {
  * Configuration for applying all templates phase
  */
 export interface ApplyAllTemplatesConfig {
+    fs: Editor;
     projectInfo: ImportProjectInfo;
     rootPath: string;
     templateData: TemplateData;
@@ -41,6 +44,7 @@ export interface ApplyAllTemplatesConfig {
  * Configuration for post-processing migration phase
  */
 export interface PostProcessMigrationConfig {
+    fs: Editor;
     projectInfo: ImportProjectInfo;
     rootPath: string;
     manifestJSON: any;
@@ -57,11 +61,12 @@ export interface PostProcessMigrationConfig {
  * - Create extension project manifest
  * - Create webapp folder and migrate files
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param rootPath - Project root path
  * @returns Updated webapp path and keepIndex flag
  */
-export declare function setupProjectStructure(projectInfo: ImportProjectInfo, rootPath: string): Promise<{
+export declare function setupProjectStructure(fs: Editor, projectInfo: ImportProjectInfo, rootPath: string): Promise<{
     webappPath: string;
     keepIndex: boolean;
 }>;

package/dist/migration-process/migration-phases.js

@@ -18,21 +18,22 @@ import { generateAllUI5YamlFiles, updateManifestForMigration, generateLaunchConf
  * - Create extension project manifest
  * - Create webapp folder and migrate files
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param rootPath - Project root path
  * @returns Updated webapp path and keepIndex flag
  */
-export async function setupProjectStructure(projectInfo, rootPath) {
+export async function setupProjectStructure(fs, projectInfo, rootPath) {
     // Migrate from FF legacy folder structure (/src/main) if applicable
-    const { keepIndex, webappPath: updatedWebappPath } = await migrateLegacyFolderStructure(projectInfo, rootPath);
+    const { keepIndex, webappPath: updatedWebappPath } = await migrateLegacyFolderStructure(fs, projectInfo, rootPath);
     // Update projectInfo with the new webapp path if it changed
     if (updatedWebappPath !== projectInfo.webappPath) {
         projectInfo.webappPath = updatedWebappPath;
     }
     // Create extension project manifest if needed
-    await createExtensionProjectManifest(rootPath, projectInfo);
+    createExtensionProjectManifest(fs, rootPath, projectInfo);
     // Create webapp folder and migrate files if needed
-    await createWebappFolderAndMigrateFiles(rootPath, projectInfo);
+    await createWebappFolderAndMigrateFiles(fs, rootPath, projectInfo);
     // Return the final webapp path (which is now in projectInfo) and keepIndex
     return { webappPath: projectInfo.webappPath, keepIndex };
 }
@@ -44,13 +45,13 @@ export async function setupProjectStructure(projectInfo, rootPath) {
  * @param config - Configuration object containing all required parameters
  */
 export async function generateAppSettings(config) {
-    const { rootPath, templateData, destination, webappPath, messages, sourceTemplateType, hasDataSource, neoappDestinations, sourceTemplateTest, firstNeoAppDestination, strict = false } = config;
+    const { fs, rootPath, templateData, destination, webappPath, messages, sourceTemplateType, hasDataSource, neoappDestinations, sourceTemplateTest, firstNeoAppDestination, strict = false } = config;
     // Determine if UI5 version should be written to YAML files
     const setUI5version = (templateData.project.manifestUI5Version !== templateData.project.ui5Version &&
         !(templateData.project.ui5Version === '' && templateData.project.manifestUI5Version === distVar)) ||
         (!templateData.project.manifestUI5Version && templateData.project.ui5Version === '');
     // Generate all UI5 YAML files
-    await generateAllUI5YamlFiles({
+    await generateAllUI5YamlFiles(fs, {
         templateData,
         neoappDestinations,
         messages,
@@ -63,7 +64,16 @@ export async function generateAppSettings(config) {
         strict
     });
     // Update manifest.json
-    await updateManifestForMigration(rootPath, webappPath, templateData, sourceTemplateType, messages, sourceTemplateTest, strict);
+    await updateManifestForMigration({
+        fs,
+        rootPath,
+        webappPath,
+        templateData,
+        floorplan: sourceTemplateType,
+        messages,
+        sourceTemplateTest,
+        strict
+    });
 }
 /**
  * Phase 3: Apply all templates
@@ -75,11 +85,12 @@ export async function generateAppSettings(config) {
  * @param config - Configuration object containing all required parameters
  */
 export async function applyAllTemplates(config) {
-    const { projectInfo, rootPath, templateData, hasDataSource, finalKeepIndex, internalToggle, ui5Version, isSAPApp, appIntent, appMockIntent } = config;
+    const { fs, projectInfo, rootPath, templateData, hasDataSource, finalKeepIndex, internalToggle, ui5Version, isSAPApp, appIntent, appMockIntent } = config;
     // Setup env i.e. create necessary directories, if they don't already exist
-    await setupMigrationDirectories(projectInfo, rootPath, hasDataSource);
+    await setupMigrationDirectories(fs, projectInfo, rootPath, hasDataSource);
     // Apply base application templates
     await applyBaseTemplates({
+        fs,
         projectInfo,
         templateData,
         rootPath,
@@ -90,6 +101,7 @@ export async function applyAllTemplates(config) {
     });
     // Apply specific application templates
     await applyApplicationTemplates({
+        fs,
         projectInfo,
         templateData,
         rootPath,
@@ -102,7 +114,7 @@ export async function applyAllTemplates(config) {
         FioriElementsVersionEnum: FioriElementsVersion
     });
     // Remove package-lock if exists
-    await removePackageLock(projectInfo.rootPath);
+    removePackageLock(fs, projectInfo.rootPath);
 }
 /**
  * Phase 4: Post-processing
@@ -112,16 +124,16 @@ export async function applyAllTemplates(config) {
  * @param config - Configuration object containing all required parameters
  */
 export async function postProcessMigration(config) {
-    const { projectInfo, rootPath, manifestJSON, vscode, appIntent, appMockIntent, flpSandboxAvailable, messages, strict = false } = config;
+    const { fs, projectInfo, rootPath, manifestJSON, vscode, appIntent, appMockIntent, flpSandboxAvailable, messages, strict = false } = config;
     // Validate metadata and add warning if missing
-    await validateAndReportMetadata(rootPath, projectInfo, manifestJSON, messages, strict);
+    await validateAndReportMetadata(fs, rootPath, projectInfo, manifestJSON, messages, strict);
     if (projectInfo.type !== MigrationTypes.projectExtension) {
         // Generate Launch Config using @sap-ux/launch-config
-        await generateLaunchConfiguration(projectInfo, vscode, appIntent, appMockIntent, flpSandboxAvailable, messages);
+        await generateLaunchConfiguration(fs, projectInfo, vscode, appIntent, appMockIntent, flpSandboxAvailable);
     }
     else {
         // Handle extension project configuration
-        await handleExtensionProjectConfig(rootPath, projectInfo);
+        handleExtensionProjectConfig(fs, rootPath, projectInfo);
     }
 }
 //# sourceMappingURL=migration-phases.js.map

package/dist/migration-process/setup.d.ts

@@ -1,20 +1,23 @@
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo } from '../types.js';
 /**
  * Sets up necessary directories for migration
- * Note: mem-fs handles directory creation implicitly when files are written
+ * Creates localService directory if data source exists, and test directory if webapp exists
  *
- * @param _projectInfo - Project information (unused - kept for API compatibility)
- * @param _rootPath - Root path of the project (unused - kept for API compatibility)
- * @param _hasDataSource - Whether project has a data source (unused - kept for API compatibility)
+ * @param fs - mem-fs editor
+ * @param projectInfo - Project information
+ * @param rootPath - Root path of the project
+ * @param hasDataSource - Whether project has a data source
  */
-export declare function setupMigrationDirectories(_projectInfo: ImportProjectInfo, _rootPath: string, _hasDataSource: boolean): Promise<void>;
+export declare function setupMigrationDirectories(fs: Editor, projectInfo: ImportProjectInfo, rootPath: string, hasDataSource: boolean): Promise<void>;
 /**
  * Removes package-lock.json if it exists
  * Package-lock is regenerated during installation
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  */
-export declare function removePackageLock(rootPath: string): Promise<void>;
+export declare function removePackageLock(fs: Editor, rootPath: string): void;
 /**
  * Determines the source template type for manifest.json
  *

package/dist/migration-process/setup.js

@@ -1,28 +1,37 @@
 import { join } from 'node:path';
 import { fileExists, deleteFile } from '../utils/index.js';
+import { createDirectory, doesDirectoryExists } from '../utils/file-system-utils.js';
+import { DirName } from '../project-spec-types.js';
 /**
  * Sets up necessary directories for migration
- * Note: mem-fs handles directory creation implicitly when files are written
+ * Creates localService directory if data source exists, and test directory if webapp exists
  *
- * @param _projectInfo - Project information (unused - kept for API compatibility)
- * @param _rootPath - Root path of the project (unused - kept for API compatibility)
- * @param _hasDataSource - Whether project has a data source (unused - kept for API compatibility)
+ * @param fs - mem-fs editor
+ * @param projectInfo - Project information
+ * @param rootPath - Root path of the project
+ * @param hasDataSource - Whether project has a data source
  */
-export async function setupMigrationDirectories(_projectInfo, _rootPath, _hasDataSource) {
-    // mem-fs handles directory creation implicitly when files are written to paths
-    // No explicit directory creation needed
+export async function setupMigrationDirectories(fs, projectInfo, rootPath, hasDataSource) {
+    if (hasDataSource) {
+        await createDirectory(join(rootPath, projectInfo.webappPath, DirName.LocalService), fs);
+    }
+    const webAppPath = join(rootPath, projectInfo.webappPath);
+    if (doesDirectoryExists(webAppPath, fs)) {
+        await createDirectory(join(rootPath, projectInfo.webappPath, DirName.Test), fs);
+    }
 }
 /**
  * Removes package-lock.json if it exists
  * Package-lock is regenerated during installation
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  */
-export async function removePackageLock(rootPath) {
+export function removePackageLock(fs, rootPath) {
     try {
         const packageLockPath = join(rootPath, 'package-lock.json');
-        if (await fileExists(packageLockPath)) {
-            deleteFile(packageLockPath);
+        if (fileExists(fs, packageLockPath)) {
+            deleteFile(fs, packageLockPath);
         }
     }
     catch (error) {

package/dist/migration-process/validation.d.ts

@@ -1,21 +1,24 @@
 import type { Message, ImportProjectInfo } from '../types.js';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Validates metadata configuration and adds warning/error message if missing
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information
  * @param manifestJSON - Manifest JSON object
  * @param messages - Array to collect validation messages
  * @param strict - Enable strict validation mode (WARNING becomes ERROR)
  */
-export declare function validateAndReportMetadata(rootPath: string, projectInfo: ImportProjectInfo, manifestJSON: any, messages: Message[], strict?: boolean): Promise<void>;
+export declare function validateAndReportMetadata(fs: Editor, rootPath: string, projectInfo: ImportProjectInfo, manifestJSON: any, messages: Message[], strict?: boolean): void;
 /**
  * Handles extension project configuration update
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information
  */
-export declare function handleExtensionProjectConfig(rootPath: string, projectInfo: ImportProjectInfo): Promise<void>;
+export declare function handleExtensionProjectConfig(fs: Editor, rootPath: string, projectInfo: ImportProjectInfo): void;
 /**
  * Checks if any error messages exist in the messages array
  *

package/dist/migration-process/validation.js

@@ -6,14 +6,15 @@ import { getMessageType } from '../utils/validation-severity.js';
 /**
  * Validates metadata configuration and adds warning/error message if missing
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information
  * @param manifestJSON - Manifest JSON object
  * @param messages - Array to collect validation messages
  * @param strict - Enable strict validation mode (WARNING becomes ERROR)
  */
-export async function validateAndReportMetadata(rootPath, projectInfo, manifestJSON, messages, strict = false) {
-    const metadataValidation = await validateMetadata(rootPath, projectInfo.webappPath, projectInfo.isSAPApp, manifestJSON);
+export function validateAndReportMetadata(fs, rootPath, projectInfo, manifestJSON, messages, strict = false) {
+    const metadataValidation = validateMetadata(rootPath, projectInfo.webappPath, projectInfo.isSAPApp, manifestJSON, fs);
     if (!(metadataValidation.config && metadataValidation.fileExists) &&
         projectInfo.type !== MigrationTypes.projectExtension) {
         messages.push({
@@ -26,12 +27,13 @@ export async function validateAndReportMetadata(rootPath, projectInfo, manifestJ
 /**
  * Handles extension project configuration update
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Root path of the project
  * @param projectInfo - Project information
  */
-export async function handleExtensionProjectConfig(rootPath, projectInfo) {
+export function handleExtensionProjectConfig(fs, rootPath, projectInfo) {
     if (projectInfo.type === MigrationTypes.projectExtension && projectInfo.extensionProjectSettings) {
-        await updateExtConfigJson(rootPath, projectInfo);
+        updateExtConfigJson(fs, rootPath, projectInfo);
     }
 }
 /**

package/dist/migration-types.d.ts

@@ -2,6 +2,7 @@ import type { FioriElementsVersion, SapAppSourceTemplate, Manifest } from './pro
 import type { MigrationTypes, postMigrationAction } from './utils/constants.js';
 import type { CdsUi5PluginInfo } from '@sap-ux/project-access';
 import type { Annotations } from '@sap-ux/axios-extension';
+import type { Editor } from 'mem-fs-editor';
 export type { ProjectFolder } from './types/project-folder.js';
 export { isProjectFolderArray } from './types/project-folder.js';
 /**
@@ -496,6 +497,7 @@ export interface TemplateModuleInfo {
  * Context for assembleTemplateData function
  */
 export interface TemplateAssemblyContext {
+    fs: Editor;
     projectInfo: ImportProjectInfo;
     rootPath: string;
     projectData: any;
@@ -511,7 +513,7 @@ export interface TemplateAssemblyContext {
  * Service for project data operations (package.json, entities, UI5 tooling)
  */
 export interface ProjectDataService {
-    getPackageJson: (projectRoot: string) => Promise<any>;
+    getPackageJson: (projectRoot: string) => any;
     getMainEntity: (manifest: Manifest) => string;
     hasUI5Tooling: (packageJson: any) => boolean;
 }
@@ -533,7 +535,7 @@ export interface BackendConfigService {
         scp?: boolean;
         sapClient?: string;
     };
-    getFlpIntentFromHtml: (path: string) => Promise<string | undefined>;
+    getFlpIntentFromHtml: (path: string) => string | undefined;
     getDestinationFromNeoApp: (projectRoot: string, destination: string) => Promise<{
         destination?: string;
         neoAppUI5Version?: string;
@@ -545,6 +547,7 @@ export interface BackendConfigService {
  * Context for processRegularProject function
  */
 export interface RegularProjectContext {
+    fs: Editor;
     projectRoot: string;
     manifest: Manifest;
     defaultProjectInfo: ImportProjectInfo;