@sap-ux/preview-middleware 0.26.10 → 0.26.11

package/dist/base/flex.d.ts

@@ -2,6 +2,22 @@ import type { Logger } from '@sap-ux/logger';
 import type { ReaderCollection } from '@ui5/fs';
 import type { Editor } from 'mem-fs-editor';
 import type { CommonChangeProperties } from '@sap-ux/adp-tooling';
+/**
+ * Set of local module paths (fragments, controllers) used to strip
+ * inlined modules from the LrepConnector response so that UI5 loads
+ * local workspace versions via HTTP instead.
+ */
+export type LocalModulePaths = Set<string>;
+/**
+ * State of local module files in the workspace.
+ * - `active`: paths derived from local change files — deployed changes should be served from the local workspace.
+ * - `orphaned`: local files with no corresponding local change record (e.g. change file was deleted) —
+ *   the associated deployed change should be suppressed entirely.
+ */
+export interface LocalModuleState {
+    active: LocalModulePaths;
+    orphaned: LocalModulePaths;
+}
 /**
  * Read changes from the file system and return them.
  *
@@ -10,6 +26,25 @@ import type { CommonChangeProperties } from '@sap-ux/adp-tooling';
  * @returns object with the file name as key and the file content as value
  */
 export declare function readChanges(project: ReaderCollection, logger: Logger): Promise<Record<string, CommonChangeProperties>>;
