@ui5/task-adaptation 1.3.1 → 1.3.2

package/dist/annotations/converter/metadataJsonUtil.js

@@ -0,0 +1,70 @@
+export default class MetadataJsonUtil {
+    static mapAnnotationsPerTarget(json) {
+        const annotations = Array.isArray(json) ? json : this.getAnnotations(json);
+        return new Map(annotations.map((json, index) => [json?._attributes?.Target, { json, index }]));
+    }
+    static getVersion(json) {
+        return this.getEdmx(json)?._attributes?.Version;
+    }
+    static getAnnotations(json) {
+        return this.toArrayReadOnly(this.getSchemaNode(json)?.Annotations);
+    }
+    static setAnnotations(json, annotations) {
+        const schema = this.getSchemaNode(json);
+        annotations.forEach(annotation => annotation._attributes.xmlns = "http://docs.oasis-open.org/odata/ns/edm");
+        schema.Annotations = annotations;
+    }
+    static getSchemaNode(json) {
+        return this.getDataServices(json)?.Schema;
+    }
+    static getSchemaReference(json) {
+        return MetadataInclude.fromJson(this.getDataServices(json)?.Schema?._attributes);
+    }
+    static getEdmx(json) {
+        return json["edmx:Edmx"];
+    }
+    static getDataServices(json) {
+        return this.getEdmx(json)["edmx:DataServices"];
+    }
+    static getReferences(json) {
+        const referenceNode = this.toArrayReadOnly(this.getEdmx(json)["edmx:Reference"]);
+        return referenceNode.map(ref => new MetadataReference(ref));
+    }
+    static toArrayReadOnly(json) {
+        return Array.isArray(json) ? json : [json];
+    }
+    static toArrayTransform(json, property) {
+        if (!Array.isArray(json[property])) {
+            json[property] = [json[property]];
+        }
+    }
+}
+export class MetadataReference {
+    uri;
+    includes = new Array();
+    constructor(referenceJson) {
+        this.uri = referenceJson._attributes.Uri;
+        for (const include of MetadataJsonUtil.toArrayReadOnly(referenceJson["edmx:Include"])) {
+            this.includes.push(MetadataInclude.fromJson(include));
+        }
+    }
+    getAlias(namespace) {
+        const include = this.includes.find(include => include.namespace === namespace);
+        return include?.alias;
+    }
+}
+export class MetadataInclude {
+    namespace;
+    alias;
+    constructor(alias, namespace) {
+        this.alias = alias;
+        this.namespace = namespace;
+    }
+    equals(other) {
+        return this.alias === other.alias && this.namespace === other.namespace;
+    }
+    static fromJson(json) {
+        return new MetadataInclude(json?._attributes?.Alias, json?._attributes?.Namespace);
+    }
+}
+//# sourceMappingURL=metadataJsonUtil.js.map

package/dist/annotations/converter/ui5JsonConverter.d.ts

@@ -0,0 +1,21 @@
+export default class UI5JsonConverter {
+    config: any;
+    oAnnotationConfig: any;
+    static convertAnnotations(json: any): any[];
+    static processAnnotations(json: any, target: string): any;
+    private static processObject;
+    static processTerms(json: any): any;
+    private static processInlineAnnotationWithCollections;
+    private static isReferenced;
+    private static processAnnotation;
+    private static getInlineAnnotation;
+    private static createTerm;
+    private static processCollection;
+    private static processCollectionItem;
+    private static updateToArray;
+    private static getAttributes;
+    private static trimLeft;
+    private static trimByAt;
+    private static isWrapped;
+    private static getWrappedProperty;
+}

package/dist/annotations/converter/ui5JsonConverter.js

