@ui5/task-adaptation 1.4.2 → 1.5.0

package/dist/cache/cacheHolder.d.ts

@@ -0,0 +1,18 @@
+export default class CacheHolder {
+    private static TEMP_TASK_DIR;
+    private static getTempDir;
+    static read(repoName: string, token: string): Map<string, string> | undefined;
+    static write(repoName: string, token: string, files: Map<string, string>): Promise<void>;
+    private static isValid;
+    /**
+     * Clears cached files by repo name and token
+     */
+    static delete(...paths: string[]): void;
+    /**
+     * Clears all cached files
+     */
+    static clear(): void;
+    private static deleteDir;
+    static clearOutdatedExcept(repoName?: string, maxAgeMs?: number): Promise<void>;
+}
+export declare function cached(): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/cache/cacheHolder.js

@@ -0,0 +1,80 @@
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as path from "path";
+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: "_" })));
+    }
+    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);
+        }
+    }
+    static async write(repoName, token, files) {
+        this.delete(repoName);
+        if (this.isValid(repoName, "repoName") && this.isValid(token, "token")) {
+            await ResourceUtil.write(this.getTempDir(repoName, token), files);
+        }
+    }
+    static isValid(value, name) {
+        if (value == null || value === "") {
+            log.warn(`No '${name}' provided, skipping cache write`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clears cached files by repo name and token
+     */
+    static delete(...paths) {
+        this.deleteDir(this.getTempDir(...paths));
+    }
+    /**
+     * Clears all cached files
+     */
+    static clear() {
+        this.deleteDir(path.join(tempDir, this.TEMP_TASK_DIR));
+    }
+    static deleteDir(directory) {
+        if (fs.existsSync(directory)) {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    }
+    static async clearOutdatedExcept(repoName, maxAgeMs = 1000 * 60 * 60 * 24 * 30) {
+        const MAX_AGE = Date.now() - maxAgeMs; // 30 days by default
+        const directory = this.getTempDir();
+        if (!fs.existsSync(directory)) {
+            return;
+        }
+        const entries = await fsPromises.readdir(directory);
+        for (let entry of entries) {
+            const repoCacheDirectory = path.join(directory, entry);
+            const stats = await fsPromises.lstat(repoCacheDirectory);
+            if (stats.isDirectory() && stats.ctimeMs < MAX_AGE && (!repoName || entry !== encodeFilename(repoName))) {
+                await fsPromises.rm(repoCacheDirectory, { recursive: true, force: true });
+            }
+        }
+    }
+}
+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]);
+            CacheHolder.clearOutdatedExcept(args[0]);
+            if (files == null) {
+                files = await originalValue.apply(this, args);
+                await CacheHolder.write(args[0], args[1], files);
+            }
+            return files;
+        };
+    };
+}
+//# sourceMappingURL=cacheHolder.js.map

package/dist/i18nManager.js

@@ -2,6 +2,7 @@ import Comparator from "./annotations/comparator/comparator.js";
 import AnnotationDiffStructureError from "./model/annotationDiffStructureError.js";
 import { getUniqueName } from "./util/commonUtil.js";
 import { join } from "path/posix"; // Ensure standardized dir separators to ensure Windows compatibility
