trm-core 9.10.6 → 10.0.1

package/dist/manifest/Manifest.js

@@ -49,6 +49,8 @@ const xmldom_1 = require("@xmldom/xmldom");
 const lodash_1 = __importDefault(require("lodash"));
 const xml_beautify_1 = __importDefault(require("xml-beautify"));
 const trm_commons_1 = require("trm-commons");
+const engines_1 = require("./engines");
+const sapEntries_1 = require("./sapEntries");
 function getManifestAuthor(sAuthor) {
     var author = {};
     const emailRegex = new RegExp("<([^>]*)>");
@@ -65,8 +67,8 @@ class Manifest {
         this._manifest = _manifest;
         this._filePath = _filePath;
     }
-    get(keepRuntimeValues = false) {
-        return Manifest.normalize(this._manifest, keepRuntimeValues);
+    get() {
+        return Manifest.normalize(this._manifest);
     }
     getKey(keepVersion = true) {
         const manifest = this.get();
@@ -81,13 +83,6 @@ class Manifest {
         this._manifest.srcFolder = src;
         return this;
     }
-    setLinkedTransport(transport) {
-        this._manifest.linkedTransport = transport;
-        return this;
-    }
-    getLinkedTransport() {
-        return this._manifest.linkedTransport;
-    }
     setRegistryEndpoint(endpoint) {
         this._manifest.registry = endpoint;
     }
@@ -108,10 +103,11 @@ class Manifest {
             "authors",
             "keywords",
             "dependencies",
+            "engines",
             "sapEntries",
             "postActivities"
         ];
-        var obj = this.get(false);
+        var obj = this.get();
         ignoredKeys.forEach(k => {
             delete obj[k];
         });
@@ -282,6 +278,36 @@ class Manifest {
                 };
             }
         }
+        /*if (manifest.sapEntries) {
+            var sapEntries = [];
+            Object.keys(manifest.sapEntries).forEach(table => {
+                try {
+                    var tableItems = [];
+                    manifest.sapEntries[table].forEach(r => {
+                        var record = {};
+                        Object.keys(r).forEach(k => {
+                            record[k] = {
+                                "_text": r[k]
+                            }
+                        });
+                        if (Object.keys(record).length > 0) {
+                            tableItems.push(record);
+                        }
+                    });
+                    sapEntries.push({
+                        "TABLE": table,
+                        "ENTRIES": {
+                            "item": tableItems
+                        }
+                    });
+                } catch (e) { }
+            });
+            if (sapEntries.length > 0) {
+                oAbapXml['asx:abap']['asx:values']['TRM_MANIFEST']['SAP_ENTRIES'] = {
+                    "item": sapEntries
+                }
+            }
+        }*/
         if (manifest.postActivities) {
             var postActivities = [];
             manifest.postActivities.forEach(pa => {
@@ -312,19 +338,34 @@ class Manifest {
                 };
             }
         }
+        if (manifest.engines) {
+            oAbapXml['asx:abap']['asx:values']['TRM_MANIFEST']['ENGINES'] = {
+                //escape xml special characters as json unicode escapes, JSON.parse restores them
+                "_text": JSON.stringify(manifest.engines).replace(/&/g, '\\u0026').replace(/</g, '\\u003c').replace(/>/g, '\\u003e')
+            };
+        }
         const sXml = xml.js2xml(oAbapXml, { compact: true });
         return sXml ? new xml_beautify_1.default({ useSelfClosingElement: true, parser: xmldom_1.DOMParser }).beautify(sXml) : null;
     }
     getPackage() {
-        const manifest = this.get(true);
+        const manifest = this.get();
         const registry = registry_1.RegistryProvider.getRegistry(manifest.registry, this._filePath);
         return new trmPackage_1.TrmPackage(manifest.name, registry, this);
     }
-    static normalize(manifest, keepRuntimeValues) {
+    /**
+     * Checks whether a dependency version is an acceptable semantic-version range.
+     *
+     * Stricter than `semver.validRange`: an empty or blank range (which semver reads as `*`)
+     * is rejected, so every dependency must declare an explicit range.
+     */
+    static isValidDependencyRange(range) {
+        return typeof range === 'string' && range.trim().length > 0 && semver.validRange(range) !== null;
+    }
+    static normalize(manifest) {
+        //this function is also used for method get()
+        //only keys will throw error
+        //always check if property has value
         var manifestClone = lodash_1.default.cloneDeep(manifest);
-        if (!keepRuntimeValues) {
-            delete manifestClone.linkedTransport;
-        }
         if (!manifestClone.name) {
             throw new Error('Package name missing.');
         }
@@ -520,17 +561,21 @@ class Manifest {
             delete manifestClone.sapEntries;
         }
         else {
-            for (const key in manifestClone.sapEntries) {
-                if (!Array.isArray(manifestClone.sapEntries[key])) {
-                    throw new Error(`Invalid structure in SAP entries declaration.`);
-                }
-                for (const item of manifestClone.sapEntries[key]) {
-                    if (typeof item !== 'object' || item === null) {
-                        throw new Error(`Invalid structure in SAP entries declaration.`);
-                    }
-                }
+            const sapEntriesErrors = (0, sapEntries_1.validateSapEntries)(manifestClone.sapEntries);
+            if (sapEntriesErrors.length > 0) {
+                throw new Error(`Invalid SAP entries declaration: ${sapEntriesErrors[0]}`);
             }
         }
+        if (!manifestClone.engines || typeof manifestClone.engines !== 'object' || Object.keys(manifestClone.engines).length === 0) {
+            delete manifestClone.engines;
+        }
+        else {
+            const enginesErrors = (0, engines_1.validateEngines)(manifestClone.engines);
+            if (enginesErrors.length > 0) {
+                throw new Error(`Invalid engines declaration: ${enginesErrors[0]}`);
+            }
+            manifestClone.engines = (0, engines_1.normalizeEngines)(manifestClone.engines);
+        }
         if (manifestClone.distFolder) {
             try {
                 manifestClone.distFolder = manifestClone.distFolder.replace(/^\//, '');
@@ -602,9 +647,9 @@ class Manifest {
             manifest = {
                 name: oAbapManifest.name.text,
                 version: oAbapManifest.version.text,
-                backwardsCompatible: false,
-                private: false,
-                registry: registry_1.PUBLIC_RESERVED_KEYWORD
+                backwardsCompatible: false, //default overwitten later
+                private: false, //default overwitten later,
+                registry: registry_1.PUBLIC_RESERVED_KEYWORD //default overwritten later
             };
         }
         catch (e) {
@@ -710,6 +755,14 @@ class Manifest {
                     }];
             }
         }
+        if (oAbapManifest.engines && oAbapManifest.engines.text) {
+            try {
+                manifest.engines = JSON.parse(oAbapManifest.engines.text);
+            }
+            catch (e) {
+                trm_commons_1.Logger.error(`Couldn't parse engines in abap xml manifest`, true);
+            }
+        }
         if (sapEntries && sapEntries.item) {
             manifest.sapEntries = {};
             try {
@@ -730,7 +783,7 @@ class Manifest {
             }
             catch (e) { }
         }
-        return new Manifest(Manifest.normalize(manifest, false));
+        return new Manifest(Manifest.normalize(manifest));
     }
     static _parseAbapXmlSapEntriesArray(input) {
         var array = [];
@@ -756,7 +809,7 @@ class Manifest {
         return array;
     }
     static fromJson(sJson) {
-        return new Manifest(Manifest.normalize(JSON.parse(sJson), false));
+        return new Manifest(Manifest.normalize(JSON.parse(sJson)));
     }
     static compare(o1, o2, checkVersion = false) {
         const s1 = o1.getKey(checkVersion);

package/dist/manifest/PostActivity.js

@@ -58,7 +58,7 @@ class PostActivity {
         return __awaiter(this, void 0, void 0, function* () {
             const data = Buffer.from(this._xml, 'utf8');
             trm_commons_1.Logger.loading(`Post activity: ${this.data.name}`, silent);
-            if (!PostActivity.exists(this.data.name)) {
+            if (!(yield PostActivity.exists(this.data.name))) {
                 throw new Error(`Class "${this.data.name}" doesn't exist.`);
             }
             const description = yield this.getDescription();
@@ -112,7 +112,7 @@ class PostActivity {
                     v3: message.msgv3,
                     v4: message.msgv4,
                 });
-                trm_commons_1.Logger.msgty(message.msgty, parsedMessage, silent);
+                trm_commons_1.Logger.msgty(message.msgty, parsedMessage, { debug: silent, important: ['A', 'E', 'W'].includes(message.msgty) });
             }
         });
     }
@@ -159,7 +159,7 @@ class PostActivity {
     }
     static exists(className) {
         return __awaiter(this, void 0, void 0, function* () {
-            const classObject = systemConnector_1.SystemConnector.getObject('R3TR', 'CLAS', className.trim().toUpperCase());
+            const classObject = yield systemConnector_1.SystemConnector.getObject('R3TR', 'CLAS', className.trim().toUpperCase());
             return classObject ? true : false;
         });
     }

package/dist/manifest/TrmManifest.d.ts

@@ -1,4 +1,3 @@
-import { Transport } from "../transport";
 import { TrmManifestBase } from "./TrmManifestBase";
 import { TrmManifestNamespace } from "./TrmManifestNamespace";
 export interface TrmManifest extends TrmManifestBase {
@@ -6,7 +5,6 @@ export interface TrmManifest extends TrmManifestBase {
     version: string;
     private?: boolean;
     registry?: string;
-    linkedTransport?: Transport;
     distFolder?: string;
     srcFolder?: string;
     namespace?: TrmManifestNamespace;

package/dist/manifest/TrmManifestBase.d.ts

@@ -1,5 +1,6 @@
 import { TrmManifestAuthor } from "./TrmManifestAuthor";
 import { TrmManifestDependency } from "./TrmManifestDependency";
+import { TrmManifestEngines } from "./TrmManifestEngines";
 import { TrmManifestPostActivity } from "./TrmManifestPostActivity";
 export interface TrmManifestBase {
     backwardsCompatible?: boolean;
@@ -12,4 +13,5 @@ export interface TrmManifestBase {
     dependencies?: TrmManifestDependency[];
     sapEntries?: any;
     postActivities?: TrmManifestPostActivity[];
+    engines?: TrmManifestEngines;
 }

package/dist/manifest/TrmManifestEngines.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Software component constraint (table CVERS).
+ * - `true`: component must be installed
+ * - `false`: component must NOT be installed
+ * - object: component must be installed and match release/sp ranges
+ * - array: at least one of the constraints must match
+ */
+export type TrmManifestEngineComponentConstraint = {
+    release?: string;
+    sp?: string;
+};
+export type TrmManifestEngineComponent = boolean | TrmManifestEngineComponentConstraint | TrmManifestEngineComponentConstraint[];
+/**
+ * Product constraint (table PRDVERS, installed versions only).
+ */
+export type TrmManifestEngineProductConstraint = {
+    version?: string;
+};
+export type TrmManifestEngineProduct = boolean | TrmManifestEngineProductConstraint | TrmManifestEngineProductConstraint[];
+/**
+ * SAP Note constraint (tables CWBNTCUST/CWBNTHEAD).
+ * - `true`: note must be completely implemented
+ * - object: note must be completely implemented with a version matching the range
+ */
+export type TrmManifestEngineNoteConstraint = {
+    version?: string;
+};
+export type TrmManifestEngineNote = true | TrmManifestEngineNoteConstraint;
+export type TrmManifestEngineTableOperator = 'EQ' | 'NE' | 'LT' | 'LE' | 'GT' | 'GE' | 'LIKE';
+export type TrmManifestEngineTableCondition = {
+    field: string;
+    op?: TrmManifestEngineTableOperator;
+    value: string;
+};
+/**
+ * Table check: at least one row matching all conditions must exist.
+ */
+export type TrmManifestEngineTableCheck = {
+    table: string;
+    where: TrmManifestEngineTableCondition[];
+};
+/**
+ * TRM constraint: semver range of a TRM package.
+ * - `trm-core`: version of the trm-core running the install
+ * - `trm-server`: version of trm-server installed on the system
+ */
+export type TrmManifestEngineTrm = {
+    'trm-core'?: string;
+    'trm-server'?: string;
+};
+export type TrmManifestEngines = {
+    trm?: TrmManifestEngineTrm;
+    components?: {
+        [component: string]: TrmManifestEngineComponent;
+    };
+    products?: {
+        [product: string]: TrmManifestEngineProduct;
+    };
+    notes?: {
+        [note: string]: TrmManifestEngineNote;
+    };
+    tables?: TrmManifestEngineTableCheck[];
+    anyOf?: TrmManifestEngines[];
+};

package/dist/manifest/TrmManifestEngines.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/manifest/engines/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sapRange";
+export * from "./validateEngines";

package/dist/manifest/engines/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sapRange"), exports);
+__exportStar(require("./validateEngines"), exports);

package/dist/manifest/engines/sapRange.d.ts

@@ -0,0 +1,38 @@
+/**
+ * SAP-aware version ranges, used by manifest engines.
+ *
+ * Syntax (semver-like):
+ * - comparator: `>=`, `>`, `<=`, `<`, `=` or none (exact match), followed by a value
+ * - comparators separated by whitespace must all match (AND)
+ * - comparator sets separated by `||` are alternatives (OR)
+ *
+ * Comparison modes:
+ * - `release`: software component release (e.g. `758`, `75I`, `2020`). Numeric when both values
+ *   are digits only, otherwise character-wise (0-9 < A-Z) when both values have the same length.
+ *   Values that can't be compared never satisfy the comparator.
+ * - `version`: dotted numeric version (e.g. product version `7.52`, `2023`)
+ * - `number`: integer (e.g. support package level, SAP Note version)
+ */
+export type SapRangeMode = 'release' | 'version' | 'number';
+/**
+ * Compares two values according to mode.
+ * Returns a negative number, zero or a positive number, or `undefined` when values can't be compared.
+ */
+export declare function compareSapValues(a: string, b: string, mode: SapRangeMode): number | undefined;
+/**
+ * Normalizes a value read from the system (e.g. CVERS-EXTRELEASE `0000000002`) or declared in a range.
+ * Returns `undefined` when the value is not valid for mode.
+ */
+export declare function normalizeSapValue(value: string | number, mode: SapRangeMode): string | undefined;
+export declare function validSapRange(range: string, mode: SapRangeMode): boolean;
+export declare function satisfiesSapRange(value: string | number, range: string, mode: SapRangeMode): boolean;
+export type SapSupportPackage = {
+    release: string;
+    sp: number;
+    component?: string;
+};
+/**
+ * Parses a support package name, e.g. `SAPK-75017INSAPUI` -> release `750`, sp `17`, component `SAPUI`.
+ * Also accepts the short form `SAPKB75017` (component not derivable).
+ */
+export declare function parseSupportPackage(supportPackage: string): SapSupportPackage | undefined;

package/dist/manifest/engines/sapRange.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSapValues = compareSapValues;
+exports.normalizeSapValue = normalizeSapValue;
+exports.validSapRange = validSapRange;
+exports.satisfiesSapRange = satisfiesSapRange;
+exports.parseSupportPackage = parseSupportPackage;
+const VALUE_PATTERNS = {
+    release: /^[0-9A-Z]+$/,
+    version: /^\d+(\.\d+)*$/,
+    number: /^\d+$/
+};
+const COMPARATOR_REGEX = /^(>=|<=|>|<|=)?(.+)$/;
+function parseSapRange(range, mode) {
+    if (typeof range !== 'string') {
+        throw new Error(`Range must be a string.`);
+    }
+    const sets = range.split('||').map(set => {
+        //allow a space between operator and value (">= 750")
+        const tokens = set.trim().toUpperCase().replace(/(>=|<=|>|<|=)\s+/g, '$1').split(/\s+/).filter(t => t);
+        if (tokens.length === 0) {
+            throw new Error(`Empty comparator set in range "${range}".`);
+        }
+        return tokens.map(token => {
+            const match = COMPARATOR_REGEX.exec(token);
+            const value = match[2];
+            if (!VALUE_PATTERNS[mode].test(value)) {
+                throw new Error(`Invalid value "${value}" in range "${range}".`);
+            }
+            return {
+                operator: (match[1] || '='),
+                value
+            };
+        });
+    });
+    return sets;
+}
+function compareVersion(a, b) {
+    const aParts = a.split('.').map(p => parseInt(p, 10));
+    const bParts = b.split('.').map(p => parseInt(p, 10));
+    const length = Math.max(aParts.length, bParts.length);
+    for (var i = 0; i < length; i++) {
+        const diff = (aParts[i] || 0) - (bParts[i] || 0);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+/**
+ * Compares two values according to mode.
+ * Returns a negative number, zero or a positive number, or `undefined` when values can't be compared.
+ */
+function compareSapValues(a, b, mode) {
+    a = normalizeSapValue(a, mode);
+    b = normalizeSapValue(b, mode);
+    if (a === undefined || b === undefined) {
+        return undefined;
+    }
+    switch (mode) {
+        case 'number':
+            return parseInt(a, 10) - parseInt(b, 10);
+        case 'version':
+            return compareVersion(a, b);
+        case 'release':
+            if (/^\d+$/.test(a) && /^\d+$/.test(b)) {
+                return parseInt(a, 10) - parseInt(b, 10);
+            }
+            if (a.length !== b.length) {
+                return undefined;
+            }
+            return a < b ? -1 : a > b ? 1 : 0;
+    }
+}
+/**
+ * Normalizes a value read from the system (e.g. CVERS-EXTRELEASE `0000000002`) or declared in a range.
+ * Returns `undefined` when the value is not valid for mode.
+ */
+function normalizeSapValue(value, mode) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const sValue = value.toString().trim().toUpperCase();
+    if (!VALUE_PATTERNS[mode].test(sValue)) {
+        return undefined;
+    }
+    if (mode === 'number') {
+        return parseInt(sValue, 10).toString();
+    }
+    return sValue;
+}
+function validSapRange(range, mode) {
+    try {
+        parseSapRange(range, mode);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function satisfiesSapRange(value, range, mode) {
+    const sets = parseSapRange(range, mode);
+    const sValue = normalizeSapValue(value, mode);
+    if (sValue === undefined) {
+        return false;
+    }
+    return sets.some(set => set.every(comparator => {
+        const result = compareSapValues(sValue, comparator.value, mode);
+        if (result === undefined) {
+            return false;
+        }
+        switch (comparator.operator) {
+            case '>=': return result >= 0;
+            case '>': return result > 0;
+            case '<=': return result <= 0;
+            case '<': return result < 0;
+            case '=': return result === 0;
+        }
+    }));
+}
+/**
+ * Parses a support package name, e.g. `SAPK-75017INSAPUI` -> release `750`, sp `17`, component `SAPUI`.
+ * Also accepts the short form `SAPKB75017` (component not derivable).
+ */
+function parseSupportPackage(supportPackage) {
+    const match = /^SAPK[A-Z-]([0-9A-Z]{3})(\d{2})(?:IN([0-9A-Z_]+))?$/.exec((supportPackage || '').trim().toUpperCase());
+    if (!match) {
+        return undefined;
+    }
+    return {
+        release: match[1],
+        sp: parseInt(match[2], 10),
+        component: match[3]
+    };
+}

package/dist/manifest/engines/validateEngines.d.ts

@@ -0,0 +1,44 @@
+import { TrmManifestEngines } from "../TrmManifestEngines";
+import { SapRangeMode } from "./sapRange";
+export declare const ENGINES_KEYS: readonly ["trm", "components", "products", "notes", "tables", "anyOf"];
+export declare const ENGINES_TRM_PACKAGES: readonly ["trm-core", "trm-server"];
+export declare const ENGINES_TABLE_OPERATORS: readonly ["EQ", "NE", "LT", "LE", "GT", "GE", "LIKE"];
+export declare const ENGINES_MAX_ANYOF_DEPTH = 3;
+export declare const COMPONENT_NAME_REGEX: RegExp;
+export declare const PRODUCT_NAME_REGEX: RegExp;
+export declare const NOTE_REGEX: RegExp;
+export declare const TABLE_NAME_REGEX: RegExp;
+export declare const FIELD_NAME_REGEX: RegExp;
+export declare const ENGINES_COMPONENT_PROPS: {
+    [prop: string]: SapRangeMode;
+};
+export declare const ENGINES_PRODUCT_PROPS: {
+    [prop: string]: SapRangeMode;
+};
+export declare const ENGINES_NOTE_PROPS: {
+    [prop: string]: SapRangeMode;
+};
+export declare const ENGINES_TABLE_PROPS: readonly ["table", "where"];
+export declare const ENGINES_TABLE_CONDITION_PROPS: readonly ["field", "op", "value"];
+export declare const TABLE_VALUE_MAX_LENGTH = 32;
+export declare const TABLE_VALUE_FORBIDDEN_REGEX: RegExp;
+export type ValidateEnginesOptions = {
+    /**
+     * When true, unknown keys are reported as errors (use on publish).
+     * When false, unknown keys are ignored (forward compatibility).
+     */
+    strict?: boolean;
+};
+export declare function normalizeEngineName(name: string): string;
+export declare function normalizeNoteNumber(note: string | number): string;
+export declare function validTrmRange(range: any): boolean;
+/**
+ * Formally validates a manifest engines declaration.
+ * Returns the list of errors (empty when valid).
+ */
+export declare function validateEngines(engines: any, options?: ValidateEnginesOptions): string[];
+/**
+ * Normalizes a (valid) engines declaration: uppercase names, note numbers without leading zeros,
+ * default table operator `EQ`. Unknown keys are kept untouched.
+ */
+export declare function normalizeEngines(engines: TrmManifestEngines): TrmManifestEngines;