@@ -0,0 +1,252 @@
+import UI5JsonParser from "./ui5MetadataJsonUtil.js";
+export default class UI5JsonConverter {
+    config;
+    oAnnotationConfig;
+    static convertAnnotations(json) {
+        const annotationsNode = UI5JsonParser.getAnnotationsNode(json);
+        if (annotationsNode) {
+            return Object.entries(annotationsNode).map(([target, annotations]) => this.processAnnotations(annotations, target));
+        }
+        return [];
+    }
+    static processAnnotations(json, target) {
+        const attributes = {
+            "_attributes": {
+                "Target": this.trimLeft(target, "@")
+            }
+        };
+        const annotation = this.processTerms(json);
+        return Object.assign(attributes, annotation);
+    }
+    static processObject(term, value) {
+        let wrapped = this.getWrappedProperty(value);
+        if (wrapped) {
+            this.getAttributes(term)[wrapped.property] = wrapped.value;
+        }
+        else {
+            const record = this.processTerms(value);
+            this.updateToArray(term, "Record", record);
+        }
+    }
+    static processTerms(json) {
+        let result = {};
+        const pendingInlineAnnotationKeys = new Array();
+        for (const key of Object.keys(json)) {
+            let wrapped = this.getWrappedProperty(json);
+            const inlineAnnotation = this.getInlineAnnotation(key);
+            if (inlineAnnotation) {
+                pendingInlineAnnotationKeys.push(inlineAnnotation);
+                continue;
+            }
+            if (wrapped) {
+                this.getAttributes(result)[wrapped.property] = wrapped.value;
+            }
+            else if (key.startsWith("$")) {
+                this.getAttributes(result)[this.trimLeft(key, "$")] = json[key];
+            }
+            else {
+                // Split Annotation from PropertyValue
+                const options = (key[0] === "@") ? {
+                    attributesProperty: "Term",
+                    entity: "Annotation"
+                } : {
+                    attributesProperty: "Property",
+                    entity: "PropertyValue",
+                    explicitBoolean: true
+                };
+                const term = this.createTerm(key, options.attributesProperty);
+                const value = json[key];
+                if (typeof value === "string") {
+                    term._attributes.String = value;
+                }
+                else if (typeof value === "boolean" && (!value || options.explicitBoolean)) {
+                    term._attributes.Bool = value.toString();
+                }
+                else if (typeof value === "number") {
+                    term._attributes.Int = value.toString();
+                }
+                else if (Array.isArray(value)) {
+                    this.processCollection(term, value);
+                }
+                else if (typeof value === "object") {
+                    this.processObject(term, value);
+                }
+                this.updateToArray(result, options.entity, term);
+            }
+        }
+        for (const inlineAnnotation of pendingInlineAnnotationKeys) {
+            const { term, reference } = inlineAnnotation;
+            if (inlineAnnotation.isInlineAnnotationWithCollections) {
+                // TODO can possibly be merged with below
+                this.processInlineAnnotationWithCollections(inlineAnnotation, json, result);
+            }
+            else if (Array.isArray(json[inlineAnnotation.key])) {
+                const annotationTerm = { Annotation: this.createTerm(term, "Term") };
+                this.processCollection(annotationTerm.Annotation, json[inlineAnnotation.key]);
+                if (Array.isArray(result[inlineAnnotation.entity])) {
+                    let referenced = result[inlineAnnotation.entity].find((item) => this.isReferenced(item, inlineAnnotation.attributesProperty, reference));
+                    if (referenced) {
+                        referenced = Object.assign(referenced, annotationTerm);
+                    }
+                }
+                else if (result[inlineAnnotation.entity]) {
+                    result[inlineAnnotation.entity] = Object.assign(result[inlineAnnotation.entity], annotationTerm);
+                }
+            }
+            else {
+                const annotation = this.processAnnotation(json, inlineAnnotation.key, term);
+                if (Array.isArray(result[inlineAnnotation.entity])) {
+                    const referenced = result[inlineAnnotation.entity].find((item) => this.isReferenced(item, inlineAnnotation.attributesProperty, reference));
+                    if (referenced) {
+                        referenced.Annotation = annotation;
+                    }
+                }
+                else if (result[inlineAnnotation.entity]) {
+                    result[inlineAnnotation.entity].Annotation = annotation;
+                }
+            }
+        }
+        return result;
+    }
+    static processInlineAnnotationWithCollections(inlineAnnotation, json, result) {
+        delete Object.assign(json, { [`@${inlineAnnotation.term}`]: json[inlineAnnotation.key] })[inlineAnnotation.key];
+        const term = this.createTerm(inlineAnnotation.term, "Term");
+        this.processCollection(term, json[`@${inlineAnnotation.term}`]);
+        const PropertyValue = (Array.isArray(result.PropertyValue)) ? result.PropertyValue : [result.PropertyValue];
+        const targetProperty = PropertyValue.find((propertyValueObject) => {
+            return this.isReferenced(propertyValueObject, "Property", inlineAnnotation.reference);
+        });
+        if (targetProperty) {
+            this.updateToArray(targetProperty, "Annotation", term);
+        }
+    }
+    static isReferenced(item, attributesProperty, reference) {
+        return this.getAttributes(item) && this.getAttributes(item)[attributesProperty] === reference;
+    }
+    static processAnnotation(json, key, term = key) {
+        const annotation = this.processTerms(json[key]);
+        const annotationTerm = this.trimByAt(term);
+        const attributes = this.getAttributes(annotation);
+        if (Object.keys(attributes).length > 0 && annotationTerm) {
+            annotation._attributes = Object.assign({ "Term": annotationTerm }, attributes);
+        }
+        else {
+            this.getAttributes(annotation).Term = annotationTerm;
+        }
+        return annotation;
+    }
+    static getInlineAnnotation(key) {
+        const parts = key.split("@"); // @<ref>@<term>
+        if (parts.length === 3) {
+            return {
+                reference: parts[1],
+                term: parts[2],
+                key,
+                attributesProperty: "Term",
+                entity: "Annotation"
+            };
+        }
+        else if (parts.length === 2 && parts[0]) { // <ref>@<term>
+            return {
+                reference: parts[0],
+                term: parts[1],
+                key,
+                isInlineAnnotationWithCollections: true,
+                attributesProperty: "Property",
+                entity: "PropertyValue",
+            };
+        }
+    }
+    static createTerm(key, attributesProperty) {
+        const parts = key.split("#");
+        const qualifier = parts.length > 1 && parts.pop();
+        const term = {
+            "_attributes": {
+                [attributesProperty]: this.trimByAt(parts[0])
+            }
+        };
+        if (qualifier) {
+            term._attributes.Qualifier = qualifier;
+        }
+        return term;
+    }
+    static processCollection(term, value) {
+        const collection = term.Collection = {};
+        for (const item of value) {
+            this.processCollectionItem(collection, item);
+        }
+    }
+    static processCollectionItem(collection, item) {
+        let wrapped = this.getWrappedProperty(item);
+        if (wrapped) {
+            this.updateToArray(collection, wrapped.property, wrapped.value.length > 0 ? { _text: wrapped.value } : {});
+        }
+        else if (typeof item === "string") {
+            this.updateToArray(collection, "String", { _text: item });
+        }
+        else if (typeof item === "object") {
+            this.processObject(collection, item);
+        }
+    }
+    static updateToArray(object, key, value) {
+        if (object[key]) {
+            if (!Array.isArray(object[key])) {
+                object[key] = [object[key]];
+            }
+            object[key].push(value);
+        }
+        else {
+            object[key] = value;
+        }
+    }
+    static getAttributes(parent) {
+        if (parent._attributes == null) {
+            parent._attributes = {};
+        }
+        return parent._attributes;
+    }
+    static trimLeft(str, char) {
+        while (str.startsWith(char)) {
+            str = str.substring(1);
+        }
+        return str;
+    }
+    static trimByAt(term) {
+        const indexOfAt = term.indexOf("@");
+        if (indexOfAt > -1) {
+            return term.substring(indexOfAt + 1);
+        }
+        return term;
+    }
+    static isWrapped(type) {
+        // copied from openUI5 _MetadataConverter.js
+        switch (type) {
+            case "$AnnotationPath":
+            case "$NavigationPropertyPath":
+            case "$Path":
+            case "$PropertyPath":
+            case "$Binary":
+            case "$Date":
+            case "$DateTimeOffset":
+            case "$Decimal":
+            case "$Duration":
+            case "$Guid":
+            case "$TimeOfDay":
+            case "$UrlRef":
+            case "$EnumMember":
+                return true;
+        }
+    }
+    static getWrappedProperty(item) {
+        if (typeof item === "object") {
+            const keys = Object.keys(item);
+            if (keys.length === 1 && this.isWrapped(keys[0])) {
+                return {
+                    property: keys[0].substring(1),
+                    value: item[keys[0]]
+                };
+            }
+        }
+    }
+}
+//# sourceMappingURL=ui5JsonConverter.js.map

