@ui5/task-adaptation 1.3.1 → 1.3.3

package/dist/cache/annotationsCacheManager.d.ts

@@ -0,0 +1,8 @@
+import CacheManager from "./cacheManager.js";
+import { IConfiguration } from "../model/types.js";
+export default class AnnotationsCacheManager extends CacheManager {
+    private tempSubFolder;
+    constructor(configuration: IConfiguration, tempSubFolder: string);
+    protected getTempId(): string;
+    getMetadataFilename(): string;
+}

package/dist/cache/annotationsCacheManager.js

@@ -0,0 +1,16 @@
+import CacheManager from "./cacheManager.js";
+export default class AnnotationsCacheManager extends CacheManager {
+    tempSubFolder;
+    constructor(configuration, tempSubFolder) {
+        super(configuration);
+        this.tempSubFolder = tempSubFolder;
+    }
+    getTempId() {
+        const { destination, appName } = this.configuration;
+        return super.normalizeId(`ui5-${destination}-${appName}-${this.tempSubFolder}`);
+    }
+    getMetadataFilename() {
+        return "annotationsmetadata.json";
+    }
+}
+//# sourceMappingURL=annotationsCacheManager.js.map

package/dist/cache/baseAppFilesCacheManager.d.ts

@@ -0,0 +1,6 @@
+import CacheManager from "./cacheManager.js";
+export default class BaseAppFilesCacheManager extends CacheManager {
+    static METADATA_FILENAME: string;
+    protected getTempId(): string;
+    getMetadataFilename(): string;
+}

package/dist/cache/baseAppFilesCacheManager.js

@@ -0,0 +1,12 @@
+import CacheManager from "./cacheManager.js";
+export default class BaseAppFilesCacheManager extends CacheManager {
+    static METADATA_FILENAME = "html5metadata.json";
+    getTempId() {
+        const { appHostId, appName, appVersion } = this.configuration;
+        return super.normalizeId(`ui5-${appHostId}-${appName}-${appVersion}`);
+    }
+    getMetadataFilename() {
+        return BaseAppFilesCacheManager.METADATA_FILENAME;
+    }
+}
+//# sourceMappingURL=baseAppFilesCacheManager.js.map

package/dist/cache/cacheManager.d.ts

@@ -0,0 +1,16 @@
+import { IConfiguration, IMetadata } from "../model/types.js";
+export default abstract class CacheManager {
+    protected configuration: IConfiguration;
+    constructor(configuration: IConfiguration);
+    protected abstract getMetadataFilename(): string;
+    protected abstract getTempId(): string;
+    protected getTempFolder(): string;
+    getFiles(fetchMetadata: () => Promise<IMetadata>, fetchFiles: () => Promise<Map<string, string>>): Promise<Map<string, string>>;
+    isMetadataSame(tempMetadata: IMetadata, metadata: IMetadata): boolean;
+    readTempMetadata(): any;
+    writeTemp(files: Map<string, string>, metadata: any): Promise<void[]>;
+    readTemp(): Promise<Map<string, string>>;
+    deleteTemp(): void;
+    protected normalizeId(id: string): string;
+    private getFilesToCache;
+}

package/dist/cache/cacheManager.js

@@ -0,0 +1,65 @@
+import * as fs from "fs";
+import * as path from "path";
+import ResourceUtil from "../util/resourceUtil.js";
+import tempFolder from "temp-dir";
+export default class CacheManager {
+    configuration;
+    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) {
+        // TODO: Implement correct metadata comparision.
+        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.write(this.getTempFolder(), filesToCache);
+    }
+    async readTemp() {
+        const files = new Map();
+        const tempFolder = this.getTempFolder();
+        if (fs.existsSync(tempFolder)) {
+            ResourceUtil.read(tempFolder, tempFolder, files, [this.getMetadataFilename()]);
+        }
+        return files;
+    }
+    deleteTemp() {
+        fs.rmSync(this.getTempFolder(), { recursive: true, force: true });
+    }
+    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;
+    }
+}
+//# sourceMappingURL=cacheManager.js.map