+/**
+ * Reads local module state from the workspace.
+ *
+ * @param project reference to the UI5 project
+ * @param logger logger instance
+ * @returns LocalModuleState with `active` and `orphaned` sets of relative paths under /changes/
+ */
+export declare function readLocalModulePaths(project: ReaderCollection, logger: Logger): Promise<LocalModuleState>;
+/**
+ * Patches an LREP flex data response so that deployed changes whose module
+ * files exist locally in the workspace are loaded from the local workspace
+ * instead of from ABAP.
+ *
+ * @param responseData the parsed LREP flex data response
+ * @param localModuleState state of local module files (active and orphaned)
+ * @param logger logger instance
+ * @returns the (possibly patched) response data
+ */
+export declare function stripLocalModulesFromLrepResponse(responseData: Record<string, unknown>, localModuleState: LocalModuleState, logger: Logger): Record<string, unknown>;
 /**
  * Writes flex changes to the user's workspace.
  *

package/dist/base/flex.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readChanges = readChanges;
+exports.readLocalModulePaths = readLocalModulePaths;
+exports.stripLocalModulesFromLrepResponse = stripLocalModulesFromLrepResponse;
 exports.writeChange = writeChange;
 exports.deleteChange = deleteChange;
 const node_fs_1 = require("node:fs");
@@ -26,6 +28,209 @@ async function readChanges(project, logger) {
     }
     return changes;
 }
+/**
+ * Extracts the local module path from a change's type and content.
+ * Returns the fragmentPath for addXML changes, codeRef for codeExt changes, and undefined otherwise.
+ *
+ * @param changeType
+ * @param content
+ */
+function extractLocalModulePath(changeType, content) {
+    if (changeType === 'addXML' && typeof content?.fragmentPath === 'string') {
+        return content.fragmentPath;
+    }
+    if (changeType === 'codeExt' && typeof content?.codeRef === 'string') {
+        return content.codeRef;
+    }
+    return undefined;
+}
+/**
+ * Reads local module state from the workspace.
+ *
+ * @param project reference to the UI5 project
+ * @param logger logger instance
+ * @returns LocalModuleState with `active` and `orphaned` sets of relative paths under /changes/
+ */
+async function readLocalModulePaths(project, logger) {
+    const active = new Set();
+    const orphaned = new Set();
+    const changeFiles = await project.byGlob('/**/changes/**/*.{change,variant,ctrl_variant,ctrl_variant_change,ctrl_variant_management_change}');
+    for (const file of changeFiles) {
+        try {
+            const change = JSON.parse(await file.getString());
+            const content = change.content;
+            const localPath = extractLocalModulePath(change.changeType, content);
+            if (localPath) {
+                active.add(localPath);
+            }
+        }
+        catch {
+            // ignore malformed change files — readChanges already warns about them
+        }
+    }
+    const moduleFiles = await project.byGlob('/**/changes/{fragments/**/*.xml,coding/**/*.js,coding/**/*.ts}');
+    for (const file of moduleFiles) {
+        const filePath = file.getPath();
+        const changesIdx = filePath.lastIndexOf('/changes/');
+        if (changesIdx !== -1) {
+            const relativePath = filePath.substring(changesIdx + '/changes/'.length);
+            // normalise .ts → .js so the orphaned key matches the codeRef in deployed changes
+            const normalizedPath = relativePath.endsWith('.ts') ? relativePath.slice(0, -3) + '.js' : relativePath;
+            if (!active.has(normalizedPath)) {
+                orphaned.add(normalizedPath);
+            }
+        }
+    }
+    logger.debug(`Found ${active.size} active and ${orphaned.size} orphaned local module(s) for LREP filtering`);
+    return { active, orphaned };
+}
+/**
+ * Strips inlined module entries from `result.modules` whose paths match active local modules.
+ *
+ * @param result the response object being patched (mutated when modules are stripped)
+ * @param active set of active local module paths
+ * @param logger logger instance
+ * @returns true if `result.modules` was modified
+ */
+function stripInlinedModules(result, active, logger) {
+    if (!result.modules || typeof result.modules !== 'object') {
+        return false;
+    }
+    const originalModules = result.modules;
+    const filteredEntries = Object.entries(originalModules).filter(([key]) => {
+        // lastIndexOf anchors on the flex /changes/ segment even if the namespace contains "changes"
+        const changesIdx = key.lastIndexOf('/changes/');
+        if (changesIdx === -1) {
+            return true;
+        }
+        const relativePath = key.substring(changesIdx + '/changes/'.length);
+        if (active.has(relativePath)) {
+            logger.debug(`Stripping inlined module '${key}' — local version will be served instead`);
+            return false;
+        }
+        return true;
+    });
+    const removedCount = Object.keys(originalModules).length - filteredEntries.length;
+    if (removedCount === 0) {
+        return false;
+    }
+    logger.info(`Stripped ${removedCount} inlined module(s) from LREP response in favor of local versions`);
+    result.modules = Object.fromEntries(filteredEntries);
+    return true;
+}
+/**
+ * Injects expected `moduleName` values into changes whose local paths are active so UI5 resolves
+ * them via the adp.proxy instead of expecting inlined module content.
+ *
+ * @param changes the array of change objects
+ * @param active set of active local module paths
+ * @param logger logger instance
+ * @returns updated changes array if any moduleName was injected, otherwise null
+ */
+function injectModuleNames(changes, active, logger) {
+    let changesModified = false;
+    const updatedChanges = changes.map((change) => {
+        const c = change;
+        const content = c.content;
+        const reference = typeof c.reference === 'string' ? c.reference : '';
+        const changeType = c.changeType;
+        const localPath = extractLocalModulePath(changeType, content);
+        if (!localPath || !active.has(localPath) || !reference) {
+            return change;
+        }
+        const prefix = reference.replaceAll('.', '/');
+        // codeExt modules are JS — strip the trailing .js so the path is a valid UI5 module ID
+        const modulePathSuffix = changeType === 'codeExt' && localPath.endsWith('.js') ? localPath.slice(0, -3) : localPath;
+        const expectedModuleName = `${prefix}/changes/${modulePathSuffix}`;
+        if (c.moduleName === expectedModuleName) {
+            return change;
+        }
+        logger.debug(`Setting moduleName '${expectedModuleName}' for local '${localPath}'`);
+        changesModified = true;
+        return { ...c, moduleName: expectedModuleName };
+    });
+    return changesModified ? updatedChanges : null;
+}
+/**
+ * Filters out deployed changes whose local file exists but whose local change record was deleted
+ * (i.e. orphaned). Returning these changes would re-apply ABAP state that the user already removed.
+ *
+ * @param changes the array of change objects
+ * @param orphaned set of orphaned local module paths
+ * @param logger logger instance
+ * @returns filtered changes array if any change was suppressed, otherwise null
+ */
+function suppressOrphanedChanges(changes, orphaned, logger) {
+    const filteredChanges = changes.filter((change) => {
+        const c = change;
+        const content = c.content;
+        const localPath = extractLocalModulePath(c.changeType, content);
+        if (localPath && orphaned.has(localPath)) {
+            logger.debug(`Suppressing deployed change for orphaned local file '${localPath}'`);
+            return false;
+        }
+        return true;
+    });
+    const removedCount = changes.length - filteredChanges.length;
+    if (removedCount === 0) {
+        return null;
+    }
+    logger.info(`Suppressed ${removedCount} deployed change(s) whose local files exist but change records were deleted`);
+    return filteredChanges;
+}
+/**
+ * Applies moduleName injection and orphaned-change suppression to `result.changes`.
+ *
+ * @param result the response object being patched (mutated when changes are updated)
+ * @param state local module state (active and orphaned)
+ * @param logger logger instance
+ * @returns true if `result.changes` was modified
+ */
+function processChanges(result, state, logger) {
+    if (!result.changes || !Array.isArray(result.changes)) {
+        return false;
+    }
+    let modified = false;
+    const injected = injectModuleNames(result.changes, state.active, logger);
+    if (injected) {
+        result.changes = injected;
+        modified = true;
+    }
+    if (state.orphaned.size > 0) {
+        const suppressed = suppressOrphanedChanges(result.changes, state.orphaned, logger);
+        if (suppressed) {
+            result.changes = suppressed;
+            modified = true;
+        }
+    }
+    return modified;
+}
+/**
+ * Patches an LREP flex data response so that deployed changes whose module
+ * files exist locally in the workspace are loaded from the local workspace
+ * instead of from ABAP.
+ *
+ * @param responseData the parsed LREP flex data response
+ * @param localModuleState state of local module files (active and orphaned)
+ * @param logger logger instance
+ * @returns the (possibly patched) response data
+ */
+function stripLocalModulesFromLrepResponse(responseData, localModuleState, logger) {
+    if (localModuleState.active.size === 0 && localModuleState.orphaned.size === 0) {
+        return responseData;
+    }
+    const result = { ...responseData };
+    let modified = stripInlinedModules(result, localModuleState.active, logger);
+    if (result.loadModules === true && localModuleState.active.size > 0) {
+        logger.debug('Stripping loadModules flag — modules will be loaded on-demand so adp.proxy can serve local versions');
+        delete result.loadModules;
+        modified = true;
+    }
+    if (processChanges(result, localModuleState, logger)) {
+        modified = true;
+    }
+    return modified ? result : responseData;
+}
 /**
  * Writes flex changes to the user's workspace.
  *

package/dist/base/flp.d.ts

@@ -341,6 +341,33 @@ export declare class FlpSandbox {
      * @param adp AdpPreview instance
      */
     private setupAdpCommonHandlers;
