@ui5/task-adaptation 1.0.15 → 1.0.16

package/dist/cache/cacheManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const resourceUtil_1 = require("../util/resourceUtil");
+const rimraf = require("rimraf");
+const tempFolder = require('temp-dir');
+class CacheManager {
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    getTempFolder() {
+        return path.join(tempFolder, this.getTempId());
+    }
+    async getFiles(fetchMetadata, fetchFiles) {
+        const tempMetadata = this.readTempMetadata();
+        const metadata = await fetchMetadata();
+        if (this.isMetadataSame(tempMetadata, metadata)) {
+            return this.readTemp();
+        }
+        else {
+            const files = await fetchFiles();
+            if (files?.size > 0) {
+                await this.writeTemp(files, metadata);
+            }
+            return files;
+        }
+    }
+    isMetadataSame(tempMetadata, metadata) {
+        return tempMetadata && metadata && tempMetadata.changedOn === metadata.changedOn;
+    }
+    readTempMetadata() {
+        const tempFolder = this.getTempFolder();
+        const filename = this.getMetadataFilename();
+        const metadataPath = path.resolve(tempFolder, filename);
+        if (fs.existsSync(metadataPath)) {
+            return JSON.parse(fs.readFileSync(metadataPath, { encoding: "utf-8" }));
+        }
+    }
+    writeTemp(files, metadata) {
+        this.deleteTemp();
+        const filesToCache = this.getFilesToCache(files, metadata);
+        return resourceUtil_1.default.write(this.getTempFolder(), filesToCache);
+    }
+    async readTemp() {
+        const files = new Map();
+        const tempFolder = this.getTempFolder();
+        if (fs.existsSync(tempFolder)) {
+            resourceUtil_1.default.read(tempFolder, tempFolder, files, [this.getMetadataFilename()]);
+        }
+        return files;
+    }
+    deleteTemp() {
+        rimraf.sync(this.getTempFolder());
+    }
+    normalizeId(id) {
+        return id.replace(/\/\\/g, "_");
+    }
+    getFilesToCache(files, metadata) {
+        const filename = this.getMetadataFilename();
+        const filesClone = new Map([...files]);
+        filesClone.set(filename, JSON.stringify(metadata));
+        return filesClone;
+    }
+}
+exports.default = CacheManager;
+//# sourceMappingURL=cacheManager.js.map

package/dist/index.js

@@ -1,29 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = require("dotenv");
 const appVariantManager_1 = require("./appVariantManager");
 const baseAppManager_1 = require("./baseAppManager");
-const updateCache_1 = require("./updateCache");
+const processor_1 = require("./processors/processor");
 /**
  * Creates an appVariant bundle from the provided resources.
  */
 module.exports = ({ workspace, options, taskUtil }) => {
-    function process(workspace, taskUtil) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const baseAppFiles = updateCache_1.default(options.configuration);
-            const appVariantResources = yield appVariantManager_1.default.getAppVariantResources(workspace);
-            const appVariantInfo = appVariantManager_1.default.process(appVariantResources, options.projectNamespace, taskUtil);
-            const baseAppResources = yield baseAppManager_1.default.process(yield baseAppFiles, yield appVariantInfo, options);
-            yield Promise.all(appVariantResources.concat(baseAppResources).map(resource => workspace.write(resource)));
-        });
+    dotenv.config();
+    async function process(workspace, taskUtil) {
+        const processor = processor_1.determineProcessor(options.configuration);
+        const appVariantResources = await appVariantManager_1.default.getAppVariantResources(workspace);
+        const appVariantInfo = await appVariantManager_1.default.process(appVariantResources, options.projectNamespace, taskUtil);
+        const baseAppFiles = await processor.getBaseAppFiles(appVariantInfo.reference);
+        const baseAppResources = await baseAppManager_1.default.process(baseAppFiles, appVariantInfo, options, processor);
+        await Promise.all(appVariantResources.concat(baseAppResources).map(resource => workspace.write(resource)));
     }
     return process(workspace, taskUtil);
 };

package/dist/model/noAuthorizationProvidedError.d.ts

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

package/dist/model/noAuthorizationProvidedError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoAuthorizationProvidedError extends Error {
+    constructor(uri) {
+        super(`Request requires authorization: '${uri}'`);
+    }
+}
+exports.default = NoAuthorizationProvidedError;
+//# sourceMappingURL=noAuthorizationProvidedError.js.map

package/dist/model/types.d.ts