package/dist/i18nManager.d.ts

@@ -0,0 +1,43 @@
+import { IDiffProperty } from "./annotations/comparator/comparator.js";
+import { IJsonPerLanguage, IJsonPromisePerLanguage } from "./model/types.js";
+import Language from "./model/language.js";
+export declare class PropertyValue {
+    value: string;
+    isReference: boolean;
+    qualifier: string;
+    language: Language;
+    private static OLD;
+    private static NEW;
+    private constructor();
+    get isOld(): boolean;
+    set(diff: any, references: Map<string, string>): void;
+    static oldFrom(language: Language, value?: string): PropertyValue;
+    static newFrom(language: Language, value?: string): PropertyValue;
+}
+export declare class I18nFileContent {
+    private properties;
+    constructor(languages: Language[]);
+    add(prop: PropertyValue, key: string): void;
+    private initKeyValuesForOtherLanguages;
+    hasTranslations(): boolean;
+    private getOrCreateLanguageContent;
+    createFiles(i18nPathName: string): Map<string, string>;
+}
+export default class I18nManager {
+    private modelName;
+    private appVariantId;
+    private references;
+    private existingKeys;
+    private i18nFileContent;
+    constructor(modelName: string, appVariantId: string, languages: Language[]);
+    processDiff(properties: Set<IDiffProperty>, previousLanguage: Language, currentLanguage: Language): void;
+    createFiles(i18nPathName: string): Map<string, string>;
+    populateTranslations(annotationJsons: Map<Language, Promise<any>>): Promise<IJsonPromisePerLanguage>;
+    populate(annotationJsons: [Language, Promise<any>][], defaultAnnotation: IJsonPerLanguage): Promise<IJsonPerLanguage>;
+    static extractDefaultLanguageAnnotation(annotationJsons: Map<Language, Promise<any>>): IJsonPromisePerLanguage;
+    private replaceWithModelReference;
+    private createReference;
+    getUniqueKeyForValue(value: string): string;
+    hasTranslations(): boolean;
+    private initPropertyValues;
+}

package/dist/i18nManager.js