+import { slugify } from "transliteration";
 // To generate keys, english language is more common, so compare all other
 // languages with it
 export class PropertyValue {
@@ -69,15 +70,17 @@ export class I18nFileContent {
         const files = new Map();
         if (this.hasTranslations()) {
             this.properties.forEach((i18nLines, language) => {
-                let filename = "i18n";
-                if (language.i18n) {
-                    filename += "_" + language.i18n;
+                if (language.isDefault) {
+                    createI18nFile("i18n", i18nLines);
                 }
-                const filepath = join(i18nPathName, filename + ".properties");
-                files.set(filepath, [...i18nLines].map(([key, value]) => `${key}=${value}`).join("\n"));
+                createI18nFile("i18n_" + language.i18n, i18nLines);
             });
         }
         return files;
+        function createI18nFile(filename, i18nLines) {
+            const filepath = join(i18nPathName, filename + ".properties");
+            files.set(filepath, [...i18nLines].map(([key, value]) => `${key}=${value}`).toSorted().join("\n"));
+        }
     }
 }
 export default class I18nManager {
@@ -128,7 +131,7 @@ export default class I18nManager {
         properties file again. And then compare with the next language and so on
         and so on */
         let defaultAnnotation = I18nManager.extractDefaultLanguageAnnotation(annotationJsons);
-        if (annotationJsons.size > 0 && defaultAnnotation) {
+        if (defaultAnnotation && annotationJsons.size > 0) {
             defaultAnnotation = await this.populate([...annotationJsons], defaultAnnotation);
         }
         return defaultAnnotation;
@@ -152,7 +155,6 @@ export default class I18nManager {
         return p;
     }
     static extractDefaultLanguageAnnotation(annotationJsons) {
-        let json = null;
         for (const [language, json] of annotationJsons) {
             if (language.isDefault) {
                 annotationJsons.delete(language);
@@ -160,7 +162,7 @@ export default class I18nManager {
             }
         }
         const language = [...annotationJsons.keys()][0];
-        json = annotationJsons.get(language);
+        let json = annotationJsons.get(language);
         annotationJsons.delete(language);
         return { json, language };
     }
@@ -188,7 +190,7 @@ export default class I18nManager {
         if (typeof value !== "string") {
             throw new Error("Failed to create unique key from: " + JSON.stringify(value));
         }
-        const propertyName = value.replace(/\W/gi, "_").toUpperCase();
+        const propertyName = slugify(value, { separator: "_", uppercase: true }).replace(/\W/gi, "_");
         const key = getUniqueName([...this.existingKeys.keys()], propertyName);
         this.existingKeys.add(key);
         return key;

package/dist/index.js

@@ -1,9 +1,11 @@
 import * as dotenv from "dotenv";
 import { logBetaUsage, logBuilderVersion } from "./util/commonUtil.js";
-import AppVariantManager from "./appVariantManager.js";
-import BaseAppManager from "./baseAppManager.js";
-import I18NMerger from "./util/i18nMerger.js";
+import AppVariant from "./appVariantManager.js";
+import BaseApp from "./baseAppManager.js";
+import I18nMerger from "./util/i18nMerger.js";
+import ResourceUtil from "./util/resourceUtil.js";
 import { determineProcessor } from "./processors/processor.js";
+import FilesUtil from "./util/filesUtil.js";
 /**
  * Creates an appVariant bundle from the provided resources.
  */
@@ -13,12 +15,35 @@ export default ({ workspace, options, taskUtil }) => {
         logBuilderVersion();
         logBetaUsage();
         const processor = determineProcessor(options.configuration);
-        const appVariantResources = await AppVariantManager.getAppVariantResourcesToProcess(workspace);
-        const appVariantInfo = await AppVariantManager.process(appVariantResources, options.projectNamespace, taskUtil);
-        const baseAppFiles = await processor.getBaseAppFiles(appVariantInfo.reference);
-        const { resources, manifestInfo } = await BaseAppManager.process(baseAppFiles, appVariantInfo, options, processor);
-        const mergedResources = await I18NMerger.mergeI18NFiles(resources, appVariantResources, options.projectNamespace, manifestInfo.i18nPath, appVariantInfo, taskUtil);
-        await Promise.all(mergedResources.map(resource => workspace.write(resource)));
+        const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
+        const appVariantIdHierarchy = await processor.getAppVariantIdHierarchy(adaptationProject.reference);
+        // appVariantIdHierarchy contains original application on bottom and the
+        // latest app variant on top. We reverse the list to process original
+        // application first and then app variants in chronological order.
+        const reversedHierarchy = appVariantIdHierarchy.toReversed();
+        const fetchFilesPromises = reversedHierarchy.map(({ repoName, cachebusterToken }) => processor.fetch(repoName, cachebusterToken));
+        fetchFilesPromises.push(Promise.resolve(adaptationProject.files));
+        const adapt = async (baseAppFiles, appVariantFiles) => {
+            const baseApp = BaseApp.fromFiles(baseAppFiles);
+            const appVariant = AppVariant.fromFiles(appVariantFiles);
+            const adaptedFiles = await baseApp.adapt(appVariant, processor);
+            return I18nMerger.merge(adaptedFiles, baseApp.i18nPath, appVariant);
+        };
+        let files = await fetchFilesPromises.reduce(async (previousFiles, currentFiles) => {
+            return adapt(await previousFiles, await currentFiles);
+        }, fetchFilesPromises.shift());
+        if (files) {
+            const references = appVariantIdHierarchy.map(item => item.appVariantId);
+            files = FilesUtil.filter(files);
+            files = FilesUtil.rename(files, references, adaptationProject.id);
+            adaptationProject.omitDeletedResources(files, options.projectNamespace, taskUtil);
+            const writePromises = new Array();
+            files.forEach((content, filename) => {
+                const resource = ResourceUtil.createResource(filename, options.projectNamespace, content);
+                writePromises.push(workspace.write(resource));
+            });
+            await Promise.all(writePromises);
+        }
     }
     return process(workspace, taskUtil);
 };

package/dist/model/appVariantIdHierarchyItem.d.ts

@@ -0,0 +1,5 @@
+export default interface IAppVariantIdHierarchyItem {
+    appVariantId: string;
+    repoName: string;
+    cachebusterToken: string;
+}

package/dist/model/appVariantIdHierarchyItem.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=appVariantIdHierarchyItem.js.map

package/dist/model/configuration.d.ts

@@ -4,8 +4,8 @@ export interface IConfiguration {
     appId?: string;
     appName?: string;
     appVersion?: string;
-    spaceGuid?: string;
-    orgGuid?: string;
+    space?: string;
+    org?: string;
     sapCloudService?: string;
     destination?: string;
     type?: "cf" | "abap";

package/dist/model/language.d.ts

@@ -1,8 +1,8 @@
 export default class Language {
-    sap: string;
-    i18n: string;
+    readonly sap: string;
+    readonly i18n: string;
     isDefault: boolean;
-    constructor(sap: string, i18n: string);
+    constructor(sap: string, i18n: string, isDefault?: boolean);
     /**
      * Create a language array from languages in configuration and default language.
      * @param languages Typically an array of objects. Probably could be undefined.

package/dist/model/language.js

@@ -1,11 +1,12 @@
+const DEFAULT_LANGUAGE = "en";
 export default class Language {
     sap;
     i18n;
     isDefault;
-    constructor(sap, i18n) {
+    constructor(sap, i18n, isDefault = false) {
         this.sap = sap;
         this.i18n = i18n;
-        this.isDefault = sap === "";
+        this.isDefault = isDefault;
     }
     /**
      * Create a language array from languages in configuration and default language.
@@ -14,7 +15,6 @@ export default class Language {
      * followed by the passed config languages.
      */
     static create(languages) {
-        const defaultLanguage = new Language("", "");
         let configLanguages = [];
         if (languages !== undefined) {
             configLanguages = languages.map(item => {
@@ -30,7 +30,14 @@ export default class Language {
                 }
             });
         }
-        return [defaultLanguage, ...configLanguages];
+        let defaultLanguage = configLanguages.find(language => language.sap.toLowerCase() === DEFAULT_LANGUAGE) ?? configLanguages[0];
+        if (defaultLanguage) {
+            defaultLanguage.isDefault = true;
+        }
+        else {
+            return [new Language(DEFAULT_LANGUAGE.toUpperCase(), DEFAULT_LANGUAGE, true), ...configLanguages];
+        }
+        return configLanguages;
     }
     ;
 }

package/dist/model/types.d.ts

@@ -8,7 +8,7 @@ export interface ICreateServiceInstanceParams {
     spaceGuid: string;
     planName: string;
     serviceName: string;
-    serviceInstanceName?: string;
+    serviceInstanceName: string;
     tags: string[];
     parameters?: any;
 }
@@ -60,11 +60,13 @@ export interface IChange {
     texts?: IChangeText;
     layer?: string;
     content?: IChangeContent;
+    filename: string;
 }
 export interface IChangeText {
     i18n: string;
 }
 export interface IChangeContent {
+    dataSource?: any;
     bundleUrl?: string;
     fallbackLocale?: string;
     modelId?: string;

package/dist/processors/abapProcessor.d.ts

@@ -1,17 +1,17 @@
 import AbapRepoManager from "../repositories/abapRepoManager.js";
 import AnnotationManager from "../annotationManager.js";
-import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
+import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 import { IConfiguration } from "../model/types.js";
 import IProcessor from "./processor.js";
 export default class AbapProcessor implements IProcessor {
     private abapRepoManager;
     private configuration;
-    private cacheManager;
     private annotationManager;
-    constructor(configuration: IConfiguration, cacheManager: BaseAppFilesCacheManager, abapRepoManager: AbapRepoManager, annotationManager: AnnotationManager);
-    getBaseAppFiles(baseAppId: string): Promise<Map<string, string>>;
+    constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager, annotationManager: AnnotationManager);
+    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
+    fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
     validateConfiguration(): void;
-    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string): Promise<void>;
     getConfigurationType(): string;
     createAppVariantHierarchyItem(appVariantId: string, version: string): {
         appVariantId: string;

package/dist/processors/abapProcessor.js

@@ -1,26 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import Language from "../model/language.js";
+import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
 export default class AbapProcessor {
     abapRepoManager;
     configuration;
-    cacheManager;
     annotationManager;
-    constructor(configuration, cacheManager, abapRepoManager, annotationManager) {
+    constructor(configuration, abapRepoManager, annotationManager) {
         this.configuration = configuration;
         this.abapRepoManager = abapRepoManager;
-        this.cacheManager = cacheManager;
         this.annotationManager = annotationManager;
     }
-    getBaseAppFiles(baseAppId) {
-        return this.cacheManager.getFiles(() => this.abapRepoManager.getMetadata(baseAppId), () => this.abapRepoManager.downloadBaseAppFiles());
+    getAppVariantIdHierarchy(appId) {
+        return this.abapRepoManager.getAppVariantIdHierarchy(appId);
+    }
+    fetch(repoName, _cachebusterToken) {
+        return this.abapRepoManager.fetch(repoName);
     }
     validateConfiguration() {
         // validate general app config
         const properties = ["appName"];
         validateObject(this.configuration, properties, "should be specified in ui5.yaml configuration");
     }
-    async updateLandscapeSpecificContent(renamedBaseAppManifest, baseAppFiles) {
-        const files = await this.annotationManager.process(renamedBaseAppManifest, (Language.create(this.configuration.languages)));
+    async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles, appVariantId) {
+        const languages = Language.create(this.configuration.languages);
+        const files = await this.annotationManager.process(baseAppManifest, languages, appVariantId);
         if (baseAppFiles) {
             files.forEach((value, key) => baseAppFiles.set(key, value));
         }
@@ -36,4 +45,7 @@ export default class AbapProcessor {
         };
     }
 }
+__decorate([
+    cached()
+], AbapProcessor.prototype, "fetch", null);
 //# sourceMappingURL=abapProcessor.js.map

package/dist/processors/cfProcessor.d.ts

@@ -1,11 +1,11 @@
-import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
+import IAppInfo from "../model/appVariantIdHierarchyItem.js";
 import { IConfiguration } from "../model/types.js";
 import IProcessor from "./processor.js";
 export default class CFProcessor implements IProcessor {
     private configuration;
-    private cacheManager;
-    constructor(configuration: IConfiguration, cacheManager: BaseAppFilesCacheManager);
-    getBaseAppFiles(): Promise<Map<string, string>>;
+    constructor(configuration: IConfiguration);
+    getAppVariantIdHierarchy(appId: string): Promise<IAppInfo[]>;
+    fetch(_repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
     validateConfiguration(): void;
     updateLandscapeSpecificContent(renamedBaseAppManifest: any): Promise<void>;
     private updateCloudPlatform;

package/dist/processors/cfProcessor.js

@@ -1,14 +1,27 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import HTML5RepoManager from "../repositories/html5RepoManager.js";
+import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
 export default class CFProcessor {
     configuration;
-    cacheManager;
-    constructor(configuration, cacheManager) {
+    constructor(configuration) {
         this.configuration = configuration;
-        this.cacheManager = cacheManager;
     }
-    async getBaseAppFiles() {
-        return this.cacheManager.getFiles(() => HTML5RepoManager.getMetadata(this.configuration), () => HTML5RepoManager.getBaseAppFiles(this.configuration));
+    async getAppVariantIdHierarchy(appId) {
+        const metadata = await HTML5RepoManager.getMetadata(this.configuration);
+        return [{
+                repoName: this.configuration.appName,
+                appVariantId: appId,
+                cachebusterToken: metadata.changedOn
+            }];
+    }
+    fetch(_repoName, _cachebusterToken) {
+        return HTML5RepoManager.getBaseAppFiles(this.configuration);
     }
     validateConfiguration() {
         validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
@@ -16,20 +29,20 @@ export default class CFProcessor {
     async updateLandscapeSpecificContent(renamedBaseAppManifest) {
         this.updateCloudPlatform(renamedBaseAppManifest);
     }
-    updateCloudPlatform(renamedBaseAppManifest) {
-        const sapCloudService = renamedBaseAppManifest["sap.cloud"]?.service;
-        const sapPlatformCf = renamedBaseAppManifest["sap.platform.cf"];
-        if (sapPlatformCf && sapCloudService) {
+    updateCloudPlatform(baseAppManifest) {
+        const sapCloudService = baseAppManifest["sap.cloud"]?.service;
+        const sapPlatformCf = baseAppManifest["sap.platform.cf"];
+        if (sapPlatformCf?.oAuthScopes && sapCloudService) {
             sapPlatformCf.oAuthScopes = sapPlatformCf.oAuthScopes.map((scope) => scope.replace(`$XSAPPNAME.`, `$XSAPPNAME('${sapCloudService}').`));
         }
         if (this.configuration.sapCloudService) {
-            if (renamedBaseAppManifest["sap.cloud"] == null) {
-                renamedBaseAppManifest["sap.cloud"] = {};
+            if (baseAppManifest["sap.cloud"] == null) {
+                baseAppManifest["sap.cloud"] = {};
             }
-            renamedBaseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
+            baseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
         }
         else {
-            delete renamedBaseAppManifest["sap.cloud"];
+            delete baseAppManifest["sap.cloud"];
         }
     }
     getConfigurationType() {
@@ -42,4 +55,7 @@ export default class CFProcessor {
         };
     }
 }
+__decorate([
+    cached()
+], CFProcessor.prototype, "fetch", null);
 //# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -1,7 +1,9 @@
+import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 import { IConfiguration } from "../model/types.js";
 export default interface IProcessor {
+    getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
+    fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
     createAppVariantHierarchyItem(appVariantId: string, version: string): void;
-    getBaseAppFiles(baseAppId: string): Promise<Map<string, string>>;
-    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: ReadonlyMap<string, string>, appVariantId: string): Promise<void>;
 }
 export declare function determineProcessor(configuration: IConfiguration): IProcessor;

package/dist/processors/processor.js

@@ -1,15 +1,13 @@
 import AbapProcessor from "./abapProcessor.js";
 import AbapRepoManager from "../repositories/abapRepoManager.js";
 import AnnotationManager from "../annotationManager.js";
-import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
 import CFProcessor from "./cfProcessor.js";
 export function determineProcessor(configuration) {
-    const cacheManager = new BaseAppFilesCacheManager(configuration);
     const abapRepoManager = new AbapRepoManager(configuration);
     const annotationManager = new AnnotationManager(configuration, abapRepoManager);
     const processors = [
-        new CFProcessor(configuration, cacheManager),
-        new AbapProcessor(configuration, cacheManager, abapRepoManager, annotationManager)
+        new CFProcessor(configuration),
+        new AbapProcessor(configuration, abapRepoManager, annotationManager)
     ];
     let processor = processors.find(processor => processor.getConfigurationType() === configuration.type);
     if (processor) {
@@ -22,7 +20,7 @@ export function determineProcessor(configuration) {
                 processor.validateConfiguration();
                 return processor;
             }
-            catch (error) {
+            catch (_error) {
                 continue;
             }
         }

package/dist/repositories/abapRepoManager.d.ts

@@ -1,11 +1,13 @@
 import { IConfiguration, IMetadata } from "../model/types.js";
 import AbapProvider from "./abapProvider.js";
+import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
 export default class AbapRepoManager {
     private configuration;
     private abapProvider;
     constructor(configuration: IConfiguration, abapProvider?: AbapProvider);
+    getAppVariantIdHierarchy(id: string): Promise<IAppVariantIdHierarchyItem[]>;
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
     downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
     getMetadata(id: string): Promise<IMetadata>;
-    downloadBaseAppFiles(): Promise<Map<string, string>>;
+    fetch(repoName: string): Promise<Map<string, string>>;
 }

package/dist/repositories/abapRepoManager.js

@@ -20,6 +20,26 @@ export default class AbapRepoManager {
         this.configuration = configuration;
         this.abapProvider = abapProvider ? abapProvider : new AbapProvider();
     }
+    async getAppVariantIdHierarchy(id) {
+        const provider = await this.abapProvider.get(this.configuration);
+        const lrep = provider.getLayeredRepository();
+        const response = await lrep.get("/dta_folder/app_info", {
+            params: { id }
+        });
+        if (response.status === 200) {
+            return JSON.parse(response.data)?.appVariantIdHierarchy;
+        }
+        else if (this.configuration.appName) {
+            // Fallback to old API on old ABAP backend or CF for backward compatibility
+            const metadataResponse = await this.getMetadata(id);
+            return [{
+                    repoName: this.configuration.appName,
+                    appVariantId: id,
+                    cachebusterToken: metadataResponse.changedOn
+                }];
+        }
+        throw new Error(`App variant id hierarchy for app id '${id}' is not provided`);
+    }
     async getAnnotationMetadata(uri) {
         const provider = await this.abapProvider.get(this.configuration);
         const response = await provider.head(uri);
@@ -48,12 +68,11 @@ export default class AbapRepoManager {
             id
         };
     }
-    async downloadBaseAppFiles() {
-        const { destination, appName } = this.configuration;
-        const encodedAppName = encodeURIComponent(appName);
+    async fetch(repoName) {
+        const encodedRepoName = encodeURIComponent(repoName);
         const provider = await this.abapProvider.get(this.configuration);
         const ui5Repo = provider.getUi5AbapRepository();
-        const response = await ui5Repo.get(`/Repositories('${encodedAppName}')`, {
+        const response = await ui5Repo.get(`/Repositories('${encodedRepoName}')`, {
             params: {
                 DownloadFiles: "RUNTIME",
                 CodePage: "UTF8",
@@ -65,7 +84,7 @@ export default class AbapRepoManager {
             const buffer = Buffer.from(data.d.ZipArchive, "base64");
             return unzipZipEntries(buffer);
         }
-        throw new Error(`App '${appName}' from '${destination}' doesn't contain files`);
+        throw new Error(`App '${repoName}' doesn't contain files`);
     }
 }
 //# sourceMappingURL=abapRepoManager.js.map

package/dist/repositories/html5RepoManager.js

@@ -13,7 +13,7 @@ export default class HTML5RepoManager {
         return this.requestMetadata(configuration, baseUri, token);
     }
     static async getHtml5RepoInfo(configuration) {
-        const spaceGuid = await CFUtil.getSpaceGuid(configuration?.spaceGuid);
+        const spaceGuid = await CFUtil.getSpaceGuid(configuration?.space);
         const credentials = await this.getHTML5Credentials(spaceGuid);
         const token = await this.getToken(credentials);
         return {
@@ -33,7 +33,8 @@ export default class HTML5RepoManager {
         const createParams = {
             spaceGuid,
             planName: PLAN_NAME,
-            serviceName: SERVIСE_INSTANCE_NAME,
+            serviceName: "html5-apps-repo",
+            serviceInstanceName: SERVIСE_INSTANCE_NAME,
             tags: ["html5-apps-repo-rt"]
         };
         const serviceKeys = await CFUtil.getServiceInstanceKeys(getParams, createParams);

package/dist/util/cfUtil.d.ts

@@ -14,6 +14,7 @@ export default class CFUtil {
     private static getServiceKeys;
     private static createServiceKey;
     private static getServiceInstance;
+    static processErrors(json: any): void;
     static requestCfApi(url: string): Promise<IResource[]>;
     static getOAuthToken(): Promise<string>;
     private static cfExecute;