@@ -6,6 +6,10 @@ export interface IConfiguration {
     spaceGuid?: string;
     orgGuid?: string;
     sapCloudService?: string;
+    destination?: string;
+    credentials?: IAuth;
+    type?: "cf" | "abap";
+    languages?: string[];
 }
 export interface IProjectOptions {
     configuration: IConfiguration;
@@ -82,6 +86,14 @@ export interface IHTML5RepoInfo {
     token: string;
     baseUri: string;
 }
+export interface IAuth {
+    username: string;
+    password: string;
+}
+export interface IMetadata {
+    changedOn: string;
+    id?: string;
+}
 export declare type KeyedMap<T, K extends keyof T, V> = {
     [k in K]: V;
 };

package/dist/processors/abapProcessor.d.ts

@@ -0,0 +1,21 @@
+import AbapRepoManager from "../repositories/abapRepoManager";
+import AnnotationManager from "../annotationManager";
+import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager";
+import { IConfiguration } from "../model/types";
+import IProcessor from "./processor";
+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>>;
+    validateConfiguration(): void;
+    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+    getConfigurationType(): string;
+    createAppVariantHierarchyItem(appVariantId: string, version: string): {
+        appVariantId: string;
+        version: string;
+        layer: string;
+    };
+}

package/dist/processors/abapProcessor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commonUtil_1 = require("../util/commonUtil");
+class AbapProcessor {
+    constructor(configuration, cacheManager, 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());
+    }
+    validateConfiguration() {
+        commonUtil_1.validateObject(this.configuration, ["destination", "appName"], "should be specified in ui5.yaml configuration");
+    }
+    async updateLandscapeSpecificContent(renamedBaseAppManifest, baseAppFiles) {
+        const { languages } = this.configuration;
+        const files = await this.annotationManager.process(renamedBaseAppManifest, ["", ...(languages ?? ["EN"])]);
+        if (baseAppFiles) {
+            files.forEach((value, key) => baseAppFiles.set(key, value));
+        }
+    }
+    getConfigurationType() {
+        return "abap";
+    }
+    createAppVariantHierarchyItem(appVariantId, version) {
+        return {
+            appVariantId,
+            version,
+            layer: "VENDOR"
+        };
+    }
+}
+exports.default = AbapProcessor;
+//# sourceMappingURL=abapProcessor.js.map

package/dist/processors/cfProcessor.d.ts

@@ -0,0 +1,17 @@
+import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager";
+import { IConfiguration } from "../model/types";
+import IProcessor from "./processor";
+export default class CFProcessor implements IProcessor {
+    private configuration;
+    private cacheManager;
+    constructor(configuration: IConfiguration, cacheManager: BaseAppFilesCacheManager);
+    getBaseAppFiles(): Promise<Map<string, string>>;
+    validateConfiguration(): void;
+    updateLandscapeSpecificContent(renamedBaseAppManifest: any): Promise<void>;
+    private updateCloudPlatform;
+    getConfigurationType(): string;
+    createAppVariantHierarchyItem(appVariantId: string, version: string): {
+        appVariantId: string;
+        version: string;
+    };
+}

package/dist/processors/cfProcessor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const html5RepoManager_1 = require("../repositories/html5RepoManager");
+const commonUtil_1 = require("../util/commonUtil");
+class CFProcessor {
+    constructor(configuration, cacheManager) {
+        this.configuration = configuration;
+        this.cacheManager = cacheManager;
+    }
+    async getBaseAppFiles() {
+        return this.cacheManager.getFiles(() => html5RepoManager_1.default.getMetadata(this.configuration), () => html5RepoManager_1.default.getBaseAppFiles(this.configuration));
+    }
+    validateConfiguration() {
+        commonUtil_1.validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
+    }
+    async updateLandscapeSpecificContent(renamedBaseAppManifest) {
+        this.updateCloudPlatform(renamedBaseAppManifest);
+    }
+    updateCloudPlatform(renamedBaseAppManifest) {
+        const sapCloudService = renamedBaseAppManifest["sap.cloud"]?.service;
+        const sapPlatformCf = renamedBaseAppManifest["sap.platform.cf"];
+        if (sapPlatformCf && sapCloudService) {
+            sapPlatformCf.oAuthScopes = sapPlatformCf.oAuthScopes.map((scope) => scope.replace(`$XSAPPNAME.`, `$XSAPPNAME('${sapCloudService}').`));
+        }
+        if (this.configuration.sapCloudService) {
+            if (renamedBaseAppManifest["sap.cloud"] == null) {
+                renamedBaseAppManifest["sap.cloud"] = {};
+            }
+            renamedBaseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
+        }
+        else {
+            delete renamedBaseAppManifest["sap.cloud"];
+        }
+    }
+    getConfigurationType() {
+        return "cf";
+    }
+    createAppVariantHierarchyItem(appVariantId, version) {
+        return {
+            appVariantId,
+            version
+        };
+    }
+}
+exports.default = CFProcessor;
+//# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -0,0 +1,7 @@
+import { IConfiguration } from "../model/types";
+export default interface IProcessor {
+    createAppVariantHierarchyItem(appVariantId: string, version: string): void;
+    getBaseAppFiles(baseAppId: string): Promise<Map<string, string>>;
+    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+}
+export declare function determineProcessor(configuration: IConfiguration): IProcessor;