@@ -0,0 +1,203 @@
+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
+// To generate keys, english language is more common, so compare all other
+// languages with it
+export class PropertyValue {
+    value;
+    isReference = false;
+    qualifier;
+    language;
+    static OLD = "__old";
+    static NEW = "__new";
+    constructor(qualifier, language, value) {
+        this.qualifier = qualifier;
+        this.language = language;
+        this.value = value;
+    }
+    get isOld() {
+        return this.qualifier === PropertyValue.OLD;
+    }
+    set(diff, references) {
+        this.value = diff[this.qualifier];
+        this.isReference = references.has(diff[this.qualifier]);
+    }
+    static oldFrom(language, value = "") {
+        return new PropertyValue(PropertyValue.OLD, language, value);
+    }
+    static newFrom(language, value = "") {
+        return new PropertyValue(PropertyValue.NEW, language, value);
+    }
+}
+export class I18nFileContent {
+    properties = new Map();
+    constructor(languages) {
+        languages.forEach(language => this.properties.set(language, new Map()));
+    }
+    add(prop, key) {
+        this.getOrCreateLanguageContent(prop.language).set(key, prop.value);
+        this.initKeyValuesForOtherLanguages(prop, key);
+    }
+    initKeyValuesForOtherLanguages(prop, key) {
+        // "", EN, EN_US, DE, FR
+        // If we already compared 2 languages and saved translations, we assume
+        // that we have generated all property keys, but suddenly 3d language or
+        // further contain translation which was not present in previous
+        // languages we need to update all other languages then. These values
+        // will be overwritten later by actual values of the language:
+        // this.getOrCreateLanguageContent(prop.language).set(key, prop.value);
+        if (prop.isOld) {
+            this.properties.forEach((keyValue, language) => {
+                if (language !== prop.language && !keyValue.has(key)) {
+                    keyValue.set(key, prop.value);
+                }
+            });
+        }
+    }
+    hasTranslations() {
+        // this.properties.size can be 0 or 2+, it can't be 1
+        return [...this.properties.values()].some(keyValue => keyValue.size > 0);
+    }
+    getOrCreateLanguageContent(language) {
+        if (!this.properties.has(language)) {
+            this.properties.set(language, new Map());
+        }
+        return this.properties.get(language);
+    }
+    createFiles(i18nPathName) {
+        const files = new Map();
+        if (this.hasTranslations()) {
+            this.properties.forEach((i18nLines, language) => {
+                let filename = "i18n";
+                if (language.i18n) {
+                    filename += "_" + language.i18n;
+                }
+                const filepath = join(i18nPathName, filename + ".properties");
+                files.set(filepath, [...i18nLines].map(([key, value]) => `${key}=${value}`).join("\n"));
+            });
+        }
+        return files;
+    }
+}
+export default class I18nManager {
+    modelName;
+    appVariantId;
+    references = new Map();
+    existingKeys = new Set();
+    i18nFileContent;
+    constructor(modelName, appVariantId, languages) {
+        this.modelName = modelName;
+        this.appVariantId = appVariantId;
+        this.i18nFileContent = new I18nFileContent(languages);
+    }
+    processDiff(properties, previousLanguage, currentLanguage) {
+        // json-diff uses __old and __new value as diff,
+        // so we assign it with languages which were in comparison
+        const propertyValues = [
+            PropertyValue.oldFrom(previousLanguage),
+            PropertyValue.newFrom(currentLanguage)
+        ];
+        for (const property of properties) {
+            this.replaceWithModelReference(property, propertyValues);
+        }
+    }
+    createFiles(i18nPathName) {
+        return this.i18nFileContent.createFiles(i18nPathName);
+    }
+    async populateTranslations(annotationJsons) {
+        /* We compare annotations. Diff gives us:
+        {
+            "string": {
+                "__old": "A"
+                "__new": "B"
+            }
+        }
+        we generate key and extract to properties file. Now it looks so:
+        {
+            "string": "{@i18n>id_KEY}"
+        }
+        and we compare this with next language and diff gives us:
+        {
+            "string": {
+                "__old": "{@i18n>id_KEY}"
+                "__new": "C"
+            }
+        }
+        we use already generate key id_KEY and extract translation value to
+        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) {
+            defaultAnnotation = await this.populate([...annotationJsons], defaultAnnotation);
+        }
+        return defaultAnnotation;
+    }
+    async populate(annotationJsons, defaultAnnotation) {
+        let p = defaultAnnotation;
+        for (const c of annotationJsons.map(([language, json]) => ({ language, json }))) {
+            try {
+                const comparator = new Comparator(await p.json, await c.json);
+                const pDiff = comparator.compare();
+                this.processDiff(pDiff.properties, p.language, c.language);
+                p.json = pDiff.json;
+            }
+            catch (error) {
+                if (error instanceof AnnotationDiffStructureError) {
+                    throw new Error(`The structure of the OData annotation xml of language '${p.language}' is different from xml of language '${c.language}' near element: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+        return p;
+    }
+    static extractDefaultLanguageAnnotation(annotationJsons) {
+        let json = null;
+        for (const [language, json] of annotationJsons) {
+            if (language.isDefault) {
+                annotationJsons.delete(language);
+                return { json, language };
+            }
+        }
+        const language = [...annotationJsons.keys()][0];
+        json = annotationJsons.get(language);
+        annotationJsons.delete(language);
+        return { json, language };
+    }
+    replaceWithModelReference({ object, property }, propertyValues) {
+        const diff = object[property];
+        this.initPropertyValues(diff, propertyValues);
+        // If there are already generated key, like on step 3. above comment, we
+        // take it (from __old), so we don't need to generate new
+        const propReference = propertyValues.find(prop => prop.isReference);
+        let reference = propReference?.value ?? this.createReference(diff.__old);
+        object[property] = reference;
+        // Other values, which are not references, are extracted to .properties
+        const key = this.references.get(reference);
+        if (key) {
+            propertyValues.filter(prop => !prop.isReference).forEach(prop => this.i18nFileContent.add(prop, key));
+        }
+    }
+    createReference(value) {
+        const key = this.appVariantId + "_" + this.getUniqueKeyForValue(value);
+        const reference = `{${this.modelName}>${key}}`;
+        this.references.set(reference, key);
+        return reference;
+    }
+    getUniqueKeyForValue(value) {
+        if (typeof value !== "string") {
+            throw new Error("Failed to create unique key from: " + JSON.stringify(value));
+        }
+        const propertyName = value.replace(/\W/gi, "_").toUpperCase();
+        const key = getUniqueName([...this.existingKeys.keys()], propertyName);
+        this.existingKeys.add(key);
+        return key;
+    }
+    hasTranslations() {
+        return this.i18nFileContent.hasTranslations();
+    }
+    initPropertyValues(diff, propertyValues) {
+        propertyValues.forEach(prop => prop.set(diff, this.references));
+    }
+}
+//# sourceMappingURL=i18nManager.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { ITaskParameters } from "./model/types.js";
+/**
+ * Creates an appVariant bundle from the provided resources.
+ */
+declare const _default: ({ workspace, options, taskUtil }: ITaskParameters) => Promise<void>;
+export default _default;

package/dist/index.js

@@ -0,0 +1,25 @@
+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 { determineProcessor } from "./processors/processor.js";
+/**
+ * Creates an appVariant bundle from the provided resources.
+ */
+export default ({ workspace, options, taskUtil }) => {
+    dotenv.config();
+    async function process(workspace, 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)));
+    }
+    return process(workspace, taskUtil);
+};
+//# sourceMappingURL=index.js.map

