@sap-ux/project-access 1.28.9 → 1.29.0

package/dist/project/access.js

@@ -275,12 +275,12 @@ async function createApplicationAccess(appRoot, fs) {
         if (!app) {
             throw new Error(`Could not find app with root ${appRoot}`);
         }
-        const project = await (0, info_1.getProject)(app.projectRoot);
-        const appId = (0, path_1.relative)(project.root, appRoot);
         let options;
         if (fs) {
             options = isEditor(fs) ? { fs } : fs;
         }
+        const project = await (0, info_1.getProject)(app.projectRoot, options?.fs);
+        const appId = (0, path_1.relative)(project.root, appRoot);
         return new ApplicationAccessImp(project, appId, options);
     }
     catch (error) {
@@ -296,7 +296,7 @@ async function createApplicationAccess(appRoot, fs) {
  */
 async function createProjectAccess(root, options) {
     try {
-        const project = await (0, info_1.getProject)(root);
+        const project = await (0, info_1.getProject)(root, options?.memFs);
         const projectAccess = new ProjectAccessImp(project, options);
         return projectAccess;
     }

package/dist/project/cap.d.ts

@@ -13,16 +13,18 @@ export declare function isCapNodeJsProject(packageJson: Package): boolean;
  *
  * @param projectRoot - the root path of the project
  * @param [capCustomPaths] - optional, relative CAP paths like app, db, srv
+ * @param memFs - optional mem-fs-editor instance
  * @returns - true if the project is a CAP project
  */
-export declare function isCapJavaProject(projectRoot: string, capCustomPaths?: CapCustomPaths): Promise<boolean>;
+export declare function isCapJavaProject(projectRoot: string, capCustomPaths?: CapCustomPaths, memFs?: Editor): Promise<boolean>;
 /**
  * Returns the CAP project type, undefined if it is not a CAP project.
  *
  * @param projectRoot - root of the project, where the package.json resides.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - CAPJava for Java based CAP projects; CAPNodejs for node.js based CAP projects; undefined if it is no CAP project
  */
-export declare function getCapProjectType(projectRoot: string): Promise<CapProjectType | undefined>;
+export declare function getCapProjectType(projectRoot: string, memFs?: Editor): Promise<CapProjectType | undefined>;
 /**
  * Returns true if the project is either a CAP Node.js or a CAP Java project.
  *

package/dist/project/cap.js

@@ -36,29 +36,64 @@ function isCapNodeJsProject(packageJson) {
  *
  * @param projectRoot - the root path of the project
  * @param [capCustomPaths] - optional, relative CAP paths like app, db, srv
+ * @param memFs - optional mem-fs-editor instance
  * @returns - true if the project is a CAP project
  */
-async function isCapJavaProject(projectRoot, capCustomPaths) {
+async function isCapJavaProject(projectRoot, capCustomPaths, memFs) {
     const srv = capCustomPaths?.srv ?? (await getCapCustomPaths(projectRoot)).srv;
-    return (0, file_1.fileExists)((0, path_1.join)(projectRoot, srv, 'src', 'main', 'resources', constants_1.FileName.CapJavaApplicationYaml));
+    return (0, file_1.fileExists)((0, path_1.join)(projectRoot, srv, 'src', 'main', 'resources', constants_1.FileName.CapJavaApplicationYaml), memFs);
+}
+/**
+ * Checks if there are files in the `srv` folder, using node fs or mem-fs.
+ *
+ * @param {string} srvFolderPath - The path to the `srv` folder to check for files.
+ * @param {Editor} [memFs] - An optional `mem-fs-editor` instance. If provided, the function checks files within the in-memory file system.
+ * @returns {Promise<boolean>} - Resolves to `true` if files are found in the `srv` folder; otherwise, `false`.
+ */
+async function checkFilesInSrvFolder(srvFolderPath, memFs) {
+    if (!memFs) {
+        return await (0, file_1.fileExists)(srvFolderPath);
+    }
+    // Load the srv folder and its files into mem-fs
+    // This is necessary as mem-fs operates in-memory and doesn't automatically include files from disk.
+    // By loading the files, we ensure they are available within mem-fs.
+    if (await (0, file_1.fileExists)(srvFolderPath)) {
+        const fileSystemFiles = await (0, file_1.readDirectory)(srvFolderPath);
+        for (const file of fileSystemFiles) {
+            const filePath = (0, path_1.join)(srvFolderPath, file);
+            if (await (0, file_1.fileExists)(filePath)) {
+                const fileContent = await (0, file_1.readFile)(filePath);
+                memFs.write(filePath, fileContent);
+            }
+        }
+    }
+    // Dump the mem-fs state
+    const memFsDump = memFs.dump();
+    const memFsFiles = Object.keys(memFsDump).filter((filePath) => {
+        const normalisedFilePath = (0, path_1.resolve)(filePath);
+        const normalisedSrvPath = (0, path_1.resolve)(srvFolderPath);
+        return normalisedFilePath.startsWith(normalisedSrvPath);
+    });
+    return memFsFiles.length > 0;
 }
 /**
  * Returns the CAP project type, undefined if it is not a CAP project.
  *
  * @param projectRoot - root of the project, where the package.json resides.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - CAPJava for Java based CAP projects; CAPNodejs for node.js based CAP projects; undefined if it is no CAP project
  */
-async function getCapProjectType(projectRoot) {
+async function getCapProjectType(projectRoot, memFs) {
     const capCustomPaths = await getCapCustomPaths(projectRoot);
-    if (!(await (0, file_1.fileExists)((0, path_1.join)(projectRoot, capCustomPaths.srv)))) {
+    if (!(await checkFilesInSrvFolder((0, path_1.join)(projectRoot, capCustomPaths.srv), memFs))) {
         return undefined;
     }
-    if (await isCapJavaProject(projectRoot, capCustomPaths)) {
+    if (await isCapJavaProject(projectRoot, capCustomPaths, memFs)) {
         return 'CAPJava';
     }
     let packageJson;
     try {
-        packageJson = await (0, file_1.readJSON)((0, path_1.join)(projectRoot, constants_1.FileName.Package));
+        packageJson = await (0, file_1.readJSON)((0, path_1.join)(projectRoot, constants_1.FileName.Package), memFs);
     }
     catch {
         // Ignore errors while reading the package.json file

package/dist/project/i18n/i18n.d.ts

@@ -1,12 +1,14 @@
 import type { I18nPropertiesPaths, Manifest } from '../../types';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Return absolute paths to i18n.properties files from manifest.
  *
  * @param manifestPath - path to manifest.json; used to parse manifest.json if not provided as second argument and to resolve absolute paths
  * @param manifest - optionally, parsed content of manifest.json, pass to avoid reading it again.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - absolute paths to i18n.properties
  */
-export declare function getI18nPropertiesPaths(manifestPath: string, manifest?: Manifest): Promise<I18nPropertiesPaths>;
+export declare function getI18nPropertiesPaths(manifestPath: string, manifest?: Manifest, memFs?: Editor): Promise<I18nPropertiesPaths>;
 /**
  * Return paths to i18n.properties files from manifest,
  * relative to the manifest.json.

package/dist/project/i18n/i18n.js

@@ -9,10 +9,11 @@ const file_1 = require("../../file");
  *
  * @param manifestPath - path to manifest.json; used to parse manifest.json if not provided as second argument and to resolve absolute paths
  * @param manifest - optionally, parsed content of manifest.json, pass to avoid reading it again.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - absolute paths to i18n.properties
  */
-async function getI18nPropertiesPaths(manifestPath, manifest) {
-    const parsedManifest = manifest ?? (await (0, file_1.readJSON)(manifestPath));
+async function getI18nPropertiesPaths(manifestPath, manifest, memFs) {
+    const parsedManifest = manifest ?? (await (0, file_1.readJSON)(manifestPath, memFs));
     const manifestFolder = (0, path_1.dirname)(manifestPath);
     const relativeI18nPropertiesPaths = getRelativeI18nPropertiesPaths(parsedManifest);
     const i18nPropertiesPaths = {

package/dist/project/info.d.ts

@@ -4,9 +4,10 @@ import type { AppProgrammingLanguage, AppType, Manifest, Project, ProjectType }
  * Returns the project structure for a given Fiori project.
  *
  * @param root - project root folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - project structure with project info like project type, apps, root folder
  */
-export declare function getProject(root: string): Promise<Project>;
+export declare function getProject(root: string, memFs?: Editor): Promise<Project>;
 /**
  * Get the used programming language of an application.
  *
@@ -19,9 +20,10 @@ export declare function getAppProgrammingLanguage(appRoot: string, memFs?: Edito
  * Get the type of application or Fiori artifact.
  *
  * @param appRoot - path to application root
+ * @param memFs - optional mem-fs-editor instance
  * @returns - type of application, e.g. SAP Fiori elements, SAPUI5 freestyle, SAPUI5 Extension, ... see AppType.
  */
-export declare function getAppType(appRoot: string): Promise<AppType | undefined>;
+export declare function getAppType(appRoot: string, memFs?: Editor): Promise<AppType | undefined>;
 /**
  * Returns the project type for a given Fiori project.
  *

package/dist/project/info.js

@@ -20,16 +20,17 @@ const semver_1 = require("semver");
  * Returns the project structure for a given Fiori project.
  *
  * @param root - project root folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - project structure with project info like project type, apps, root folder
  */
-async function getProject(root) {
-    if (!(await (0, file_1.fileExists)((0, path_1.join)(root, constants_1.FileName.Package)))) {
+async function getProject(root, memFs) {
+    if (!(await (0, file_1.fileExists)((0, path_1.join)(root, constants_1.FileName.Package), memFs))) {
         throw new Error(`The project root folder '${root}' is not a Fiori project. No 'package.json' found.`);
     }
     const capProjectType = await (0, cap_1.getCapProjectType)(root);
     const projectType = capProjectType ?? 'EDMXBackend';
-    const appFolders = await getAppFolders(root);
-    const apps = await getApps(root, appFolders);
+    const appFolders = await getAppFolders(root, memFs);
+    const apps = await getApps(root, appFolders, memFs);
     return {
         root,
         projectType,
@@ -42,10 +43,11 @@ async function getProject(root) {
  * array of operating system specific relative paths to the apps.
  *
  * @param root - project root folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - array of operating specific application folders
  */
-async function getAppFolders(root) {
-    const apps = await (0, search_1.findAllApps)([root]);
+async function getAppFolders(root, memFs) {
+    const apps = await (0, search_1.findAllApps)([root], memFs);
     return apps.length > 0 ? apps.map((app) => (0, path_1.relative)(root, app.appRoot)) : [''];
 }
 /**
@@ -53,12 +55,13 @@ async function getAppFolders(root) {
  *
  * @param root - project root folder
  * @param appFolders - array of relative application folders
+ * @param memFs - optional mem-fs-editor instance
  * @returns - map of application structures
  */
-async function getApps(root, appFolders) {
+async function getApps(root, appFolders, memFs) {
     const apps = {};
     for (const appFolder of appFolders) {
-        const applicationStructure = await getApplicationStructure(root, appFolder);
+        const applicationStructure = await getApplicationStructure(root, appFolder, memFs);
         if (applicationStructure) {
             apps[appFolder] = applicationStructure;
         }
@@ -70,21 +73,22 @@ async function getApps(root, appFolders) {
  *
  * @param root - project root folder
  * @param appFolder - relative application folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - application structure with application info like manifest, changes, main service, services, annotations
  */
-async function getApplicationStructure(root, appFolder) {
+async function getApplicationStructure(root, appFolder, memFs) {
     const appRoot = (0, path_1.join)(root, appFolder);
-    const absoluteWebappPath = await (0, ui5_config_1.getWebappPath)(appRoot);
-    const appType = (await getAppType(appRoot));
+    const absoluteWebappPath = await (0, ui5_config_1.getWebappPath)(appRoot, memFs);
+    const appType = (await getAppType(appRoot, memFs));
     const manifest = (0, path_1.join)(absoluteWebappPath, constants_1.FileName.Manifest);
-    if (!(await (0, file_1.fileExists)(manifest))) {
+    if (!(await (0, file_1.fileExists)(manifest, memFs))) {
         return undefined;
     }
-    const manifestObject = await (0, file_1.readJSON)(manifest);
+    const manifestObject = await (0, file_1.readJSON)(manifest, memFs);
     const changes = (0, path_1.join)(absoluteWebappPath, constants_1.DirName.Changes);
-    const i18n = await (0, i18n_1.getI18nPropertiesPaths)(manifest, manifestObject);
+    const i18n = await (0, i18n_1.getI18nPropertiesPaths)(manifest, manifestObject, memFs);
     const mainService = (0, service_1.getMainService)(manifestObject);
-    const services = await (0, service_1.getServicesAndAnnotations)(manifest, manifestObject);
+    const services = await (0, service_1.getServicesAndAnnotations)(manifest, manifestObject, memFs);
     return {
         appRoot,
         appType,
@@ -126,14 +130,16 @@ async function getAppProgrammingLanguage(appRoot, memFs) {
  * Get the type of application or Fiori artifact.
  *
  * @param appRoot - path to application root
+ * @param memFs - optional mem-fs-editor instance
  * @returns - type of application, e.g. SAP Fiori elements, SAPUI5 freestyle, SAPUI5 Extension, ... see AppType.
  */
-async function getAppType(appRoot) {
+async function getAppType(appRoot, memFs) {
     let appType;
     try {
         const artifacts = await (0, search_1.findFioriArtifacts)({
             wsFolders: [appRoot],
-            artifacts: ['adaptations', 'applications', 'extensions', 'libraries']
+            artifacts: ['adaptations', 'applications', 'extensions', 'libraries'],
+            memFs
         });
         if ((artifacts.applications?.length ?? 0) +
             (artifacts.adaptations?.length ?? 0) +
@@ -141,7 +147,7 @@ async function getAppType(appRoot) {
             (artifacts.libraries?.length ?? 0) ===
             1) {
             if (artifacts.applications?.length === 1) {
-                appType = await getApplicationType(artifacts.applications[0]);
+                appType = await getApplicationType(artifacts.applications[0], memFs);
             }
             else if (artifacts.adaptations?.length === 1) {
                 appType = 'Fiori Adaptation';
@@ -163,12 +169,15 @@ async function getAppType(appRoot) {
  * Get the application type from search results.
  *
  * @param application - application from findFioriArtifacts() results
+ * @param memFs - optional mem-fs-editor instance
  * @returns - type of application: 'SAP Fiori elements' or 'SAPUI5 freestyle'
  */
-async function getApplicationType(application) {
+async function getApplicationType(application, memFs) {
     let appType;
     const rootPackageJsonPath = (0, path_1.join)(application.projectRoot, constants_1.FileName.Package);
-    const packageJson = (await (0, file_1.fileExists)(rootPackageJsonPath)) ? await (0, file_1.readJSON)(rootPackageJsonPath) : null;
+    const packageJson = (await (0, file_1.fileExists)(rootPackageJsonPath, memFs))
+        ? await (0, file_1.readJSON)(rootPackageJsonPath, memFs)
+        : null;
     if (application.projectRoot === application.appRoot) {
         appType = packageJson?.sapux ? 'SAP Fiori elements' : 'SAPUI5 freestyle';
     }

package/dist/project/module-loader.js

@@ -88,8 +88,10 @@ async function getModule(module, version, options) {
             await (0, promises_1.rm)(moduleDirectory, { recursive: true });
         }
         await (0, promises_1.mkdir)(moduleDirectory, { recursive: true });
-        await (0, promises_1.writeFile)(modulePackagePath, '{}');
-        await (0, command_1.execNpmCommand)(['install', `${module}@${version}`], { cwd: moduleDirectory, logger });
+        await (0, command_1.execNpmCommand)(['install', '--prefix', moduleDirectory, `${module}@${version}`], {
+            cwd: moduleDirectory,
+            logger
+        });
     }
     return loadModuleFromProject(moduleDirectory, module);
 }

package/dist/project/search.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 import type { AllAppResults, FioriArtifactTypes, FoundFioriArtifacts, WorkspaceFolder } from '../types';
 /**
  * Find root folder of the project containing the given file.
@@ -5,9 +6,10 @@ import type { AllAppResults, FioriArtifactTypes, FoundFioriArtifacts, WorkspaceF
  * @param path path of a project file
  * @param sapuxRequired if true, only find sapux projects
  * @param silent if true, then does not throw an error but returns an empty path
+ * @param memFs - optional mem-fs-editor instance
  * @returns {*}  {Promise<string>} - Project Root
  */
-export declare function findProjectRoot(path: string, sapuxRequired?: boolean, silent?: boolean): Promise<string>;
+export declare function findProjectRoot(path: string, sapuxRequired?: boolean, silent?: boolean, memFs?: Editor): Promise<string>;
 /**
  * Get the application root for a given webapp path.
  *
@@ -28,9 +30,10 @@ export declare function getAppRootFromWebappPath(webappPath: string): Promise<st
  * - Freestyle application (non CAP) has in package.json dependency to @sap/ux-ui5-tooling and <appRoot>/ui5-local.yaml.
  *
  * @param path - path to check, e.g. to the manifest.json
+ * @param memFs - optional mem-fs-editor instance
  * @returns - in case a supported app is found this function returns the appRoot and projectRoot path
  */
-export declare function findRootsForPath(path: string): Promise<{
+export declare function findRootsForPath(path: string, memFs?: Editor): Promise<{
     appRoot: string;
     projectRoot: string;
 } | null>;
@@ -39,29 +42,33 @@ export declare function findRootsForPath(path: string): Promise<{
  *
  * @param path - path inside CAP project
  * @param checkForAppRouter - if true, checks for app router in CAP project app folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - CAP project root path
  */
-export declare function findCapProjectRoot(path: string, checkForAppRouter?: boolean): Promise<string | null>;
+export declare function findCapProjectRoot(path: string, checkForAppRouter?: boolean, memFs?: Editor): Promise<string | null>;
 /**
  * Find all app that are supported by Fiori tools for a given list of roots (workspace folders).
  * This is a convenient function to retrieve all apps. Same result can be achieved with call
  * findFioriArtifacts({ wsFolders, artifacts: ['applications'] }); from same module.
  *
  * @param wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as path to apps plus files already parsed, e.g. manifest.json
  */
-export declare function findAllApps(wsFolders: readonly WorkspaceFolder[] | string[] | undefined): Promise<AllAppResults[]>;
+export declare function findAllApps(wsFolders: readonly WorkspaceFolder[] | string[] | undefined, memFs?: Editor): Promise<AllAppResults[]>;
 /**
  * Find all requested Fiori artifacts like apps, adaptations, extensions, that are supported by Fiori tools, for a given list of roots (workspace folders).
  *
  * @param options - find options
  * @param options.wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
  * @param options.artifacts - list of artifacts to search for: 'application', 'adaptation', 'extension' see FioriArtifactTypes
+ * @param options.memFs
  * @returns - data structure containing the search results, for app e.g. as path to app plus files already parsed, e.g. manifest.json
  */
 export declare function findFioriArtifacts(options: {
     wsFolders?: readonly WorkspaceFolder[] | string[];
     artifacts: FioriArtifactTypes[];
+    memFs?: Editor;
 }): Promise<FoundFioriArtifacts>;
 /**
  * Find all CAP project roots by locating pom.xml or package.json in a given workspace.

package/dist/project/search.js

@@ -66,10 +66,11 @@ function wsFoldersToRootPaths(wsFolders) {
  * @param path path of a project file
  * @param sapuxRequired if true, only find sapux projects
  * @param silent if true, then does not throw an error but returns an empty path
+ * @param memFs - optional mem-fs-editor instance
  * @returns {*}  {Promise<string>} - Project Root
  */
-async function findProjectRoot(path, sapuxRequired = true, silent = false) {
-    const packageJson = await (0, file_1.findFileUp)(constants_1.FileName.Package, path);
+async function findProjectRoot(path, sapuxRequired = true, silent = false, memFs) {
+    const packageJson = await (0, file_1.findFileUp)(constants_1.FileName.Package, path, memFs);
     if (!packageJson) {
         if (silent) {
             return '';
@@ -78,9 +79,9 @@ async function findProjectRoot(path, sapuxRequired = true, silent = false) {
     }
     let root = (0, path_1.dirname)(packageJson);
     if (sapuxRequired) {
-        const sapux = (await (0, file_1.readJSON)(packageJson)).sapux;
+        const sapux = (await (0, file_1.readJSON)(packageJson, memFs)).sapux;
         if (!sapux) {
-            root = await findProjectRoot((0, path_1.dirname)(root), sapuxRequired, silent);
+            root = await findProjectRoot((0, path_1.dirname)(root), sapuxRequired, silent, memFs);
         }
     }
     return root;
@@ -147,27 +148,28 @@ async function getAppRootFromWebappPath(webappPath) {
  * - Freestyle application (non CAP) has in package.json dependency to @sap/ux-ui5-tooling and <appRoot>/ui5-local.yaml.
  *
  * @param path - path to check, e.g. to the manifest.json
+ * @param memFs - optional mem-fs-editor instance
  * @returns - in case a supported app is found this function returns the appRoot and projectRoot path
  */
-async function findRootsForPath(path) {
+async function findRootsForPath(path, memFs) {
     try {
         // Get the root of the app, that is where the package.json is, otherwise not supported
-        const appRoot = await findProjectRoot(path, false);
+        const appRoot = await findProjectRoot(path, false, false, memFs);
         if (!appRoot) {
             return null;
         }
-        const appPckJson = await (0, file_1.readJSON)((0, path_1.join)(appRoot, constants_1.FileName.Package));
+        const appPckJson = await (0, file_1.readJSON)((0, path_1.join)(appRoot, constants_1.FileName.Package), memFs);
         // Check for most common app, Fiori elements with sapux=true in package.json
         if (appPckJson.sapux) {
             return findRootsWithSapux(appPckJson.sapux, path, appRoot);
         }
-        if ((await (0, cap_1.getCapProjectType)(appRoot)) !== undefined) {
+        if ((await (0, cap_1.getCapProjectType)(appRoot, memFs)) !== undefined) {
             // App is part of a CAP project, but doesn't have own package.json and is not mentioned in sapux array
             // in root -> not supported
             return null;
         }
         // Check if app is included in CAP project
-        const projectRoot = await findCapProjectRoot(appRoot);
+        const projectRoot = await findCapProjectRoot(appRoot, undefined, memFs);
         if (projectRoot) {
             // App included in CAP
             return {
@@ -177,7 +179,7 @@ async function findRootsForPath(path) {
         }
         else if (
         // Check for freestyle non CAP
-        (await (0, file_1.fileExists)((0, path_1.join)(appRoot, constants_1.FileName.Ui5LocalYaml))) &&
+        (await (0, file_1.fileExists)((0, path_1.join)(appRoot, constants_1.FileName.Ui5LocalYaml), memFs)) &&
             (0, dependencies_1.hasDependency)(appPckJson, '@sap/ux-ui5-tooling')) {
             return {
                 appRoot,
@@ -195,9 +197,10 @@ async function findRootsForPath(path) {
  *
  * @param path - path inside CAP project
  * @param checkForAppRouter - if true, checks for app router in CAP project app folder
+ * @param memFs - optional mem-fs-editor instance
  * @returns - CAP project root path
  */
-async function findCapProjectRoot(path, checkForAppRouter = true) {
+async function findCapProjectRoot(path, checkForAppRouter = true, memFs) {
     try {
         if (!(0, path_1.isAbsolute)(path)) {
             return null;
@@ -205,7 +208,7 @@ async function findCapProjectRoot(path, checkForAppRouter = true) {
         const { root } = (0, path_1.parse)(path);
         let projectRoot = (0, path_1.dirname)(path);
         while (projectRoot !== root) {
-            if (await (0, cap_1.getCapProjectType)(projectRoot)) {
+            if (await (0, cap_1.getCapProjectType)(projectRoot, memFs)) {
                 // We have found a CAP project as root. Check if the found app is not directly in CAP's 'app/' folder.
                 // Sometime there is a <CAP_ROOT>/app/package.json file that is used for app router (not an app)
                 // or skip app router check if checkForAppRouter is false and return the project root.
@@ -227,26 +230,28 @@ async function findCapProjectRoot(path, checkForAppRouter = true) {
  * findFioriArtifacts({ wsFolders, artifacts: ['applications'] }); from same module.
  *
  * @param wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as path to apps plus files already parsed, e.g. manifest.json
  */
-async function findAllApps(wsFolders) {
-    const findResults = await findFioriArtifacts({ wsFolders, artifacts: ['applications'] });
+async function findAllApps(wsFolders, memFs) {
+    const findResults = await findFioriArtifacts({ wsFolders, artifacts: ['applications'], memFs });
     return findResults.applications ?? [];
 }
 /**
  * Filter Fiori apps from a list of files.
  *
  * @param pathMap - map of files. Key is the path, on first read parsed content will be set as value to prevent multiple reads of a file.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as path to apps plus files already parsed, e.g. manifest.json
  */
-async function filterApplications(pathMap) {
+async function filterApplications(pathMap, memFs) {
     const filterApplicationByManifest = async (manifestPath) => {
-        pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath);
+        pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
         const manifest = pathMap[manifestPath]; // cast needed as pathMap also allows strings and any other objects
         // cast allowed, as this is the only place pathMap is filled for manifests
         if (manifest['sap.app'].id && manifest['sap.app'].type === 'application') {
-            const roots = await findRootsForPath((0, path_1.dirname)(manifestPath));
-            if (roots && !(await (0, file_1.fileExists)((0, path_1.join)(roots.appRoot, '.adp', constants_1.FileName.AdaptationConfig)))) {
+            const roots = await findRootsForPath((0, path_1.dirname)(manifestPath), memFs);
+            if (roots && !(await (0, file_1.fileExists)((0, path_1.join)(roots.appRoot, '.adp', constants_1.FileName.AdaptationConfig), memFs))) {
                 return { appRoot: roots.appRoot, projectRoot: roots.projectRoot, manifest: manifest, manifestPath };
             }
         }
@@ -262,15 +267,16 @@ async function filterApplications(pathMap) {
  * Filter adaptation projects from a list of files.
  *
  * @param pathMap - map of files. Key is the path, on first read parsed content will be set as value to prevent multiple reads of a file.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as array of found adaptation projects.
  */
-async function filterAdaptations(pathMap) {
+async function filterAdaptations(pathMap, memFs) {
     const results = [];
     const manifestAppDescrVars = Object.keys(pathMap).filter((path) => path.endsWith(constants_1.FileName.ManifestAppDescrVar));
     for (const manifestAppDescrVar of manifestAppDescrVars) {
-        const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestAppDescrVar));
+        const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestAppDescrVar), memFs);
         const projectRoot = packageJsonPath ? (0, path_1.dirname)(packageJsonPath) : null;
-        if (projectRoot && (await (0, file_1.fileExists)((0, path_1.join)(projectRoot, 'webapp', constants_1.FileName.ManifestAppDescrVar)))) {
+        if (projectRoot && (await (0, file_1.fileExists)((0, path_1.join)(projectRoot, 'webapp', constants_1.FileName.ManifestAppDescrVar), memFs))) {
             results.push({ appRoot: projectRoot, manifestAppdescrVariantPath: manifestAppDescrVar });
         }
     }
@@ -280,9 +286,10 @@ async function filterAdaptations(pathMap) {
  * Filter extensions projects from a list of files.
  *
  * @param pathMap - map of files. Key is the path, on first read parsed content will be set as value to prevent multiple reads of a file.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as array of found extension projects.
  */
-async function filterExtensions(pathMap) {
+async function filterExtensions(pathMap, memFs) {
     const results = [];
     const extensionConfigs = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.ExtConfigJson);
     for (const extensionConfig of extensionConfigs) {
@@ -290,18 +297,19 @@ async function filterExtensions(pathMap) {
             let manifest = null;
             let manifestPath = Object.keys(pathMap).find((path) => path.startsWith((0, path_1.dirname)(extensionConfig) + path_1.sep) && (0, path_1.basename)(path) === constants_1.FileName.Manifest);
             if (manifestPath) {
-                pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath);
+                pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
                 manifest = pathMap[manifestPath];
             }
             else {
                 const manifests = await (0, file_1.findBy)({
                     fileNames: [constants_1.FileName.Manifest],
                     root: (0, path_1.dirname)(extensionConfig),
-                    excludeFolders
+                    excludeFolders,
+                    memFs
                 });
                 if (manifests.length === 1) {
                     [manifestPath] = manifests;
-                    manifest = await (0, file_1.readJSON)(manifestPath);
+                    manifest = await (0, file_1.readJSON)(manifestPath, memFs);
                 }
             }
             if (manifestPath && manifest) {
@@ -319,9 +327,10 @@ async function filterExtensions(pathMap) {
  *
  * @param pathMap - path to files
  * @param manifestPaths - paths to manifest.json files
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as array of found .library projects.
  */
-async function filterDotLibraries(pathMap, manifestPaths) {
+async function filterDotLibraries(pathMap, manifestPaths, memFs) {
     const dotLibraries = [];
     const dotLibraryPaths = Object.keys(pathMap)
         .filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Library)
@@ -329,7 +338,7 @@ async function filterDotLibraries(pathMap, manifestPaths) {
         .filter((path) => !manifestPaths.map((manifestPath) => (0, path_1.dirname)(manifestPath)).includes(path));
     if (dotLibraryPaths) {
         for (const libraryPath of dotLibraryPaths) {
-            const projectRoot = (0, path_1.dirname)((await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(libraryPath))) ?? libraryPath);
+            const projectRoot = (0, path_1.dirname)((await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(libraryPath), memFs)) ?? libraryPath);
             dotLibraries.push({ projectRoot, libraryPath });
         }
     }
@@ -339,20 +348,21 @@ async function filterDotLibraries(pathMap, manifestPaths) {
  * Filter extensions projects from a list of files.
  *
  * @param pathMap - path to files
+ * @param memFs - optional mem-fs-editor instance
  * @returns - results as array of found library projects.
  */
-async function filterLibraries(pathMap) {
+async function filterLibraries(pathMap, memFs) {
     const results = [];
     const manifestPaths = Object.keys(pathMap).filter((path) => (0, path_1.basename)(path) === constants_1.FileName.Manifest);
-    results.push(...(await filterDotLibraries(pathMap, manifestPaths)));
+    results.push(...(await filterDotLibraries(pathMap, manifestPaths, memFs)));
     for (const manifestPath of manifestPaths) {
         try {
-            pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath);
+            pathMap[manifestPath] ??= await (0, file_1.readJSON)(manifestPath, memFs);
             const manifest = pathMap[manifestPath];
             if (manifest['sap.app'] && manifest['sap.app'].type === 'library') {
-                const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestPath));
+                const packageJsonPath = await (0, file_1.findFileUp)(constants_1.FileName.Package, (0, path_1.dirname)(manifestPath), memFs);
                 const projectRoot = packageJsonPath ? (0, path_1.dirname)(packageJsonPath) : null;
-                if (projectRoot && (await (0, file_1.fileExists)((0, path_1.join)(projectRoot, constants_1.FileName.Ui5Yaml)))) {
+                if (projectRoot && (await (0, file_1.fileExists)((0, path_1.join)(projectRoot, constants_1.FileName.Ui5Yaml), memFs))) {
                     results.push({ projectRoot, manifestPath, manifest });
                 }
             }
@@ -384,6 +394,7 @@ function getFilterFileNames(artifacts) {
  * @param options - find options
  * @param options.wsFolders - list of roots, either as vscode WorkspaceFolder[] or array of paths
  * @param options.artifacts - list of artifacts to search for: 'application', 'adaptation', 'extension' see FioriArtifactTypes
+ * @param options.memFs
  * @returns - data structure containing the search results, for app e.g. as path to app plus files already parsed, e.g. manifest.json
  */
 async function findFioriArtifacts(options) {
@@ -396,7 +407,8 @@ async function findFioriArtifacts(options) {
             const foundFiles = await (0, file_1.findBy)({
                 fileNames,
                 root,
-                excludeFolders
+                excludeFolders,
+                memFs: options.memFs
             });
             foundFiles.forEach((path) => (pathMap[path] = null));
         }
@@ -405,16 +417,16 @@ async function findFioriArtifacts(options) {
         }
     }
     if (options.artifacts.includes('applications')) {
-        results.applications = await filterApplications(pathMap);
+        results.applications = await filterApplications(pathMap, options.memFs);
     }
     if (options.artifacts.includes('adaptations')) {
-        results.adaptations = await filterAdaptations(pathMap);
+        results.adaptations = await filterAdaptations(pathMap, options.memFs);
     }
     if (options.artifacts.includes('extensions')) {
-        results.extensions = await filterExtensions(pathMap);
+        results.extensions = await filterExtensions(pathMap, options.memFs);
     }
     if (options.artifacts.includes('libraries')) {
-        results.libraries = await filterLibraries(pathMap);
+        results.libraries = await filterLibraries(pathMap, options.memFs);
     }
     return results;
 }

package/dist/project/service.d.ts

@@ -1,4 +1,5 @@
 import type { Manifest, ManifestNamespace, ServiceSpecification } from '../types';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Get the main service name from the manifest.
  * LROP: by definition the service name can be read from the UI5 model with "" as name.
@@ -13,9 +14,10 @@ export declare function getMainService(manifest: Manifest): string | undefined;
  *
  * @param manifestPath - path to manifest.json
  * @param manifest - optionally, parsed content of manifest.json, pass to avoid reading it again.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - service and annotation specification
  */
-export declare function getServicesAndAnnotations(manifestPath: string, manifest: Manifest): Promise<{
+export declare function getServicesAndAnnotations(manifestPath: string, manifest: Manifest, memFs?: Editor): Promise<{
     [index: string]: ServiceSpecification;
 }>;
 /**

package/dist/project/service.js

@@ -24,10 +24,11 @@ function getMainService(manifest) {
  *
  * @param manifestPath - path to manifest.json
  * @param manifest - optionally, parsed content of manifest.json, pass to avoid reading it again.
+ * @param memFs - optional mem-fs-editor instance
  * @returns - service and annotation specification
  */
-async function getServicesAndAnnotations(manifestPath, manifest) {
-    const parsedManifest = manifest ?? (await (0, file_1.readJSON)(manifestPath));
+async function getServicesAndAnnotations(manifestPath, manifest, memFs) {
+    const parsedManifest = manifest ?? (await (0, file_1.readJSON)(manifestPath, memFs));
     const manifestFolder = (0, path_1.dirname)(manifestPath);
     const services = {};
     const dataSources = parsedManifest?.['sap.app']?.dataSources ?? {};

package/dist/types/access/index.d.ts

@@ -120,6 +120,7 @@ export interface ApplicationAccess extends BaseAccess {
 }
 export interface ProjectAccessOptions {
     logger?: Logger;
+    memFs?: Editor;
 }
 export interface ProjectAccess extends BaseAccess {
     getApplicationIds: () => string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap-ux/project-access",
-  "version": "1.28.9",
+  "version": "1.29.0",
   "description": "Library to access SAP Fiori tools projects",
   "repository": {
     "type": "git",