@ui5/task-adaptation 1.5.3 → 1.6.0-rc.1

package/dist/cache/cacheHolder.d.ts

@@ -1,7 +1,7 @@
 export default class CacheHolder {
     private static TEMP_TASK_DIR;
     private static getTempDir;
-    static read(repoName: string, token: string): Map<string, string> | undefined;
+    static read(repoName: string, token: string): Promise<Map<string, string>>;
     static write(repoName: string, token: string, files: Map<string, string>): Promise<void>;
     private static isValid;
     /**

package/dist/cache/cacheHolder.js

@@ -1,21 +1,22 @@
 import * as fs from "fs";
 import * as fsPromises from "fs/promises";
 import * as path from "path";
+import * as os from "node:os";
 import ResourceUtil from "../util/resourceUtil.js";
 import encodeFilename from "filenamify";
 import { getLogger } from "@ui5/logger";
-import tempDir from "temp-dir";
 const log = getLogger("@ui5/task-adaptation::CacheHolder");
 export default class CacheHolder {
     static TEMP_TASK_DIR = "ui5-task-adaptation";
     static getTempDir(...paths) {
-        return path.join(tempDir, this.TEMP_TASK_DIR, ...paths.map(part => encodeFilename(part, { replacement: "_" })));
+        return path.join(os.tmpdir(), this.TEMP_TASK_DIR, ...paths.map(part => encodeFilename(part, { replacement: "_" })));
     }
     static read(repoName, token) {
         const directory = this.getTempDir(repoName, token);
         if (this.isValid(repoName, "repoName") && this.isValid(token, "token") && fs.existsSync(directory)) {
-            return ResourceUtil.read(directory);
+            return ResourceUtil.byGlob(directory, "**/*");
         }