package/dist/model/annotationDiffStructureError.d.ts

@@ -0,0 +1,3 @@
+export default class AnnotationDiffStructureError extends Error {
+    constructor(json: any);
+}

package/dist/model/annotationDiffStructureError.js

@@ -0,0 +1,8 @@
+export default class AnnotationDiffStructureError extends Error {
+    constructor(json) {
+        super(JSON.stringify(json));
+        this.name = "AnnotationDiffStructureError";
+        this.message = `The structure of the OData annotation xml is different near element: ${JSON.stringify(json)}`;
+    }
+}
+//# sourceMappingURL=annotationDiffStructureError.js.map

package/dist/model/configuration.d.ts

@@ -0,0 +1,21 @@
+import { AbapTarget } from "@sap-ux/system-access";
+export interface IConfiguration {
+    appHostId?: string;
+    appId?: string;
+    appName?: string;
+    appVersion?: string;
+    spaceGuid?: string;
+    orgGuid?: string;
+    sapCloudService?: string;
+    destination?: string;
+    type?: "cf" | "abap";
+    languages?: any[] | undefined;
+    enableAnnotationCache?: boolean;
+    enableBetaFeatures?: boolean;
+    writeTempFiles?: any;
+    connections?: (AbapTarget & IAbapTargetMeta)[];
+}
+export interface IAbapTargetMeta {
+    name?: string;
+    ignoreCertErrors?: boolean;
+}

package/dist/model/configuration.js

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

package/dist/model/language.d.ts

@@ -0,0 +1,13 @@
+export default class Language {
+    sap: string;
+    i18n: string;
+    isDefault: boolean;
+    constructor(sap: string, i18n: string);
+    /**
+     * Create a language array from languages in configuration and default language.
+     * @param languages Typically an array of objects. Probably could be undefined.
+     * @returns An array of type Language, where the default language is placed first,
+     * followed by the passed config languages.
+     */
+    static create(languages: any[] | undefined): Language[];
+}

package/dist/model/language.js