+    /**
+     * Registers a middleware that intercepts LREP flex data responses to apply
+     * local workspace overrides: stripping inlined modules for active local files,
+     * removing the loadModules pre-fetch flag, injecting correct moduleNames, and
+     * suppressing deployed changes for orphaned local files (change record deleted).
+     *
+     * The local module state is captured once at server startup by `readLocalModulePaths`
+     * and is not refreshed during the preview session. If a developer adds, renames, or deletes
+     * a local fragment, controller, or change file while the preview is running, the filter will
+     * be stale until the server is restarted. This is an intentional trade-off — re-scanning the
+     * VFS on every flex-data request would add latency to every preview round-trip.
+     *
+     * @param adp AdpPreview instance with access to the ABAP service provider
+     * @param localModuleState pre-scanned local module state
+     */
+    private registerLrepFlexDataFilter;
+    /**
+     * Handler for LREP flex data requests. Strips inlined modules that exist locally
+     * so that UI5 fetches them via HTTP from the local workspace instead.
+     *
+     * @param req the request
+     * @param res the response
+     * @param next the next middleware
+     * @param provider the ABAP service provider for backend calls
+     * @param localModuleState pre-scanned local module state
+     */
+    private lrepFlexDataFilterHandler;
     /**
      * Setup the CF build path mode for the ADP project.
      *

package/dist/base/flp.js

@@ -936,6 +936,8 @@ class FlpSandbox {
         const descriptor = adp.descriptor;
         const { name, manifest } = descriptor;
         await this.init(manifest, name, adp.resources, adp);
+        const localModuleState = await (0, flex_1.readLocalModulePaths)(this.project, this.logger);
+        this.registerLrepFlexDataFilter(adp, localModuleState);
         this.router.use(adp.descriptor.url, adp.proxy.bind(adp));
         await this.setupAdpCommonHandlers(adp);
     }
@@ -951,6 +953,60 @@ class FlpSandbox {
         // Register i18n store route for ADP projects (used by OVP bridge functions)
         await this.addStoreI18nKeysRoute();
     }
+    /**
+     * Registers a middleware that intercepts LREP flex data responses to apply
+     * local workspace overrides: stripping inlined modules for active local files,
+     * removing the loadModules pre-fetch flag, injecting correct moduleNames, and
+     * suppressing deployed changes for orphaned local files (change record deleted).
+     *
+     * The local module state is captured once at server startup by `readLocalModulePaths`
+     * and is not refreshed during the preview session. If a developer adds, renames, or deletes
+     * a local fragment, controller, or change file while the preview is running, the filter will
+     * be stale until the server is restarted. This is an intentional trade-off — re-scanning the
+     * VFS on every flex-data request would add latency to every preview round-trip.
+     *
+     * @param adp AdpPreview instance with access to the ABAP service provider
+     * @param localModuleState pre-scanned local module state
+     */
+    registerLrepFlexDataFilter(adp, localModuleState) {
+        const provider = adp.serviceProvider;
+        if (!provider) {
+            return;
+        }
+        if (localModuleState.active.size === 0 && localModuleState.orphaned.size === 0) {
+            this.logger.debug('No local module files found — LREP flex data filter not registered');
+            return;
+        }
+        const lrepFlexDataPath = '/sap/bc/lrep/flex/data/';
+        this.router.get(`${lrepFlexDataPath}*`, async (req, res, next) => {
+            await this.lrepFlexDataFilterHandler(req, res, next, provider, localModuleState);
+        });
+        this.logger.info(`Registered LREP flex data filter for ${localModuleState.active.size} active and ${localModuleState.orphaned.size} orphaned local module(s)`);
+    }
+    /**
+     * Handler for LREP flex data requests. Strips inlined modules that exist locally
+     * so that UI5 fetches them via HTTP from the local workspace instead.
+     *
+     * @param req the request
+     * @param res the response
+     * @param next the next middleware
+     * @param provider the ABAP service provider for backend calls
+     * @param localModuleState pre-scanned local module state
+     */
+    async lrepFlexDataFilterHandler(req, res, next, provider, localModuleState) {
+        try {
+            const response = await provider.get(req.url);
+            const responseData = typeof response.data === 'string' ? JSON.parse(response.data) : response.data;
+            const filtered = (0, flex_1.stripLocalModulesFromLrepResponse)(responseData, localModuleState, this.logger);
+            res.status(200).json(filtered);
+        }
+        catch (error) {
+            this.logger.error(`LREP flex data filter failed for '${req.url}' — falling back to unfiltered backend response. Local workspace files may not take effect. Error: ${error?.message ?? error}`);
+            // Fall through to the next middleware (e.g. backend-proxy-middleware)
+            // so that preview remains functional even if filtering fails.
+            next();
+        }
+    }
     /**
      * Setup the CF build path mode for the ADP project.
      *

package/package.json

@@ -9,7 +9,7 @@
   "bugs": {
     "url": "https://github.com/SAP/open-ux-tools/issues?q=is%3Aopen+is%3Aissue+label%3Abug+label%3Apreview-middleware"
   },
-  "version": "0.26.10",
+  "version": "0.26.11",
   "license": "Apache-2.0",
   "author": "@SAP/ux-tools-team",
   "main": "dist/index.js",
@@ -27,7 +27,7 @@
     "mem-fs-editor": "9.4.0",
     "qrcode": "1.5.4",
     "@sap/bas-sdk": "3.13.7",
-    "@sap-ux/adp-tooling": "0.19.9",
+    "@sap-ux/adp-tooling": "0.19.10",
     "@sap-ux/btp-utils": "1.2.1",
     "@sap-ux/control-property-editor-sources": "npm:@sap-ux/control-property-editor@0.8.1",
     "@sap-ux/feature-toggle": "0.4.0",
@@ -52,7 +52,7 @@
     "nock": "14.0.11",
     "npm-run-all2": "8.0.4",
     "supertest": "7.2.2",
-    "@private/preview-middleware-client": "npm:@sap-ux-private/preview-middleware-client@0.26.10",
+    "@private/preview-middleware-client": "npm:@sap-ux-private/preview-middleware-client@0.26.11",
     "@sap-ux-private/playwright": "0.3.1",
     "@sap-ux/axios-extension": "1.26.1",
     "@sap-ux/store": "1.6.1",