package/dist/processors/processor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineProcessor = void 0;
+const abapProcessor_1 = require("./abapProcessor");
+const abapRepoManager_1 = require("../repositories/abapRepoManager");
+const annotationManager_1 = require("../annotationManager");
+const baseAppFilesCacheManager_1 = require("../cache/baseAppFilesCacheManager");
+const cfProcessor_1 = require("./cfProcessor");
+function determineProcessor(configuration) {
+    const cacheManager = new baseAppFilesCacheManager_1.default(configuration);
+    const abapRepoManager = new abapRepoManager_1.default(configuration);
+    const annotationManager = new annotationManager_1.default(configuration, abapRepoManager);
+    const processors = [
+        new cfProcessor_1.default(configuration, cacheManager),
+        new abapProcessor_1.default(configuration, cacheManager, abapRepoManager, annotationManager)
+    ];
+    let processor = processors.find(processor => processor.getConfigurationType() === configuration.type);
+    if (processor) {
+        processor.validateConfiguration();
+        return processor;
+    }
+    else {
+        for (const processor of processors) {
+            try {
+                processor.validateConfiguration();
+                return processor;
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    throw new Error("ui5.yaml configuration should correspond either ABAP or SAP BTP landscape");
+}
+exports.determineProcessor = determineProcessor;
+//# sourceMappingURL=processor.js.map

package/dist/repositories/abapRepoManager.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration, IMetadata } from "../model/types";
+export default class AbapRepoManager {
+    private auth?;
+    private configuration;
+    constructor(configuration: IConfiguration);
+    getAnnotationMetadata(uri: string): Promise<IMetadata>;
+    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    getMetadata(baseAppId: string): Promise<IMetadata>;
+    downloadBaseAppFiles(): Promise<Map<string, string>>;
+    private getMetadataRequest;
+    private downloadBaseAppFilesRequest;
+    private getAuth;
+}

package/dist/repositories/abapRepoManager.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const requestUtil_1 = require("../util/requestUtil");
+const zipUtil_1 = require("../util/zipUtil");
+const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::AbapRepoManager");
+const REQUEST_OPTIONS_XML = {
+    responseType: "text",
+    headers: {
+        "Content-Type": "text/xml"
+    }
+};
+const REQUEST_OPTIONS_JSON = {
+    headers: {
+        "Content-Type": "application/json"
+    }
+};
+class AbapRepoManager {
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async getAnnotationMetadata(uri) {
+        const header = await requestUtil_1.default.retryWithAuth(() => requestUtil_1.default.head(uri), () => requestUtil_1.default.head(uri, this.getAuth()));
+        return { changedOn: header.modified };
+    }
+    async downloadAnnotationFile(uri) {
+        const annotation = await requestUtil_1.default.retryWithAuth(() => requestUtil_1.default.get(uri, REQUEST_OPTIONS_XML), () => requestUtil_1.default.get(uri, REQUEST_OPTIONS_XML, this.getAuth()));
+        return new Map([["annotation.xml", annotation]]);
+    }
+    getMetadata(baseAppId) {
+        return requestUtil_1.default.retryWithAuth(() => this.getMetadataRequest(baseAppId), () => this.getMetadataRequest(baseAppId, this.getAuth()));
+    }
+    downloadBaseAppFiles() {
+        return requestUtil_1.default.retryWithAuth(() => this.downloadBaseAppFilesRequest(), () => this.downloadBaseAppFilesRequest(this.getAuth()));
+    }
+    async getMetadataRequest(id, auth) {
+        let uri = `https://${this.configuration.destination}.dest/sap/bc/ui2/app_index/ui5_app_info_json?id=${id}`;
+        const data = await requestUtil_1.default.get(uri, REQUEST_OPTIONS_JSON, auth);
+        if (data && data[id]) {
+            return {
+                changedOn: data[id].url,
+                id
+            };
+        }
+        log.warn(`UI5AppInfoJson request doesn't contain cache buster token for sap.app/id '${id}'. Fallback to download.`);
+    }
+    async downloadBaseAppFilesRequest(auth) {
+        const { destination, appName } = this.configuration;
+        const encodedAppName = encodeURIComponent(appName);
+        const uri = `https://${destination}.dest/sap/opu/odata/UI5/ABAP_REPOSITORY_SRV/Repositories('${encodedAppName}')?DownloadFiles=RUNTIME&CodePage=UTF8`;
+        const data = await requestUtil_1.default.get(uri, REQUEST_OPTIONS_XML, auth);
+        if (data?.d?.ZipArchive.length > 0) {
+            const buffer = Buffer.from(data.d.ZipArchive, "base64");
+            return zipUtil_1.unzipZipEntries(buffer);
+        }
+        throw new Error(`App '${appName}' from destination '${destination}' doesn't contain files`);
+    }
+    getAuth() {
+        if (!this.auth) {
+            if (this.configuration?.credentials) {
+                let { username, password } = this.configuration?.credentials;
+                if (username && password) {
+                    const ENV_PREFIX = "env:";
+                    username = username.substring(ENV_PREFIX.length);
+                    password = password.substring(ENV_PREFIX.length);
+                    if (process.env[username] && process.env[password]) {
+                        this.auth = {
+                            username: process.env[username],
+                            password: process.env[password]
+                        };
+                    }
+                }
+            }
+        }
+        if (!this.auth) {
+            throw new Error("Please provide ABAP System credentials in .env file of the project: https://help.sap.com/docs/SAP_FIORI_tools/17d50220bcd848aa854c9c182d65b699/1c859274b511435ab6bd45f70e7f9af2.html.");
+        }
+        return this.auth;
+    }
+}
+exports.default = AbapRepoManager;
+//# sourceMappingURL=abapRepoManager.js.map

package/dist/{html5RepoManager.d.ts → repositories/html5RepoManager.d.ts}

@@ -1,4 +1,4 @@
-import { IConfiguration } from "./model/types";
+import { IConfiguration } from "./../model/types";
 export default class HTML5RepoManager {
     static getBaseAppFiles(configuration: IConfiguration): Promise<Map<string, string>>;
     static getMetadata(configuration: IConfiguration): Promise<any>;
@@ -7,5 +7,5 @@ export default class HTML5RepoManager {
     private static getToken;
     private static requestMetadata;
     private static getBaseAppZipEntries;
-    private static mapEntries;
+    private static download;
 }

package/dist/repositories/html5RepoManager.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfUtil_1 = require("./../util/cfUtil");
+const requestUtil_1 = require("./../util/requestUtil");
+const zipUtil_1 = require("./../util/zipUtil");
+const log = require("@ui5/logger").getLogger("@ui5/task-adaptation::HTML5RepoManager");
+class HTML5RepoManager {
+    static async getBaseAppFiles(configuration) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        return this.getBaseAppZipEntries(configuration, baseUri, token);
+    }
+    static async getMetadata(configuration) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        return this.requestMetadata(configuration, baseUri, token);
+    }
+    static async getHtml5RepoInfo(configuration) {
+        const spaceGuid = await cfUtil_1.default.getSpaceGuid(configuration?.spaceGuid);
+        const credentials = await this.getHTML5Credentials(spaceGuid);
+        const token = await this.getToken(credentials);
+        return {
+            token,
+            baseUri: credentials.uri
+        };
+    }
+    static async getHTML5Credentials(spaceGuid) {
+        log.verbose("Getting HTML5 Repo Runtime credentials from space " + spaceGuid);
+        const PLAN_NAME = "app-runtime";
+        const SERVIСE_INSTANCE_NAME = "html5-apps-repo-runtime";
+        const getParams = {
+            spaceGuids: [spaceGuid],
+            planNames: [PLAN_NAME],
+            names: [SERVIСE_INSTANCE_NAME]
+        };
+        const createParams = {
+            spaceGuid,
+            planName: PLAN_NAME,
+            serviceName: SERVIСE_INSTANCE_NAME,
+            tags: ["html5-apps-repo-rt"]
+        };
+        const serviceKeys = await cfUtil_1.default.getServiceInstanceKeys(getParams, createParams);
+        return serviceKeys.credentials;
+    }
+    static async getToken({ uaa }) {
+        log.verbose("Getting HTML5 Repo token");
+        const auth = Buffer.from(uaa.clientid + ":" + uaa.clientsecret);
+        const options = {
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Basic " + auth.toString("base64")
+            }
+        };
+        const uri = `${uaa.url}/oauth/token?grant_type=client_credentials`;
+        return requestUtil_1.default.get(uri, options).then((json) => json["access_token"]);
+    }
+    static async requestMetadata(options, html5RepoBaseUri, token) {
+        const { appHostId, appName, appVersion } = options;
+        const uri = `${html5RepoBaseUri}/applications/metadata/`;
+        const requestOptions = {
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer " + token,
+                "x-app-host-id": appHostId
+            }
+        };
+        const metadata = await requestUtil_1.default.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);
+        return zipUtil_1.unzipZipEntries(zip);
+    }
+    static async download(token, appHostId, uri) {
+        if (!token) {
+            throw new Error("HTML5 token is undefined");
+        }
+        return requestUtil_1.default.get(uri, {
+            responseType: "arraybuffer",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer " + token,
+                "x-app-host-id": appHostId
+            }
+        });
+    }
+}
+exports.default = HTML5RepoManager;
+//# sourceMappingURL=html5RepoManager.js.map