@@ -0,0 +1,37 @@
+export default class Language {
+    sap;
+    i18n;
+    isDefault;
+    constructor(sap, i18n) {
+        this.sap = sap;
+        this.i18n = i18n;
+        this.isDefault = sap === "";
+    }
+    /**
+     * Create a language array from languages in configuration and default language.
+     * @param languages Typically an array of objects. Probably could be undefined.
+     * @returns An array of type Language, where the default language is placed first,
+     * followed by the passed config languages.
+     */
+    static create(languages) {
+        const defaultLanguage = new Language("", "");
+        let configLanguages = [];
+        if (languages !== undefined) {
+            configLanguages = languages.map(item => {
+                if (typeof item === "string") {
+                    // For legacy language format support which is just a string and doesn't contain i18n
+                    return new Language(item, item.toLowerCase());
+                }
+                else if (item.sap !== undefined && item.i18n !== undefined) {
+                    return new Language(item.sap, item.i18n);
+                }
+                else {
+                    throw new Error("Can not parse languages from ui5.yaml configuration. Please use the 'AdaptationProject: Create wizard' to generate the project.");
+                }
+            });
+        }
+        return [defaultLanguage, ...configLanguages];
+    }
+    ;
+}
+//# sourceMappingURL=language.js.map

package/dist/model/serverError.d.ts

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

package/dist/model/serverError.js

@@ -0,0 +1,6 @@
+export default class ServerError extends Error {
+    constructor(uri, error) {
+        super(`Request ${uri} failed with Server error: ${error.response.status}${error.response.data ?? ""}`);
+    }
+}
+//# sourceMappingURL=serverError.js.map

package/dist/model/types.d.ts

@@ -0,0 +1,105 @@
+import { IConfiguration } from "./configuration.js";
+import Language from "./language.js";
+export interface IProjectOptions {
+    configuration: IConfiguration;
+    projectNamespace: string;
+}
+export interface ICreateServiceInstanceParams {
+    spaceGuid: string;
+    planName: string;
+    serviceName: string;
+    serviceInstanceName?: string;
+    tags: string[];
+    parameters?: any;
+}
+export interface IGetServiceInstanceParams {
+    [key: string]: string[] | undefined;
+    spaceGuids?: string[];
+    planNames?: string[];
+    names: string[];
+}
+export interface IServiceInstance {
+    name: string;
+    guid: string;
+}
+export interface IResource {
+    name: string;
+    guid: string;
+    tags: string[];
+    visibility_type: string;
+}
+export interface IServiceKeys {
+    credentials: ICredentials;
+    serviceInstance: IServiceInstance;
+}
+export interface ICredentials {
+    [key: string]: any;
+    uaa: IUaa;
+    uri: string;
+    endpoints: any;
+}
+export interface IUaa {
+    clientid: string;
+    clientsecret: string;
+    url: string;
+}
+export interface IAppVariantInfo {
+    id: string;
+    reference: string;
+    layer?: string;
+    changes: IChange[];
+}
+export interface IAppVariantManifest {
+    id: string;
+    reference: string;
+    layer?: string;
+    content: IChange[];
+}
+export interface IChange {
+    changeType: string;
+    texts?: IChangeText;
+    layer?: string;
+    content?: IChangeContent;
+}
+export interface IChangeText {
+    i18n: string;
+}
+export interface IChangeContent {
+    bundleUrl?: string;
+    fallbackLocale?: string;
+    modelId?: string;
+    supportedLocales?: string[];
+}
+export interface ITaskParameters {
+    workspace: any;
+    options: IProjectOptions;
+    taskUtil: any;
+}
+export interface IBaseAppInfo {
+    filepath: string;
+    content: any;
+}
+export interface IHTML5RepoInfo {
+    token: string;
+    baseUri: string;
+}
+export interface IAuth {
+    username: string;
+    password: string;
+}
+export interface IMetadata {
+    changedOn: string;
+    id?: string;
+}
+export type KeyedMap<T, K extends keyof T, V> = {
+    [k in K]: V;
+};
+export interface IJsonPerLanguage {
+    language: Language;
+    json: any;
+}
+export interface IJsonPromisePerLanguage {
+    language: Language;
+    json: Promise<any>;
+}
+export { IConfiguration };

package/dist/model/types.js

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

package/dist/processors/abapProcessor.d.ts

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