@ui5/task-adaptation 1.1.0 → 1.1.2

package/dist/annotations/dataSource/dataSourceODataAnnotationBeta.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataSource_1 = require("./dataSource");
+const traverseReferences_1 = require("../transformers/traverseReferences");
+class DataSourceODataAnnotation extends dataSource_1.default {
+    constructor(name, uri, dataSourceJson, metadataUrl) {
+        super(name, uri);
+        this.dataSourceJson = dataSourceJson;
+        this.jsonTransformers = [
+            new traverseReferences_1.default(metadataUrl)
+        ];
+    }
+    updateManifest() {
+        this.dataSourceJson.uri = this.getFilename();
+    }
+}
+exports.default = DataSourceODataAnnotation;
+//# sourceMappingURL=dataSourceODataAnnotationBeta.js.map

package/dist/annotations/serviceRequestor.d.ts

@@ -1,17 +1,9 @@
 import AbapRepoManager from "../repositories/abapRepoManager";
 import { IConfiguration } from "../model/types";
 import Language from "../model/language";
-export interface ILanguageXmlContent {
-    language: Language;
-    xml: string;
-}
-export interface ILanguageJsonContent {
-    language: Language;
-    json: any;
-}
 export default class ServiceRequestor {
     private abapRepoManager;
     private configuration;
     constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager);
-    downloadAnnotation(uri: string, name: string, language: Language): Promise<ILanguageXmlContent>;
+    downloadAnnotation(uri: string, name: string, language: Language): Promise<string>;
 }

package/dist/annotations/serviceRequestor.js

@@ -1,36 +1,71 @@
 "use strict";
+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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const annotationsCacheManager_1 = require("../cache/annotationsCacheManager");
+const serverError_1 = require("../model/serverError");
+const commonUtil_1 = require("../util/commonUtil");
 const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::ServiceRequestor");