package/dist/annotations/converter/ui5MetadataJsonUtil.d.ts

@@ -0,0 +1,3 @@
+export default class UI5MetadataJsonUtil {
+    static getAnnotationsNode(json: any): any;
+}

package/dist/annotations/converter/ui5MetadataJsonUtil.js

@@ -0,0 +1,10 @@
+export default class UI5MetadataJsonUtil {
+    static getAnnotationsNode(json) {
+        for (const key of Object.keys(json)) {
+            if (json[key].$kind === "Schema") {
+                return json[key].$Annotations;
+            }
+        }
+    }
+}
+//# sourceMappingURL=ui5MetadataJsonUtil.js.map

package/dist/annotations/converter/ui5XmlConverter.d.ts

@@ -0,0 +1,5 @@
+export default class UI5XmlConverter {
+    static convertV2(xml: string): any;
+    static convertV4(xml: string): any;
+    private static getDocument;
+}

package/dist/annotations/converter/ui5XmlConverter.js

@@ -0,0 +1,14 @@
+import { V2MetadataConverter, V4MetadataConverter } from "../../../dist/bundle.js";
+import { JSDOM } from "jsdom";
+export default class UI5XmlConverter {
+    static convertV2(xml) {
+        return new V2MetadataConverter().convertXMLMetadata(this.getDocument(xml));
+    }
+    static convertV4(xml) {
+        return new V4MetadataConverter().convertXMLMetadata(this.getDocument(xml));
+    }
+    static getDocument(xml) {
+        return (new JSDOM(xml, { contentType: "application/xml" })).window._document;
+    }
+}
+//# sourceMappingURL=ui5XmlConverter.js.map