+        return Promise.resolve(new Map());
     }
     static async write(repoName, token, files) {
         this.delete(repoName);
@@ -40,7 +41,7 @@ export default class CacheHolder {
      * Clears all cached files
      */
     static clear() {
-        this.deleteDir(path.join(tempDir, this.TEMP_TASK_DIR));
+        this.deleteDir(path.join(os.tmpdir(), this.TEMP_TASK_DIR));
     }
     static deleteDir(directory) {
         if (fs.existsSync(directory)) {
@@ -67,9 +68,10 @@ export function cached() {
     return function (_target, _propertyKey, descriptor) {
         const originalValue = descriptor.value;
         descriptor.value = async function (...args) {
-            let files = CacheHolder.read(args[0], args[1]);
+            let files = await CacheHolder.read(args[0], args[1]);
             CacheHolder.clearOutdatedExcept(args[0]);
-            if (files == null) {
+            if (files.size === 0) {
+                log.verbose(`Cache repo '${args[0]}' with token '${args[1]}' does not contain files. Fetching...`);
                 files = await originalValue.apply(this, args);
                 await CacheHolder.write(args[0], args[1], files);
             }

package/dist/index.js

@@ -6,6 +6,7 @@ import I18nMerger from "./util/i18nMerger.js";
 import ResourceUtil from "./util/resourceUtil.js";
 import { determineProcessor } from "./processors/processor.js";
 import FilesUtil from "./util/filesUtil.js";
+import PreviewManager from "./previewManager.js";
 /**
  * Creates an appVariant bundle from the provided resources.
  */
@@ -14,7 +15,9 @@ export default ({ workspace, options, taskUtil }) => {
     async function process(workspace, taskUtil) {
         logBuilderVersion();
         const processor = determineProcessor(options.configuration);
+        const adapter = processor.getAdapter();
         const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
+        const previewManagerPromise = PreviewManager.createFromRoot(adaptationProject.reference, processor);
         const appVariantIdHierarchy = await processor.getAppVariantIdHierarchy(adaptationProject.reference);
         if (appVariantIdHierarchy.length === 0) {
             throw new Error(`No app variant found for reference ${adaptationProject.reference}`);
@@ -35,7 +38,8 @@ export default ({ workspace, options, taskUtil }) => {
                 appVariant = adaptationProject;
             }
             appVariants.push(appVariant);
-            const adaptedFiles = await baseApp.adapt(appVariant, processor);
+            let adaptedFiles = await baseApp.adapt(appVariant, processor);
+            adaptedFiles = await adapter.adapt(adaptedFiles, appVariantFiles);
             return I18nMerger.merge(adaptedFiles, baseApp.i18nPath, appVariant);
         };
         let files = await fetchFilesPromises.reduce(async (previousFiles, currentFiles) => adapt(await previousFiles, await currentFiles), fetchFilesPromises.shift());
@@ -43,7 +47,9 @@ export default ({ workspace, options, taskUtil }) => {
         files = FilesUtil.filter(files);
         files = FilesUtil.rename(files, references);
         adaptationProject.omitDeletedResources(files, options.projectNamespace, taskUtil);
-        const writePromises = new Array();
+        // Read libs for preview
+        const previewManager = await previewManagerPromise;
+        const writePromises = new Array(previewManager.processPreviewResources(files));
         files.forEach((content, filename) => {
             const resource = ResourceUtil.createResource(filename, options.projectNamespace, content);
             writePromises.push(workspace.write(resource));

package/dist/model/authenticationError.d.ts

@@ -0,0 +1,3 @@
+export default class AuthenticationError extends Error {
+    constructor(details?: string);
+}

package/dist/model/authenticationError.js

@@ -0,0 +1,8 @@
+export default class AuthenticationError extends Error {
+    constructor(details) {
+        super(details);
+        this.name = "AuthenticationError";
+        this.message = "Authentication error. Use 'cf login' to authenticate in Cloud Foundry" + (details ? `: ${details}` : ".");
+    }
+}
+//# sourceMappingURL=authenticationError.js.map

package/dist/model/types.d.ts

@@ -85,6 +85,18 @@ export interface IHTML5RepoInfo {
     token: string;
     baseUri: string;
 }
+export interface IReuseLibInfo {
+    name: string;
+    lazy: boolean;
+    html5AppHostId: string;
+    html5AppName: string;
+    html5AppVersion: string;
+    html5CacheBusterToken: string;
+    url: {
+        uri: string;
+        final: boolean;
+    };
+}
 export interface IAuth {
     username: string;
     password: string;

package/dist/previewManager.d.ts

@@ -0,0 +1,13 @@
+import IProcessor from "./processors/processor.js";
+export default class PreviewManager {
+    private readonly fetchLibsPromises;
+    static createFromRoot(appId: string, processor: IProcessor): Promise<PreviewManager>;
+    static isPreviewRequested(): boolean;
+    private constructor();
+    processPreviewResources(baseAppFiles: ReadonlyMap<string, string>): Promise<void>;
+    private preReadLibs;
+    private searchBaseAppXsAppJsonFile;
+    private mergeXsAppJsonFiles;
+    private static moveLibraryFiles;
+    private static modifyRoutes;
+}

package/dist/previewManager.js

@@ -0,0 +1,131 @@
+import { getLogger } from "@ui5/logger";
+import ResourceUtil from "./util/resourceUtil.js";
+import path from "path";
+import { merge } from "./util/cf/xsAppJsonUtil.js";
+const log = getLogger("@ui5/task-adaptation::PreviewManager");
+const REUSE_DIR = ".adp/reuse";
+const APP_INFO_FILE = "ui5AppInfo.json";
+const XS_APP_JSON_FILE = "xs-app.json";
+export default class PreviewManager {
+    fetchLibsPromises = new Map();
+    static async createFromRoot(appId, processor) {
+        let ui5AppInfo = "";
+        if (PreviewManager.isPreviewRequested()) {
+            try {
+                ui5AppInfo = await ResourceUtil.readInProject(APP_INFO_FILE);
+            }
+            catch (_err) {
+                log.verbose("Preview mode not requested (env variable ADP_BUILDER_MODE=preview is not set), skipping preview resources processing.");
+                throw new Error(`ui5AppInfo.json is missing in project root, cannot process preview resources.`);
+            }
+        }
+        return new PreviewManager(appId, ui5AppInfo, processor);
+    }
+    static isPreviewRequested() {
+        return process.env.ADP_BUILDER_MODE === "preview";
+    }
+    constructor(appId, ui5AppInfo, processor) {
+        // If no ui5AppInfo is provided, no preview processing is needed
+        if (!ui5AppInfo) {
+            return;
+        }
+        const appInfo = JSON.parse(ui5AppInfo)[appId];
+        if (!appInfo) {
+            throw new Error(`No app info found for original app id '${appId}' in ui5AppInfo.json`);
+        }
+        const reuseLibs = appInfo.asyncHints.libs.filter(lib => lib.html5AppHostId && lib.html5AppName && lib.html5AppVersion);
+        if (reuseLibs.length > 0) {
+            this.fetchLibsPromises = this.preReadLibs(reuseLibs, processor);
+        }
+        const logMap = {
+            Error: log.error,
+            Warning: log.warning,
+            Info: log.info,
+            debug: log.verbose
+        };
+        appInfo.messages.forEach((message) => {
+            const logger = logMap[message.severity] || log.info;
+            logger(`ui5AppInfo.json: ${message.severity} Message: ${message.message} (Error Code: ${message.errorCode})`);
+        });
+    }
+    async processPreviewResources(baseAppFiles) {
+        log.verbose(`Downloading reuse libraries to reuse folder`);
+        const xsAppFiles = new Map();
+        if (this.fetchLibsPromises.size === 0) {
+            log.verbose("No reuse libraries defined in ui5AppInfo.json for preview");
+            return;
+        }
+        const mergedFiles = new Map();
+        for (const [libName, libFilesPromise] of this.fetchLibsPromises) {
+            const libFiles = await libFilesPromise;
+            if (!libFiles || libFiles.size === 0) {
+                log.warn(`No files found in reuse library ${libName} for preview`);
+                continue;
+            }
+            for (const [filename, content] of libFiles) {
+                mergedFiles.set(filename, content);
+                if (filename.includes(XS_APP_JSON_FILE)) {
+                    xsAppFiles.set(filename, content);
+                }
+            }
+        }
+        this.searchBaseAppXsAppJsonFile(xsAppFiles, baseAppFiles);
+        this.mergeXsAppJsonFiles(xsAppFiles, mergedFiles);
+        await ResourceUtil.writeInProject(REUSE_DIR, mergedFiles);
+    }
+    preReadLibs(reuseLibs, processor) {
+        const promises = new Map();
+        reuseLibs.forEach(lib => {
+            log.info(`Downloading reuse library '${lib.html5AppName}' version '${lib.html5AppVersion}'`);
+            const promise = processor
+                .fetchReuseLib(lib.html5AppName, lib.html5CacheBusterToken, lib)
+                .then(libFiles => PreviewManager.moveLibraryFiles(libFiles, lib.html5AppName, lib.name));
+            promises.set(lib.html5AppName, promise);
+        });
+        return promises;
+    }
+    searchBaseAppXsAppJsonFile(xsAppFiles, baseAppFiles) {
+        const xsAppJsonContent = baseAppFiles.get(XS_APP_JSON_FILE);
+        if (xsAppJsonContent) {
+            xsAppFiles.set(XS_APP_JSON_FILE, xsAppJsonContent);
+        }
+        else {
+            log.warn("xs-app.json is missing in the downloaded base app files for preview");
+        }
+    }
+    mergeXsAppJsonFiles(xsAppFiles, files) {
+        const mergedXsAppJson = merge([...xsAppFiles.values()]);
+        if (mergedXsAppJson) {
+            files.set(XS_APP_JSON_FILE, mergedXsAppJson);
+        }
+    }
+    static moveLibraryFiles(inputFiles, libraryName, libId) {
+        const files = new Map();
+        inputFiles.forEach((content, filename) => {
+            const newFilename = path.join(libraryName, filename);
+            // Source path in xs-app.json needs to be adjusted to new location
+            if (filename.includes(XS_APP_JSON_FILE)) {
+                content = PreviewManager.modifyRoutes(content, libraryName, libId);
+            }
+            files.set(newFilename, content);
+        });
+        return files;
+    }
+    ;
+    static modifyRoutes(xsAppJson, libName, libId) {
+        const xsApp = JSON.parse(xsAppJson);
+        xsApp.routes = xsApp.routes.map((route) => {
+            route.source = route.source.replace(new RegExp("^\\^\\/?(resources/)?"), `^/resources/${libId.replaceAll(".", "/")}/`);
+            if (route.service === "html5-apps-repo-rt") {
+                route = {
+                    source: route.source,
+                    target: route.target,
+                    localDir: path.join(REUSE_DIR, libName)
+                };
+            }
+            return route;
+        });
+        return JSON.stringify(xsApp);
+    }
+}
+//# sourceMappingURL=previewManager.js.map

package/dist/processors/abapProcessor.d.ts

@@ -3,13 +3,16 @@ import AnnotationManager from "../annotationManager.js";
 import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 import { IConfiguration } from "../model/types.js";
 import IProcessor from "./processor.js";
+import { Adapter } from "../adapters/adapter.js";
 export default class AbapProcessor implements IProcessor {
     private abapRepoManager;
     private configuration;
     private annotationManager;
     constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager, annotationManager: AnnotationManager);
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
+    getAdapter(): Adapter;
     fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(): Promise<Map<string, string>>;
     validateConfiguration(): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
     getConfigurationType(): string;

package/dist/processors/abapProcessor.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import Language from "../model/language.js";
 import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
+import AbapAdapter from "../adapters/abapAdapter.js";
 export default class AbapProcessor {
     abapRepoManager;
     configuration;
@@ -19,9 +20,15 @@ export default class AbapProcessor {
     getAppVariantIdHierarchy(appId) {
         return this.abapRepoManager.getAppVariantIdHierarchy(appId);
     }
+    getAdapter() {
+        return new AbapAdapter();
+    }
     fetch(repoName, _cachebusterToken) {
         return this.abapRepoManager.fetch(repoName);
     }
+    fetchReuseLib() {
+        throw new Error("Preview is not available on SAP S/4HANA On-Premise or Cloud Systems. Please create a ticket on CA-UI5-FL-ADP-BAS component.");
+    }
     validateConfiguration() {
         // validate general app config
         const properties = ["appName"];

package/dist/processors/cfProcessor.d.ts

@@ -1,11 +1,14 @@
 import IAppInfo from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "../model/types.js";
 import IProcessor from "./processor.js";
+import { Adapter } from "../adapters/adapter.js";
 export default class CFProcessor implements IProcessor {
     private configuration;
     constructor(configuration: IConfiguration);
+    getAdapter(): Adapter;
     getAppVariantIdHierarchy(appId: string): Promise<IAppInfo[]>;
     fetch(_repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(_libName: string, _cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
     validateConfiguration(): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>): Promise<void>;
     private updateXsAppJson;

package/dist/processors/cfProcessor.js

@@ -9,12 +9,17 @@ import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
 import CFUtil from "../util/cfUtil.js";
 import { getLogger } from "@ui5/logger";
+import PreviewManager from "../previewManager.js";
+import CFAdapter from "../adapters/cfAdapter.js";
 const log = getLogger("@ui5/task-adaptation::CFProcessor");
 export default class CFProcessor {
     configuration;
     constructor(configuration) {
         this.configuration = configuration;
     }
+    getAdapter() {
+        return new CFAdapter();
+    }
     async getAppVariantIdHierarchy(appId) {
         const metadata = await HTML5RepoManager.getMetadata(this.configuration);
         return [{
@@ -26,12 +31,18 @@ export default class CFProcessor {
     fetch(_repoName, _cachebusterToken) {
         return HTML5RepoManager.getBaseAppFiles(this.configuration);
     }
+    fetchReuseLib(_libName, _cachebusterToken, lib) {
+        return HTML5RepoManager.getReuseLibFiles(this.configuration, lib);
+    }
     validateConfiguration() {
         validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
     }
     async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles) {
         this.updateCloudPlatform(baseAppManifest);
-        await this.updateXsAppJson(baseAppFiles);
+        // Preview uses destinations and does not require xs-app.json updates
+        if (!PreviewManager.isPreviewRequested()) {
+            await this.updateXsAppJson(baseAppFiles);
+        }
     }
     async updateXsAppJson(baseAppFiles) {
         const xsAppJsonContent = baseAppFiles.get("xs-app.json");
@@ -119,4 +130,7 @@ export default class CFProcessor {
 __decorate([
     cached()
 ], CFProcessor.prototype, "fetch", null);
+__decorate([
+    cached()
+], CFProcessor.prototype, "fetchReuseLib", null);
 //# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -1,8 +1,11 @@
 import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "../model/types.js";
+import { Adapter } from "../adapters/adapter.js";
 export default interface IProcessor {
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
     fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(repoName: string, cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
+    getAdapter(): Adapter;
     createAppVariantHierarchyItem(appVariantId: string, version: string): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
 }

package/dist/repositories/html5RepoManager.d.ts

@@ -1,11 +1,12 @@
-import { IConfiguration } from "./../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "./../model/types.js";
 export default class HTML5RepoManager {
     static getBaseAppFiles(configuration: IConfiguration): Promise<Map<string, string>>;
     static getMetadata(configuration: IConfiguration): Promise<any>;
+    static getReuseLibFiles(configuration: IConfiguration, lib: IReuseLibInfo): Promise<Map<string, string>>;
     private static getHtml5RepoInfo;
     private static getHTML5Credentials;
     private static getToken;
     private static requestMetadata;
-    private static getBaseAppZipEntries;
+    private static getAppZipEntries;
     private static download;
 }

package/dist/repositories/html5RepoManager.js

@@ -6,12 +6,26 @@ const log = getLogger("@ui5/task-adaptation::HTML5RepoManager");
 export default class HTML5RepoManager {
     static async getBaseAppFiles(configuration) {
         const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
-        return this.getBaseAppZipEntries(configuration, baseUri, token);
+        const app = {
+            appName: configuration.appName,
+            appVersion: configuration.appVersion,
+            appHostId: configuration.appHostId
+        };
+        return this.getAppZipEntries(app, baseUri, token);
     }
     static async getMetadata(configuration) {
         const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
         return this.requestMetadata(configuration, baseUri, token);
     }
+    static async getReuseLibFiles(configuration, lib) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        const libAppData = {
+            appName: lib.html5AppName,
+            appVersion: lib.html5AppVersion,
+            appHostId: lib.html5AppHostId
+        };
+        return this.getAppZipEntries(libAppData, baseUri, token);
+    }
     static async getHtml5RepoInfo(configuration) {
         const spaceGuid = await CFUtil.getSpaceGuid(configuration?.space);
         const credentials = await this.getHTML5Credentials(spaceGuid);
@@ -65,10 +79,9 @@ export default class HTML5RepoManager {
         const metadata = await RequestUtil.get(uri, requestOptions);
         return metadata.find((item) => item.appHostId === appHostId && item.applicationName === appName && item.applicationVersion === appVersion);
     }
-    static async getBaseAppZipEntries(options, html5RepoBaseUri, token) {
-        const { appHostId, appName, appVersion } = options;
-        const uri = `${html5RepoBaseUri}/applications/content/${appName}-${appVersion}/`;
-        const zip = await this.download(token, appHostId, uri);
+    static async getAppZipEntries(app, html5RepoBaseUri, token) {
+        const uri = `${html5RepoBaseUri}/applications/content/${app.appName}-${app.appVersion}/`;
+        const zip = await this.download(token, app.appHostId, uri);
         return unzipZipEntries(zip);
     }
     static async download(token, appHostId, uri) {

package/dist/util/cf/xsAppJsonUtil.d.ts

@@ -0,0 +1,23 @@
+export type XsApp = {
+    welcomeFile?: string;
+    authenticationMethod: "none" | "route";
+    routes: Route[];
+};
+export type Route = {
+    source: string;
+    target: string;
+    service?: string;
+    destination?: string;
+    authenticationType?: string;
+    localDir?: string;
+};
+export declare const XSAPP_JSON_FILENAME = "xs-app.json";
+/**
+ * Merges multiple xs-app.json contents into one. AppVariant and Reuse Library
+ * xs-app.json files come first, base app xs-app.json last. Routes from all
+ * files are concatenated.
+ * @param xsAppFiles Array of xs-app.json file contents as strings
+ * @returns Merged xs-app.json content as a string, or undefined if no files
+ * were provided
+ */
+export declare function merge(xsAppFiles: string[]): string | undefined;

package/dist/util/cf/xsAppJsonUtil.js

@@ -0,0 +1,36 @@
+export const XSAPP_JSON_FILENAME = "xs-app.json";
+/**
+ * Merges multiple xs-app.json contents into one. AppVariant and Reuse Library
+ * xs-app.json files come first, base app xs-app.json last. Routes from all
+ * files are concatenated.
+ * @param xsAppFiles Array of xs-app.json file contents as strings
+ * @returns Merged xs-app.json content as a string, or undefined if no files
+ * were provided
+ */
+export function merge(xsAppFiles) {
+    if (xsAppFiles.length === 0) {
+        return;
+    }
+    if (xsAppFiles.length === 1) {
+        return xsAppFiles[0];
+    }
+    // Start with empty xs-app.json
+    const merged = {
+        authenticationMethod: "none",
+        routes: []
+    };
+    for (const xsAppInfoContent of xsAppFiles) {
+        const { authenticationMethod, routes, welcomeFile } = JSON.parse(xsAppInfoContent);
+        if (merged.welcomeFile === undefined && welcomeFile) {
+            merged.welcomeFile = welcomeFile;
+        }
+        if (merged.authenticationMethod === "none" && authenticationMethod) {
+            merged.authenticationMethod = authenticationMethod;
+        }
+        if (Array.isArray(routes)) {
+            merged.routes = merged.routes.concat(routes);
+        }
+    }
+    return JSON.stringify(merged, null, 4);
+}
+//# sourceMappingURL=xsAppJsonUtil.js.map

package/dist/util/cfUtil.d.ts

@@ -15,7 +15,7 @@ export default class CFUtil {
     private static createServiceKey;
     private static deleteServiceKeyUnsafe;
     private static getServiceInstance;
-    static processErrors(json: any): void;
+    static processCfErrors(errors?: ICfError[]): void;
     static requestCfApi(url: string): Promise<IResource[]>;
     static getOAuthToken(): Promise<string>;
     private static cfExecute;
@@ -76,3 +76,10 @@ export default class CFUtil {
      */
     static getSpaceGuid(spaceGuid?: string): Promise<string>;
 }
+interface ICfError {
+    code: number;
+    title: string;
+    detail: string;
+    [key: string]: any;
+}
+export {};

package/dist/util/cfUtil.js

@@ -3,6 +3,7 @@ import { getSpaceGuidThrowIfUndefined } from "@sap/cf-tools/out/src/utils.js";
 import { Cli } from "@sap/cf-tools/out/src/cli.js";
 import { eFilters } from "@sap/cf-tools/out/src/types.js";
 import { getLogger } from "@ui5/logger";
+import AuthenticationError from "../model/authenticationError.js";
 const log = getLogger("@ui5/task-adaptation::CFUtil");
 export default class CFUtil {
     /**
@@ -103,19 +104,20 @@ export default class CFUtil {
             guid: service.guid
         }));
     }
-    static processErrors(json) {
-        if (json?.errors?.length > 0) {
-            const message = JSON.stringify(json.errors);
-            if (json?.errors?.some((e) => e.title === "CF-NotAuthenticated" || e.code === 10002)) {
-                throw new Error(`Authentication error. Use 'cf login' to authenticate in Cloud Foundry: ${message}`);
-            }
-            throw new Error(`Failed sending request to Cloud Foundry: ${message}`);
+    static processCfErrors(errors) {
+        if (!errors || errors.length === 0) {
+            return;
+        }
+        const authError = errors.find(e => e.title === "CF-NotAuthenticated" || e.code === 10002);
+        if (authError) {
+            throw new AuthenticationError(authError.detail);
         }
+        throw new Error(`Failed sending request to Cloud Foundry: ${JSON.stringify(errors)}`);
     }
     static async requestCfApi(url) {
         const response = await this.cfExecute(["curl", url]);
         const json = this.parseJson(response);
-        this.processErrors(json);
+        this.processCfErrors(json?.errors);
         const resources = json?.resources;
         const totalPages = json?.pagination?.total_pages;
         if (totalPages > 1) {
@@ -142,11 +144,17 @@ export default class CFUtil {
                     if (errorValues?.length > 0) {
                         log.verbose(this.errorsToString(errorValues));
                     }
+                    if (response.stdout === "\n") {
+                        throw new AuthenticationError();
+                    }
                     return response.stdout;
                 }
                 errors.add(response.error || response.stderr);
             }
             catch (error) {
+                if (error instanceof AuthenticationError) {
+                    throw error;
+                }
                 errors.add(error.message);
             }
         }

package/dist/util/movingHandler/changeFileMoveHandler.d.ts

@@ -0,0 +1,8 @@
+export declare const moveFiles: (inputFiles: ReadonlyMap<string, string>, prefix: string, id: string) => {
+    files: Map<string, string>;
+    renamingPaths: Map<string, string>;
+};
+export declare const moveFile: (filename: string, content: string, prefix: string, id: string) => {
+    newFilename: string;
+    renamingPath: Map<string, string>;
+};