+function retryOnError(maxRetries) {
+    return (_target, _propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            let retries = 0;
+            while (true) {
+                try {
+                    const result = await originalMethod.apply(this, args);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof serverError_1.default) {
+                        if (retries === maxRetries) {
+                            throw new Error(`Error occurred: ${error.message}. Please try again if this is a temporary issue. If not, please create a ticket on CA-UI5-ABA-AIDX`);
+                        }
+                        retries++;
+                    }
+                    else {
+                        throw new Error(`Failed to fetch annotation by '${args[0]}': ${error.message}`);
+                    }
+                }
+            }
+        };
+        return descriptor;
+    };
+}
 class ServiceRequestor {
     constructor(configuration, abapRepoManager) {
         this.abapRepoManager = abapRepoManager;
         this.configuration = configuration;
     }
     async downloadAnnotation(uri, name, language) {
+        let cacheName = name;
         if (language.sap) {
             uri += `?sap-language=${language.sap}`;
-            name += `-${language.sap}`;
+            cacheName += `-${language.sap}`;
         }
-        const cacheManager = new annotationsCacheManager_1.default(this.configuration, name);
-        log.verbose(`Getting annotation '${name}' ${language.sap} by '${uri}'`);
-        try {
-            let files;
-            if (this.configuration.enableAnnotationCache) {
-                files = await cacheManager.getFiles(() => this.abapRepoManager.getAnnotationMetadata(uri), () => this.abapRepoManager.downloadAnnotationFile(uri));
-            }
-            else {
-                files = await this.abapRepoManager.downloadAnnotationFile(uri);
-            }
-            if (!files || files.size === 0) {
-                throw new Error(`No files were fetched for '${name}' by '${uri}'`);
-            }
-            return { language, xml: [...files][0][1] };
+        const cacheManager = new annotationsCacheManager_1.default(this.configuration, cacheName);
+        log.verbose(`Getting annotation '${cacheName}' ${language} by '${uri}'`);
+        let files;
+        if (this.configuration.enableAnnotationCache) {
+            files = await cacheManager.getFiles(() => this.abapRepoManager.getAnnotationMetadata(uri), () => this.abapRepoManager.downloadAnnotationFile(uri));
+        }
+        else {
+            files = await this.abapRepoManager.downloadAnnotationFile(uri);
         }
-        catch (error) {
-            throw new Error(`Failed to fetch annotation by '${uri}': ${error.message}`);
+        if (!files || files.size === 0) {
+            throw new Error(`No files were fetched for '${name}' by '${uri}'`);
         }
+        const xml = [...files][0][1];
+        (0, commonUtil_1.writeTempAnnotations)(this.configuration, name, language, xml);
+        return xml;
     }
 }
+__decorate([
+    retryOnError(1)
+], ServiceRequestor.prototype, "downloadAnnotation", null);
 exports.default = ServiceRequestor;
 //# sourceMappingURL=serviceRequestor.js.map

package/dist/annotations/transformers/convertV2ToV4.d.ts

@@ -0,0 +1,4 @@
+import Transformer, { TransformerInput } from "./transformer";
+export default class ConvertV2ToV4 implements Transformer {
+    transform({ json, xml }: TransformerInput): any;
+}

package/dist/annotations/transformers/convertV2ToV4.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataJsonUtil_1 = require("../converter/metadataJsonUtil");
+const ui5JsonConverter_1 = require("../converter/ui5JsonConverter");
+const ui5XmlConverter_1 = require("../converter/ui5XmlConverter");
+class ConvertV2ToV4 {
+    transform({ json, xml }) {
+        if (metadataJsonUtil_1.default.getVersion(json) !== "4.0") {
+            const annotationsV4 = ui5JsonConverter_1.default.convertAnnotations(ui5XmlConverter_1.default.convertV2(xml));
+            metadataJsonUtil_1.default.setAnnotations(json, annotationsV4);
+        }
+        return json;
+    }
+}
+exports.default = ConvertV2ToV4;
+//# sourceMappingURL=convertV2ToV4.js.map

package/dist/annotations/transformers/makeAnnotationNamespaceUnique.d.ts

@@ -0,0 +1,6 @@
+import Transformer, { TransformerInput } from "./transformer";
+export default class MakeAnnotationNamespaceUnique implements Transformer {
+    transform({ json, uri }: TransformerInput): any;
+    private createReference;
+    private getReferences;
+}

package/dist/annotations/transformers/makeAnnotationNamespaceUnique.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataJsonUtil_1 = require("../converter/metadataJsonUtil");
+const crc16_1 = require("crc/crc16");
+class MakeAnnotationNamespaceUnique {
+    transform({ json, uri }) {
+        const uniquePart = (0, crc16_1.default)(uri).toString(16);
+        // First add current schema as reference
+        const schema = metadataJsonUtil_1.default.getSchemaNode(json);
+        const references = this.getReferences(json);
+        references.push(this.createReference(schema, uri));
+        // Then rename the namespace/alias
+        schema._attributes.Namespace += "." + uniquePart;
+        delete schema._attributes["Alias"];
+        return json;
+    }
+    createReference(schema, uri) {
+        const attributes = {
+            Namespace: schema._attributes.Namespace
+        };
+        if (schema._attributes.Alias) {
+            attributes.Alias = schema._attributes.Alias;
+        }
+        ;
+        return {
+            _attributes: {
+                Uri: uri
+            },
+            "edmx:Include": {
+                _attributes: attributes
+            }
+        };
+    }
+    getReferences(json) {
+        const REFERENCE_NODE_NAME = "edmx:Reference";
+        const references = metadataJsonUtil_1.default.getEdmx(json)[REFERENCE_NODE_NAME];
+        if (!Array.isArray(references)) {
+            metadataJsonUtil_1.default.getEdmx(json)[REFERENCE_NODE_NAME] = [references];
+        }
+        return metadataJsonUtil_1.default.getEdmx(json)[REFERENCE_NODE_NAME];
+    }
+}
+exports.default = MakeAnnotationNamespaceUnique;
+//# sourceMappingURL=makeAnnotationNamespaceUnique.js.map

package/dist/annotations/transformers/removeAllSchemaNodesExceptAnnotations.d.ts

@@ -0,0 +1,4 @@
+import Transformer, { TransformerInput } from "./transformer";
+export default class RemoveAllSchemaNodesExceptAnnotations implements Transformer {
+    transform({ json }: TransformerInput): any;
+}

package/dist/annotations/transformers/removeAllSchemaNodesExceptAnnotations.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataJsonUtil_1 = require("../converter/metadataJsonUtil");
+class RemoveAllSchemaNodesExceptAnnotations {
+    transform({ json }) {
+        const schema = metadataJsonUtil_1.default.getSchemaNode(json);
+        for (const key of Object.keys(schema)) {
+            if (key !== "_attributes" && key !== "Annotations") {
+                delete schema[key];
+            }
+        }
+        return json;
+        // TODO: remove also references not used in annotations
+    }
+}
+exports.default = RemoveAllSchemaNodesExceptAnnotations;
+//# sourceMappingURL=removeAllSchemaNodesExceptAnnotations.js.map

package/dist/annotations/transformers/transformer.d.ts

@@ -0,0 +1,12 @@
+import Language from "../../model/language";
+import ServiceRequestor from "../serviceRequestor";
+export interface TransformerInput {
+    uri: string;
+    json: any;
+    xml: string;
+    language: Language;
+    serviceRequestor: ServiceRequestor;
+}
+export default interface Transformer {
+    transform(input: TransformerInput): any;
+}

package/dist/annotations/transformers/transformer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transformer.js.map

package/dist/annotations/transformers/traverseReferences.d.ts

@@ -0,0 +1,9 @@
+import Transformer, { TransformerInput } from "../transformers/transformer";
+export default class TraverseReferences implements Transformer {
+    private metadataUrl?;
+    constructor(metadataUrl?: string);
+    transform({ json, language, serviceRequestor, uri: parentUrl }: TransformerInput): Promise<void>;
+    private shouldIgnoreUrl;
+    private mergeAnnotations;
+    private static isTraversable;
+}

package/dist/annotations/transformers/traverseReferences.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadataJsonUtil_1 = require("../converter/metadataJsonUtil");
+const dataSourceODataAnnotationBeta_1 = require("../dataSource/dataSourceODataAnnotationBeta");
+const urlUtil_1 = require("../../util/urlUtil");
+class TraverseReferences {
+    constructor(metadataUrl) {
+        this.metadataUrl = metadataUrl;
+    }
+    async transform({ json, language, serviceRequestor, uri: parentUrl }) {
+        const references = metadataJsonUtil_1.default.getReferences(json).filter(TraverseReferences.isTraversable);
+        const promises = [];
+        for (const { includes, uri: relativeUrl } of references) {
+            const absoluteUrl = urlUtil_1.default.join(urlUtil_1.default.getResourcePath(relativeUrl), parentUrl);
+            if (this.shouldIgnoreUrl(absoluteUrl, [parentUrl, this.metadataUrl])) {
+                // If reference to metadata or its parent, don't traverse
+                continue;
+            }
+            const name = includes[0]?.namespace;
+            const dataSource = new dataSourceODataAnnotationBeta_1.default(name, absoluteUrl, {}, this.metadataUrl);
+            promises.push(dataSource.downloadAnnotation(language, serviceRequestor)
+                .then(childAnnotation => ({ name, childAnnotation })));
+        }
+        const childAnnotations = await Promise.all(promises);
+        for (const { childAnnotation } of childAnnotations) {
+            this.mergeAnnotations(json, childAnnotation);
+        }
+        return json;
+    }
+    shouldIgnoreUrl(referenceUrl, urlsToIgnore) {
+        const toResourcePath = (url) => urlUtil_1.default.getResourcePath(url);
+        const isEqual = (a, b) => a && b && a.toLowerCase() === b.toLowerCase();
+        return urlsToIgnore.map(toResourcePath).some(url => isEqual(referenceUrl, url));
+    }
+    mergeAnnotations(parentJson, nestedJson) {
+        const parentAnnotations = metadataJsonUtil_1.default.getAnnotations(parentJson);
+        const parentMapByTarget = metadataJsonUtil_1.default.mapAnnotationsPerTarget(parentJson);
+        const nestedMapByTarget = metadataJsonUtil_1.default.mapAnnotationsPerTarget(nestedJson);
+        for (const nested of [...nestedMapByTarget].map(([target, { json }]) => ({ target, json }))) {
+            // If we found parent annotation with the same target - we extend it
+            // with missing <Annotation> nodes. If not, just add it to the end.
+            // Annotations do not have a merge logic If same target & term is in
+            // parent and nested, parent wins (same logic as UI5 in
+            // sap/ui/model/odata/v4/ODataMetaModel.js mergeAnnotations).
+            const parent = parentMapByTarget.get(nested.target);
+            if (parent) {
+                metadataJsonUtil_1.default.toArrayTransform(parent.json, "Annotation");
+                const parentTerms = parent.json.Annotation.map((item) => item._attributes.Term);
+                for (const nestedAnnotation of metadataJsonUtil_1.default.toArrayReadOnly(nested.json.Annotation)) {
+                    if (!parentTerms.includes(nestedAnnotation._attributes.Term)) {
+                        parent.json.Annotation.push(nestedAnnotation);
+                    }
+                }
+            }
+            else {
+                parentAnnotations.push(nested.json);
+            }
+        }
+        metadataJsonUtil_1.default.setAnnotations(parentJson, parentAnnotations);
+    }
+    static isTraversable(reference) {
+        const IGNORED_NAMESPACES = ["com.sap.vocabularies.", "Org.OData."];
+        return !reference.includes.some(include => IGNORED_NAMESPACES.some(namespace => include.namespace.startsWith(namespace)));
+    }
+}
+exports.default = TraverseReferences;
+//# sourceMappingURL=traverseReferences.js.map

package/dist/appVariantManager.d.ts

@@ -1,10 +1,12 @@
 import { IAppVariantInfo } from "./model/types";
 export default class AppVariantManager {
     static process(appVariantResources: any[], projectNamespace: string, taskUtil: any): Promise<IAppVariantInfo>;
-    static getAppVariantResources(workspace: any): Promise<any[]>;
-    static renameChanges(appVariantResources: any[], projectNamespace: string, appVariantInfo: IAppVariantInfo): Promise<void>;
+    static getAppVariantResourcesToProcess(workspace: any): Promise<any[]>;
+    static updateChanges(appVariantResources: any[], projectNamespace: string): Promise<void>;
     private static isManifestChange;
     private static isManifestAppVariant;
     static getAppVariantInfo(appVariantResources: any[]): Promise<IAppVariantInfo>;
+    private static validateManifest;
+    private static updateRelativePaths;
     private static omitFiles;
 }

package/dist/appVariantManager.js

@@ -3,24 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const resourceUtil_1 = require("./util/resourceUtil");
 const path_1 = require("path");
 const commonUtil_1 = require("./util/commonUtil");
-const EXTENSIONS = "js,json,xml,html,properties,change,appdescr_variant";
+const EXTENSIONS_TO_PROCESS = "js,json,xml,html,properties,change,appdescr_variant,ctrl_variant,ctrl_variant_change,ctrl_variant_management_change,variant,fioriversion,codeChange,xmlViewChange,context";
 class AppVariantManager {
     static async process(appVariantResources, projectNamespace, taskUtil) {
-        const appVariantInfo = await this.getAppVariantInfo(appVariantResources);
         for (const resource of appVariantResources) {
             this.omitFiles(resource, taskUtil);
         }
-        await this.renameChanges(appVariantResources, projectNamespace, appVariantInfo);
-        return appVariantInfo;
+        await this.updateChanges(appVariantResources, projectNamespace);
+        return this.getAppVariantInfo(appVariantResources);
     }
-    static getAppVariantResources(workspace) {
-        return workspace.byGlob(`/**/*.{${EXTENSIONS}}`);
+    static getAppVariantResourcesToProcess(workspace) {
+        return workspace.byGlob(`/**/*.{${EXTENSIONS_TO_PROCESS}}`);
     }
-    static async renameChanges(appVariantResources, projectNamespace, appVariantInfo) {
+    static async updateChanges(appVariantResources, projectNamespace) {
         const changesFolder = resourceUtil_1.default.getResourcePath(projectNamespace, "changes");
         const changes = new Map();
         const resourcesByPath = new Map();
+        let manifest;
         for (const resource of appVariantResources) {
+            if (this.isManifestAppVariant(resource)) {
+                manifest = await resourceUtil_1.default.getJson(resource);
+            }
             const resourcePath = resource.getPath();
             const basename = path_1.posix.dirname(resourcePath);
             if (basename.startsWith(changesFolder)) {
@@ -28,7 +31,9 @@ class AppVariantManager {
                 resourcesByPath.set(resourcePath, resource);
             }
         }
-        const renamedChanges = (0, commonUtil_1.renameResources)(changes, appVariantInfo.reference, appVariantInfo.id);
+        this.updateRelativePaths(changes, projectNamespace);
+        this.validateManifest(manifest);
+        const renamedChanges = (0, commonUtil_1.renameResources)(changes, manifest.reference, manifest.id);
         renamedChanges.forEach((renamedContent, resourcePath) => {
             const resource = resourcesByPath.get(resourcePath);
             resourceUtil_1.default.setString(resource, renamedContent);
@@ -36,7 +41,8 @@ class AppVariantManager {
     }
     static isManifestChange(resource) {
         const changesManifestFolder = path_1.posix.join("changes", "manifest");
-        const dirname = path_1.posix.dirname(resource.getPath());
+        const resourcePath = typeof resource === "string" ? resource : resource.getPath();
+        const dirname = path_1.posix.dirname(resourcePath);
         return dirname.endsWith(changesManifestFolder);
     }
     static isManifestAppVariant(resource) {
@@ -49,22 +55,42 @@ class AppVariantManager {
         const manifestChanges = [];
         for (const resource of appVariantResources) {
             if (this.isManifestAppVariant(resource)) {
-                manifest = await resourceUtil_1.default.getString(resource).then(JSON.parse);
+                manifest = await resourceUtil_1.default.getJson(resource);
             }
             else if (this.isManifestChange(resource)) {
                 const content = await resourceUtil_1.default.getString(resource);
                 manifestChanges.push(JSON.parse(content));
             }
         }
-        if (manifest) {
-            return {
-                id: manifest.id,
-                reference: manifest.reference,
-                manifest,
-                manifestChanges
-            };
+        this.validateManifest(manifest);
+        return {
+            id: manifest.id,
+            reference: manifest.reference,
+            layer: manifest.layer,
+            changes: manifestChanges.concat(manifest.content)
+        };
+    }
+    static validateManifest(manifest) {
+        if (!manifest) {
+            throw new Error("Adaptation project should contain manifest.appdescr_variant");
         }
-        throw new Error("Adaptation project should contain manifest.appdescr_variant");
+    }
+    // TODO In future this should be handled by merger which needs to know change and target location
+    static updateRelativePaths(changes, projectNamespace) {
+        changes.forEach((jsonString, resourcePath) => {
+            if (this.isManifestChange(resourcePath)) {
+                const change = JSON.parse(jsonString);
+                if (change.changeType === "appdescr_app_addAnnotationsToOData") {
+                    for (const dataSource of Object.values(change.content.dataSource)) {
+                        if (!dataSource.uri.startsWith("/")) {
+                            const basepath = path_1.posix.dirname(resourceUtil_1.default.relativeToRoot(resourcePath, projectNamespace));
+                            dataSource.uri = path_1.posix.join(basepath.replace(/^\//, ""), dataSource.uri);
+                        }
+                    }
+                    changes.set(resourcePath, JSON.stringify(change));
+                }
+            }
+        });
     }
     static omitFiles(resource, taskUtil) {
         if (this.isManifestAppVariant(resource) || this.isManifestChange(resource)) {

package/dist/baseAppManager.d.ts

@@ -21,8 +21,9 @@ export default class BaseAppManager {
     private static extractI18NFromBundleUrl;
     private static getBaseAppManifest;
     private static fillAppVariantIdHierarchy;
+    private static VALIDATION_RULES;
     static validateProperty(value: string, property: string): void;
-    static applyDescriptorChanges(baseAppManifest: any, appVariantInfo: IAppVariantInfo): Promise<void>;
+    static applyDescriptorChanges(baseAppManifest: any, { layer, changes, id }: IAppVariantInfo): Promise<void>;
     private static adjustAddNewModelEnhanceWith;
     static writeToWorkspace(baseAppFiles: Map<string, string>, projectNamespace: string): any[];
 }

package/dist/baseAppManager.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commonUtil_1 = require("./util/commonUtil");
 const buildStrategy_1 = require("./buildStrategy");
 const resourceUtil_1 = require("./util/resourceUtil");
-const path_1 = require("path");
 const commonUtil_2 = require("./util/commonUtil");
 const { RegistrationBuild, Applier, Change } = require("../dist/bundle");
-const resourceFactory = require("@ui5/fs/lib/resourceFactory");
 const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::BaseAppManager");
 class BaseAppManager {
     static async process(baseAppFiles, appVariantInfo, options, processor) {
         const baseAppManifest = this.getBaseAppManifest(baseAppFiles);
         const { id, version } = this.getIdVersion(baseAppManifest.content);
+        this.validateProperty(id, "sap.app/id");
+        this.validateProperty(version, "sap.app/applicationVersion/version");
         const renamedBaseAppFiles = (0, commonUtil_2.renameResources)(baseAppFiles, appVariantInfo.reference, appVariantInfo.id);
         const { filepath, content } = this.getBaseAppManifest(renamedBaseAppFiles);
         await processor.updateLandscapeSpecificContent(content, renamedBaseAppFiles);
@@ -59,19 +59,17 @@ class BaseAppManager {
         return (0, commonUtil_1.removePropertiesExtension)(i18nNode["bundleUrl"]);
     }
     static getBaseAppManifest(baseAppFiles) {
-        let filepath = [...baseAppFiles.keys()].find(filepath => filepath.endsWith("manifest.json"));
-        if (filepath) {
+        const manifestContent = baseAppFiles.get("manifest.json");
+        if (manifestContent) {
             return {
-                content: JSON.parse(baseAppFiles.get(filepath)),
-                filepath
+                content: JSON.parse(manifestContent),
+                filepath: "manifest.json"
             };
         }
         throw new Error("Original application should have manifest.json in root folder");
     }
     static fillAppVariantIdHierarchy(processor, id, version, baseAppManifest) {
         log.verbose("Filling up app variant hierarchy in manifest.json");
-        this.validateProperty(id, "sap.app/id");
-        this.validateProperty(version, "sap.app/applicationVersion/version");
         if (baseAppManifest["sap.ui5"] == null) {
             baseAppManifest["sap.ui5"] = {};
         }
@@ -85,25 +83,24 @@ class BaseAppManager {
         if (!value) {
             throw new Error(`Original application manifest should have ${property}`);
         }
+        let validatationRule = this.VALIDATION_RULES.get(property);
+        if (validatationRule) {
+            validatationRule(value);
+        }
     }
-    static async applyDescriptorChanges(baseAppManifest, appVariantInfo) {
+    static async applyDescriptorChanges(baseAppManifest, { layer, changes, id }) {
         log.verbose("Applying appVariant changes");
-        const strategy = new buildStrategy_1.default(RegistrationBuild);
-        const { manifest } = appVariantInfo;
-        const allChanges = [
-            ...manifest.content,
-            ...appVariantInfo.manifestChanges
-        ];
         const changesContent = new Array();
-        const i18nBundleName = (0, commonUtil_1.dotToUnderscore)(appVariantInfo.id);
-        for (const change of structuredClone(allChanges)) {
-            if (manifest.layer) {
-                change.layer = manifest.layer;
+        const i18nBundleName = (0, commonUtil_1.dotToUnderscore)(id);
+        for (const change of structuredClone(changes)) {
+            if (layer) {
+                change.layer = layer;
             }
-            this.adjustAddNewModelEnhanceWith(change, i18nBundleName);
             changesContent.push(new Change(change));
+            this.adjustAddNewModelEnhanceWith(change, i18nBundleName);
         }
         if (changesContent.length > 0) {
+            const strategy = new buildStrategy_1.default(RegistrationBuild);
             await Applier.applyChanges(baseAppManifest, changesContent, strategy);
         }
     }
@@ -121,17 +118,14 @@ class BaseAppManager {
     }
     static writeToWorkspace(baseAppFiles, projectNamespace) {
         const IGNORE_FILES = [
-            "/manifest-bundle.zip",
-            "/Component-preload.js",
-            "/sap-ui-cachebuster-info.json"
+            "manifest-bundle.zip",
+            "Component-preload.js",
+            "sap-ui-cachebuster-info.json"
         ];
         const resources = [];
         for (let filename of baseAppFiles.keys()) {
             if (!IGNORE_FILES.includes(filename)) {
-                const resource = resourceFactory.createResource({
-                    path: getPath(filename, projectNamespace),
-                    string: baseAppFiles.get(filename)
-                });
+                const resource = resourceUtil_1.default.createResource(filename, projectNamespace, baseAppFiles.get(filename));
                 resources.push(resource);
             }
         }
@@ -139,8 +133,9 @@ class BaseAppManager {
     }
 }
 exports.default = BaseAppManager;
-const getPath = (filename, projectNamespace) => {
-    const rootFolder = resourceUtil_1.default.getRootFolder(projectNamespace);
-    return path_1.posix.join(rootFolder, filename);
-};
+BaseAppManager.VALIDATION_RULES = new Map([["sap.app/id", (value) => {
+            if (!value.includes(".")) {
+                throw new Error(`The original application id '${value}' should consist of multiple segments split by dot, e.g.: original.id`);
+            }
+        }]]);
 //# sourceMappingURL=baseAppManager.js.map