package/dist/annotations/dataSource/dataSource.d.ts

@@ -0,0 +1,34 @@
+import I18nManager from "../../i18nManager.js";
+import { IAnnotationDownloadParams } from "./dataSourceOData.js";
+import Language from "../../model/language.js";
+import ServiceRequestor from "../serviceRequestor.js";
+import Transformer from "../transformers/transformer.js";
+export default class DataSource {
+    protected name: string;
+    private uri;
+    protected jsonTransformers: Transformer[];
+    constructor(name: string, uri: string);
+    /**
+     * Update the json of the dataSources in manifest.json
+     */
+    updateManifest(_: any): void;
+    /**
+     * Get the filename under which it should be stored in dist folder
+     */
+    getFilename(): string;
+    createAnnotationFile(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<{
+        filename: string;
+        xml: string;
+    }>;
+    /**
+     * Download the annotation for all configured languages
+     * @param languages from configuration
+     * @param serviceRequestor will download the annotation for all languages
+     */
+    private getPromisesPerLanguage;
+    /**
+     * Download annotations and process xml string after it
+     */
+    downloadAnnotation(language: Language, serviceRequestor: ServiceRequestor): Promise<any>;
+    afterXmlDownload({ xml, language, serviceRequestor, uri }: IAnnotationDownloadParams): Promise<any>;
+}

package/dist/annotations/dataSource/dataSource.js

@@ -0,0 +1,62 @@
+import XmlUtil from "../../util/xmlUtil.js";
+export default class DataSource {
+    name;
+    uri;
+    jsonTransformers = new Array();
+    constructor(name, uri) {
+        this.name = name;
+        this.uri = uri;
+    }
+    /**
+     * Update the json of the dataSources in manifest.json
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    updateManifest(_) {
+        // to be overriden in children
+    }
+    /**
+     * Get the filename under which it should be stored in dist folder
+     */
+    getFilename() {
+        return `annotations/annotation_${this.name}.xml`;
+    }
+    async createAnnotationFile(languages, i18nManager, serviceRequestor) {
+        const annotationJsons = this.getPromisesPerLanguage(languages, serviceRequestor);
+        const annotationJson = await i18nManager.populateTranslations(annotationJsons);
+        const xml = XmlUtil.jsonToXml(await annotationJson.json);
+        return {
+            filename: this.getFilename(),
+            xml
+        };
+    }
+    /**
+     * Download the annotation for all configured languages
+     * @param languages from configuration
+     * @param serviceRequestor will download the annotation for all languages
+     */
+    getPromisesPerLanguage(languages, serviceRequestor) {
+        const promises = new Map();
+        for (const language of languages) {
+            promises.set(language, this.downloadAnnotation(language, serviceRequestor));
+        }
+        return promises;
+    }
+    /**
+     * Download annotations and process xml string after it
+     */
+    async downloadAnnotation(language, serviceRequestor) {
+        const languageXmlContent = await serviceRequestor.downloadAnnotation(this.uri, this.name, language);
+        if (!languageXmlContent) {
+            throw new Error(`Xml is undefined for '${this.uri}', name '${this.name}' and language '${language.sap}'`);
+        }
+        return this.afterXmlDownload({ xml: languageXmlContent, language, serviceRequestor, uri: this.uri });
+    }
+    async afterXmlDownload({ xml, language, serviceRequestor, uri }) {
+        let json = XmlUtil.xmlToJson(xml);
+        for (const transformer of this.jsonTransformers) {
+            json = await transformer.transform({ xml, json, language, serviceRequestor, uri });
+        }
+        return json;
+    }
+}
+//# sourceMappingURL=dataSource.js.map

package/dist/annotations/dataSource/dataSourceManager.d.ts

@@ -0,0 +1,12 @@
+import I18nManager from "../../i18nManager.js";
+import Language from "../../model/language.js";
+import ServiceRequestor from "../serviceRequestor.js";
+export default class DataSourceManager {
+    private dataSources;
+    /**
+     * Parses dataSources from manifest.json.
+     * @param dataSourcesJson manifest.json/sap.app/dataSources node
+     */
+    addDataSources(dataSourcesJson: any): void;
+    createAnnotationFiles(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<Map<string, string>>;
+}

package/dist/annotations/dataSource/dataSourceManager.js

@@ -0,0 +1,45 @@
+import DataSourceOData from "./dataSourceOData.js";
+import DataSourceODataAnnotation from "./dataSourceODataAnnotation.js";
+import path from "path/posix";
+export default class DataSourceManager {
+    dataSources = new Array();
+    /**
+     * Parses dataSources from manifest.json.
+     * @param dataSourcesJson manifest.json/sap.app/dataSources node
+     */
+    addDataSources(dataSourcesJson) {
+        if (!dataSourcesJson) {
+            return;
+        }
+        const odataAnnotationMap = new Map();
+        // Loop over OData first to collect linked annotation names
+        for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
+            if (dataSource.uri?.startsWith("/") && dataSource.type === "OData") {
+                const uri = path.normalize(dataSource.uri + "/$metadata");
+                const odata = new DataSourceOData(name, uri, dataSource);
+                odata.getAnnotations().forEach(annotation => odataAnnotationMap.set(annotation, uri));
+                this.dataSources.push(odata);
+            }
+        }
+        // If ODataAnnotation is in OData annotations, pass metadata url to it
+        for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
+            const uri = dataSource.uri;
+            const metadataUrl = odataAnnotationMap.get(name);
+            if (uri?.startsWith("/") && dataSource.type === "ODataAnnotation") {
+                this.dataSources.push(new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl));
+            }
+        }
+        for (const dataSource of this.dataSources) {
+            dataSource.updateManifest(dataSourcesJson);
+        }
+    }
+    async createAnnotationFiles(languages, i18nManager, serviceRequestor) {
+        const annotationFiles = new Map();
+        for (const dataSource of this.dataSources) {
+            const { filename, xml } = await dataSource.createAnnotationFile(languages, i18nManager, serviceRequestor);
+            annotationFiles.set(filename, xml);
+        }
+        return annotationFiles;
+    }
+}
+//# sourceMappingURL=dataSourceManager.js.map

package/dist/annotations/dataSource/dataSourceOData.d.ts

@@ -0,0 +1,17 @@
+import DataSource from "./dataSource.js";
+import Language from "../../model/language.js";
+import ServiceRequestor from "../serviceRequestor.js";
+export interface IAnnotationDownloadParams {
+    uri: string;
+    xml: string;
+    language: Language;
+    serviceRequestor: ServiceRequestor;
+}
+export default class DataSourceOData extends DataSource {
+    private dataSourceJson;
+    constructor(name: string, uri: string, dataSourceJson: any);
+    updateManifest(manifestDataSources: any): void;
+    addNewODataAnnotation(manifestDataSources: any): void;
+    private getSettings;
+    getAnnotations(): string[];
+}

package/dist/annotations/dataSource/dataSourceOData.js

@@ -0,0 +1,45 @@
+import ConvertV2ToV4 from "../transformers/convertV2ToV4.js";
+import DataSource from "./dataSource.js";
+import MakeAnnotationNamespaceUnique from "../transformers/makeAnnotationNamespaceUnique.js";
+import RemoveAllSchemaNodesExceptAnnotations from "../transformers/removeAllSchemaNodesExceptAnnotations.js";
+import TraverseReferences from "../transformers/traverseReferences.js";
+import { getUniqueName } from "../../util/commonUtil.js";
+export default class DataSourceOData extends DataSource {
+    dataSourceJson;
+    constructor(name, uri, dataSourceJson) {
+        super(name, uri);
+        this.dataSourceJson = dataSourceJson;
+        this.jsonTransformers = [
+            new TraverseReferences(),
+            new ConvertV2ToV4(),
+            new RemoveAllSchemaNodesExceptAnnotations(),
+            new MakeAnnotationNamespaceUnique()
+        ];
+    }
+    updateManifest(manifestDataSources) {
+        this.getSettings().ignoreAnnotationsFromMetadata = true;
+        this.addNewODataAnnotation(manifestDataSources);
+    }
+    addNewODataAnnotation(manifestDataSources) {
+        const newAnnotationNameTemplate = `annotation_${this.name}`;
+        let newAnnotationName = getUniqueName(Object.keys(manifestDataSources), newAnnotationNameTemplate);
+        this.getAnnotations().unshift(newAnnotationName);
+        manifestDataSources[newAnnotationName] = {
+            type: "ODataAnnotation",
+            uri: this.getFilename()
+        };
+    }
+    getSettings() {
+        if (this.dataSourceJson.settings == null) {
+            this.dataSourceJson.settings = {};
+        }
+        return this.dataSourceJson.settings;
+    }
+    getAnnotations() {
+        if (this.getSettings().annotations == null) {
+            this.getSettings().annotations = [];
+        }
+        return this.getSettings().annotations;
+    }
+}
+//# sourceMappingURL=dataSourceOData.js.map

package/dist/annotations/dataSource/dataSourceODataAnnotation.d.ts

@@ -0,0 +1,6 @@
+import DataSource from "./dataSource.js";
+export default class DataSourceODataAnnotation extends DataSource {
+    private dataSourceJson;
+    constructor(name: string, uri: string, dataSourceJson: any, metadataUrl: string | undefined);
+    updateManifest(): void;
+}

package/dist/annotations/dataSource/dataSourceODataAnnotation.js

@@ -0,0 +1,16 @@
+import DataSource from "./dataSource.js";
+import TraverseReferences from "../transformers/traverseReferences.js";
+export default class DataSourceODataAnnotation extends DataSource {
+    dataSourceJson;
+    constructor(name, uri, dataSourceJson, metadataUrl) {
+        super(name, uri);
+        this.dataSourceJson = dataSourceJson;
+        this.jsonTransformers = [
+            new TraverseReferences(metadataUrl)
+        ];
+    }
+    updateManifest() {
+        this.dataSourceJson.uri = this.getFilename();
+    }
+}
+//# sourceMappingURL=dataSourceODataAnnotation.js.map

package/dist/annotations/serviceRequestor.d.ts

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