@cap-js/ord 1.7.0 → 1.9.0

package/lib/configuration.js

@@ -1,36 +1,36 @@
 const path = require("path");
 const cds = require("@sap/cds");
-const _ = require("lodash");
 const { readFileSync } = require("fs");
 
 const Logger = require("./logger");
-const { getRFC3339Date } = require("./date");
 const defaults = require("./defaults");
-const { createEntityTypeMappingsItemTemplate } = require("./templates");
-const { CONTENT_MERGE_KEY, CDS_ELEMENT_KIND } = require("./constants");
+const { getRFC3339Date } = require("./common/utils");
+const { createAuthConfig } = require("./auth/authentication");
+const { resolveAccessStrategies } = require("./common/utils");
+const { CDS_ELEMENT_KIND } = require("./constants");
 
 module.exports = class Configuration {
     constructor(csn) {
         const env = cds.env["ord"];
-        const packageName = this._loadNameFromPackageJson();
+        const authConfig = createAuthConfig();
+        const packageName = env?.packageName ?? this._loadNameFromPackageJson();
         const eventApplicationNamespace = cds.env?.export?.asyncapi?.applicationNamespace;
-        const ordNamespace = cds.env["ord"]?.namespace || `customer.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
-        const internalNamespace = env?.internalNamespace;
+        const ordNamespace = env?.namespace || `customer.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
 
         if (eventApplicationNamespace && ordNamespace !== eventApplicationNamespace) {
             Logger.warn("ORD and AsyncAPI namespaces should be the same.");
         }
 
+        if (authConfig.error) {
+            throw new Error(`Authentication configuration error: ${authConfig.error}`);
+        }
+
         this._env = env;
         this._packageName = packageName;
         this._ordNamespace = ordNamespace;
-        this._internalNamespace = internalNamespace;
         this._lastUpdate = getRFC3339Date();
-        this._serviceNames = this._resolveServiceNames(csn);
-        this._existingProductORDId = env?.existingProductORDId;
-        this._apiResourceNames = this._resolveApiResourceNames(csn);
-        this._entityTypeTargets = this._resolveEntityTypeTargets(csn);
-        this._eventServiceNames = this._resolveEventServiceNames(csn);
+        this._csn = this._propagateORDVisibility(cds.linked(csn));
+        this._accessStrategies = resolveAccessStrategies(authConfig);
         this._appName = packageName.replace(/^@/, "").replace(/[@/]/g, "-");
         this._policyLevels = env?.policyLevels || (env?.policyLevel && [env?.policyLevel]) || defaults.policyLevels;
     }
@@ -39,6 +39,10 @@ module.exports = class Configuration {
         return this._env;
     }
 
+    get csn() {
+        return this._csn;
+    }
+
     get appName() {
         return this._appName;
     }
@@ -51,32 +55,20 @@ module.exports = class Configuration {
         return this._packageName;
     }
 
-    get serviceNames() {
-        return this._serviceNames;
-    }
-
     get ordNamespace() {
         return this._ordNamespace;
     }
 
-    get internalNamespace() {
-        return this._internalNamespace;
-    }
-
     get policyLevels() {
         return this._policyLevels;
     }
 
-    get apiResourceNames() {
-        return this._apiResourceNames;
+    get accessStrategies() {
+        return this._accessStrategies;
     }
 
-    get entityTypeTargets() {
-        return this._entityTypeTargets;
-    }
-
-    get eventServiceNames() {
-        return this._eventServiceNames;
+    get internalNamespace() {
+        return this._env?.internalNamespace;
     }
 
     get hasSAPPolicyLevel() {
@@ -84,12 +76,7 @@ module.exports = class Configuration {
     }
 
     get existingProductORDId() {
-        return this._existingProductORDId;
-    }
-
-    _resolveServiceNames(csn) {
-        return Object.keys(csn.definitions) //
-            .filter((name) => this._isValidService(name, csn.definitions[name]));
+        return this._env?.existingProductORDId;
     }
 
     _loadNameFromPackageJson() {
@@ -102,60 +89,18 @@ module.exports = class Configuration {
         return JSON.parse(readFileSync(packageJsonPath, "utf-8")).name;
     }
 
-    _isBlockedServiceName(name) {
-        return ["cds.xt.MTXServices", "MtxOrdProviderService", "OpenResourceDiscoveryService"] //
-            .some((blocked) => name.includes(blocked));
-    }
-
-    _resolveApiResourceNames(csn) {
-        return Object.keys(csn.definitions)
-            .filter((name) => this._isValidService(name, csn.definitions[name]))
-            .filter((name) => !this._serviceOnlyContainsEvents(csn.definitions[name]));
-    }
+    _propagateORDVisibility(csn) {
+        const annotation = "@ORD.Extensions.visibility";
 
-    _resolveEntityTypeTargets(csn) {
-        return _.uniqBy(
-            Object.keys(csn.definitions)
-                .filter((name) => !name.includes(".texts"))
-                .filter((name) => !this._isBlockedServiceName(name))
-                .filter((name) => csn.definitions[name].kind === CDS_ELEMENT_KIND.entity)
-                .filter((name) => csn.definitions[name]["_service"]?.["@protocol"] !== "none")
-                .flatMap((name) => createEntityTypeMappingsItemTemplate(csn.definitions[name]) || []),
-            CONTENT_MERGE_KEY,
-        );
-    }
-
-    _resolveEventServiceNames(csn) {
-        const serviceNames = this._resolveServiceNames(csn);
-
-        return [
-            ...new Set(
-                Object.keys(csn.definitions)
-                    .filter((name) => !this._isBlockedServiceName(name))
-                    .filter((name) => csn.definitions[name].kind === CDS_ELEMENT_KIND.event)
-                    .filter((name) => csn.definitions[name]["_service"]?.["@protocol"] !== "none")
-                    .filter((name) => serviceNames.some((serviceName) => name.startsWith(`${serviceName}.`)))
-                    .map((name) => serviceNames.find((serviceName) => name.startsWith(`${serviceName}.`))),
-            ),
-        ];
-    }
-
-    _isValidService(key, definition) {
-        const isExternalService = Object.keys(cds).includes("requires") && Object.keys(cds.requires).includes(key);
-
-        return (
-            definition.kind === CDS_ELEMENT_KIND.service &&
-            !definition["@cds.external"] &&
-            definition["@protocol"] !== "none" &&
-            !isExternalService &&
-            !this._isBlockedServiceName(key)
-        );
-    }
+        Object.values(csn.definitions)
+            .filter((service) => Boolean(service[annotation]))
+            .filter((definition) => definition.kind === CDS_ELEMENT_KIND.service)
+            .forEach((service) => {
+                Object.values(csn.definitions)
+                    .filter((definition) => definition.name.startsWith(`${service.name}.`))
+                    .forEach((definition) => (definition[annotation] ??= service[annotation]));
+            });
 
-    _serviceOnlyContainsEvents(definition) {
-        return (
-            Object.keys(definition.events || {}).length > 0 &&
-            ["actions", "entities", "functions"].every((key) => Object.keys(definition[key] || {}).length === 0)
-        );
+        return csn;
     }
 };

package/lib/constants.js

@@ -1,9 +1,3 @@
-const AUTHENTICATION_TYPE = Object.freeze({
-    Open: "open",
-    Basic: "basic",
-    CfMtls: "cf-mtls",
-});
-
 const BASIC_AUTH_HEADER_KEY = "authorization";
 
 const BUILD_DEFAULT_PATH = "gen/ord";
@@ -11,13 +5,8 @@ const BUILD_DEFAULT_PATH = "gen/ord";
 const ORD_ACCESS_STRATEGY = Object.freeze({
     Open: "open",
     Basic: "basic-auth",
-    CfMtls: "sap:cmp-mtls:v1",
-});
-
-const AUTH_TYPE_ORD_ACCESS_STRATEGY_MAP = Object.freeze({
-    [AUTHENTICATION_TYPE.Open]: ORD_ACCESS_STRATEGY.Open,
-    [AUTHENTICATION_TYPE.Basic]: ORD_ACCESS_STRATEGY.Basic,
-    [AUTHENTICATION_TYPE.CfMtls]: ORD_ACCESS_STRATEGY.CfMtls,
+    CmpMtls: "sap:cmp-mtls:v1",
+    BahMtls: "sap.businesshub:mtls:v1",
 });
 
 // CF mTLS default header names
@@ -42,15 +31,6 @@ const CDS_ELEMENT_KIND = Object.freeze({
     type: "type",
 });
 
-const COMPILER_TYPES = Object.freeze({
-    oas3: "oas3",
-    asyncapi2: "asyncapi2",
-    edmx: "edmx",
-    csn: "csn",
-    mcp: "mcp",
-    graphql: "graphql",
-});
-
 const CONTENT_MERGE_KEY = "ordId";
 
 const DATA_PRODUCT_ANNOTATION = "@DataIntegration.dataProduct.type";
@@ -116,8 +96,6 @@ const EXTERNAL_DP_ORD_ID_ANNOTATION = "@cds.dp.ordId";
 
 const EXTERNAL_SERVICE_ANNOTATION = "@cds.external";
 
-const INTEGRATION_DEPENDENCY_RESOURCE_NAME = "externalDependencies";
-
 // ORD apiProtocol values
 const ORD_API_PROTOCOL = Object.freeze({
     ODATA_V4: "odata-v4",
@@ -149,9 +127,6 @@ const ORD_ONLY_PROTOCOLS = Object.freeze({
     },
 });
 
-// Protocols that the ORD plugin cannot currently generate definitions for
-const PLUGIN_UNSUPPORTED_PROTOCOLS = Object.freeze([]);
-
 // CF mTLS Error Reasons
 const CF_MTLS_ERROR_REASON = Object.freeze({
     NO_HEADERS: "NO_HEADERS",
@@ -183,14 +158,11 @@ const DOCUMENT_PERSPECTIVES = Object.freeze({
 const LOCAL_TENANT_ID_HEADER_KEY = "local-tenant-id";
 
 module.exports = {
-    AUTHENTICATION_TYPE,
-    AUTH_TYPE_ORD_ACCESS_STRATEGY_MAP,
     BASIC_AUTH_HEADER_KEY,
     BUILD_DEFAULT_PATH,
     CAP_TO_ORD_PROTOCOL_MAP,
     CDS_ELEMENT_KIND,
     CF_MTLS_HEADERS,
-    COMPILER_TYPES,
     CONTENT_MERGE_KEY,
     DATA_PRODUCT_ANNOTATION,
     DATA_PRODUCT_SIMPLE_ANNOTATION,
@@ -199,7 +171,6 @@ module.exports = {
     ENTITY_RELATIONSHIP_ANNOTATION,
     EXTERNAL_DP_ORD_ID_ANNOTATION,
     EXTERNAL_SERVICE_ANNOTATION,
-    INTEGRATION_DEPENDENCY_RESOURCE_NAME,
     LEVEL,
     MCP_RESOURCE_DEFINITION_TYPE,
     OPENAPI_SERVERS_ANNOTATION,
@@ -212,7 +183,6 @@ module.exports = {
     ORD_ONLY_PROTOCOLS,
     ORD_RESOURCE_TYPE,
     ORD_SERVICE_NAME,
-    PLUGIN_UNSUPPORTED_PROTOCOLS,
     RESOURCE_VISIBILITY,
     ALLOWED_VISIBILITY,
     IMPLEMENTATIONSTANDARD_VERSIONS,

package/lib/defaults.js

@@ -1,75 +1,12 @@
 const fs = require("fs");
-const _ = require("lodash");
 const cds = require("@sap/cds");
 const { join } = require("path");
 
-const {
-    ORD_RESOURCE_TYPE,
-    SHORT_DESCRIPTION_PREFIX,
-    RESOURCE_VISIBILITY,
-    DOCUMENT_PERSPECTIVES,
-    CONTENT_MERGE_KEY,
-} = require("./constants");
+const { slice } = require("./common/slice");
+const { DOCUMENT_PERSPECTIVES } = require("./constants");
+const { resolveAccessStrategies } = require("./common/utils");
 
-const stringTypeCheck = (value) => typeof value === "string";
-const arrayTypeCheck = (value) => Array.isArray(value);
-
-// see ref: https://pages.github.tools.sap/CentralEngineering/open-resource-discovery-specification/spec-v1/interfaces/document#package
-const packageTypeChecks = {
-    policyLevels: arrayTypeCheck,
-    packageLinks: arrayTypeCheck,
-    links: arrayTypeCheck,
-    licenseType: stringTypeCheck,
-    supportInfo: stringTypeCheck,
-    vendor: stringTypeCheck,
-    countries: arrayTypeCheck,
-    lineOfBusiness: arrayTypeCheck,
-    industry: arrayTypeCheck,
-    runtimeRestriction: stringTypeCheck,
-    tags: arrayTypeCheck,
-    labels: arrayTypeCheck,
-    documentationLabels: arrayTypeCheck,
-};
-
-const regexWithRemoval = (name) => {
-    return name?.replace(/[^a-zA-Z0-9]/g, "");
-};
-
-const nameWithDot = (name) => {
-    return regexWithRemoval(name.charAt(0)) + name.slice(1, name.length).replace(/[^a-zA-Z0-9]/g, ".");
-};
-
-const nameWithSpaces = (name) => {
-    return regexWithRemoval(name.charAt(0)) + name.slice(1, name.length).replace(/[^a-zA-Z0-9]/g, " ");
-};
-
-const defaultProductOrdId = (name) => `customer:product:${nameWithDot(name)}:`;
-
-const generatePackageDescriptions = (name, type, visibility) => ({
-    shortDescription: `Package containing ${visibility} ${type}`,
-    description: `This package contains ${visibility} ${type} for ${nameWithSpaces(name)}.`,
-});
-
-const generateUniquePackageOrdId = (ordNamespace, name, tag, visibility) => {
-    const visibilitySuffix = visibility === RESOURCE_VISIBILITY.public ? "" : `-${visibility}`;
-    return `${ordNamespace}:package:${regexWithRemoval(name)}${tag}${visibilitySuffix}:v1`;
-};
-
-const mapEnvPackageInfo = (packageConfig) => {
-    if (!packageConfig) {
-        return { vendor: undefined };
-    }
-
-    const filteredEnv = {};
-    for (const key in packageConfig) {
-        const value = packageConfig[key];
-        const checkFunction = packageTypeChecks[key];
-        if (value && checkFunction && checkFunction(value)) {
-            filteredEnv[key] = value;
-        }
-    }
-    return filteredEnv;
-};
+const sizeLimit = 2000000; // 2mb
 
 /**
  * Module containing default configuration for ORD Document.
@@ -77,86 +14,37 @@ const mapEnvPackageInfo = (packageConfig) => {
  */
 module.exports = {
     $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
-    openResourceDiscovery: "1.14",
+    openResourceDiscovery: "1.16",
     policyLevels: ["none"],
     groupTypeId: "sap.cds:service",
     description: "this is an application description",
-    products: (name) => [
-        {
-            ordId: defaultProductOrdId(name),
-            title: nameWithSpaces(name),
-            shortDescription: SHORT_DESCRIPTION_PREFIX + nameWithSpaces(name),
-            vendor: "customer:vendor:Customer:",
-        },
-    ],
-    packages: (appConfig, products) => {
-        const name = appConfig.appName;
-        const ordNamespace = appConfig.ordNamespace;
-        const productsOrdId = appConfig.existingProductORDId || products?.[0]?.ordId;
-        const { vendor, ...envValues } = mapEnvPackageInfo(appConfig?.env?.packages?.[0]);
-        const visibilities = !appConfig.hasSAPPolicyLevel
-            ? [RESOURCE_VISIBILITY.public]
-            : Object.values(RESOURCE_VISIBILITY);
-        const packageTypes = !appConfig.hasSAPPolicyLevel
-            ? [{ tag: "", type: "General" }]
-            : [
-                  { tag: `-${ORD_RESOURCE_TYPE.api}`, type: "APIs" },
-                  { tag: `-${ORD_RESOURCE_TYPE.event}`, type: "Events" },
-                  { tag: `-${ORD_RESOURCE_TYPE.entityType}`, type: "Entity Types" },
-                  { tag: `-${ORD_RESOURCE_TYPE.dataProduct}`, type: "Data Products" },
-                  { tag: `-${ORD_RESOURCE_TYPE.integrationDependency}`, type: "Integration Dependencies" },
-              ];
-
-        return _.uniqBy(
-            packageTypes.flatMap(({ tag, type }) =>
-                visibilities.map((visibility) => ({
-                    ordId: generateUniquePackageOrdId(ordNamespace, name, tag, visibility),
-                    title: nameWithSpaces(name),
-                    ...generatePackageDescriptions(name, type, visibility),
-                    version: "1.0.0",
-                    ...(productsOrdId && { partOfProducts: [productsOrdId || defaultProductOrdId(name)] }),
-                    vendor: vendor || "customer:vendor:Customer:",
-                    ...envValues,
-                })),
-            ),
-            CONTENT_MERGE_KEY,
-        );
-    },
-    consumptionBundles: (appConfig) => [
-        {
-            ordId: `${regexWithRemoval(appConfig.appName)}:consumptionBundle:noAuth:v1`,
-            version: "1.0.0",
-            lastUpdate: appConfig.lastUpdate,
-            title: "Unprotected resources",
-            shortDescription: "If we have another protected API then it will be another object",
-            description:
-                "This Consumption Bundle contains all resources of the reference app which are unprotected and do not require authentication",
-        },
-    ],
-    baseTemplate: (authConfig, tenant) => {
-        // Get access strategies from the provided authConfig
-        // If auth config is not available, fall back to empty array
-        const toggles = cds.env.requires.toggles;
-        const extensibility = cds.env.requires.extensibility;
-        const accessStrategies = authConfig?.accessStrategies || [];
+    sizeLimit: sizeLimit,
+    baseTemplate: (authConfig, document, tenantDocument) => {
+        const accessStrategies = resolveAccessStrategies(authConfig);
 
         return {
             openResourceDiscoveryV1: {
                 documents: [
-                    {
-                        url: "/ord/v1/documents/ord-document",
-                        perspective: DOCUMENT_PERSPECTIVES.SystemVersion,
-                        accessStrategies,
-                    },
-                    ...(!tenant || !(toggles || extensibility)
+                    ...Array(slice(document, sizeLimit).length)
+                        .fill(0)
+                        .map((_, i) => {
+                            return {
+                                url: `/ord/v1/documents/ord-document?part=${i}`,
+                                perspective: DOCUMENT_PERSPECTIVES.SystemVersion,
+                                accessStrategies,
+                            };
+                        }),
+                    ...(!tenantDocument
                         ? []
-                        : [
-                              {
-                                  url: `/ord/v1/documents/ord-document?perspective=${encodeURIComponent(DOCUMENT_PERSPECTIVES.SystemInstance)}`,
-                                  perspective: DOCUMENT_PERSPECTIVES.SystemInstance,
-                                  accessStrategies,
-                              },
-                          ]),
+                        : Array(slice(tenantDocument, sizeLimit).length)
+                              .fill(0)
+                              .map((_, i) => {
+                                  return {
+                                      url: `/ord/v1/documents/ord-document?part=${i}&perspective=${encodeURIComponent(DOCUMENT_PERSPECTIVES.SystemInstance)}`,
+                                      perspective: DOCUMENT_PERSPECTIVES.SystemInstance,
+                                      accessStrategies,
+                                  };
+                              })),
                 ],
             },
         };

package/lib/extend-ord-with-custom.js

@@ -1,68 +1,99 @@
-const { CONTENT_MERGE_KEY } = require("./constants");
 const cds = require("@sap/cds");
 const fs = require("fs");
 const Logger = require("./logger");
 const path = require("path");
 const _ = require("lodash");
 
-function cleanNullProperties(obj) {
-    for (const key in obj) {
-        if (obj[key] === null) {
-            delete obj[key];
-        } else if (typeof obj[key] === "object") {
-            cleanNullProperties(obj[key]);
-        }
-    }
-    return obj;
-}
-
-function patchGeneratedOrdResources(destinationObj, sourceObj) {
-    const destObj = _.keyBy(destinationObj, CONTENT_MERGE_KEY);
-    const srcObj = _.keyBy(sourceObj, CONTENT_MERGE_KEY);
+const SCALAR_TYPES = Object.freeze(["number", "string", "boolean"]);
 
-    for (const ordId in srcObj) {
-        destObj[ordId] =
-            ordId in destObj
-                ? _.assignWith(structuredClone(destObj[ordId]), structuredClone(srcObj[ordId]))
-                : srcObj[ordId];
-    }
+const MERGE_STRATEGIES = Object.freeze({
+    // Directly replace scalar values and scalar value arrays
+    $schema: (current, custom) => custom,
+    baseUrl: (current, custom) => custom,
+    description: (current, custom) => custom,
+    perspective: (current, custom) => custom,
+    policyLevel: (current, custom) => custom,
+    customPolicyLevel: (current, custom) => custom,
+    policyLevels: (current, custom) => prune(custom),
+    openResourceDiscovery: (current, custom) => custom,
 
-    return cleanNullProperties(Object.values(destObj));
-}
+    // Perform simple merge for objects
+    describedSystemType: (current, custom) => prune(_.assign(current, custom)),
+    describedSystemVersion: (current, custom) => prune(_.assign(current, custom)),
+    describedSystemInstance: (current, custom) => prune(_.assign(current, custom)),
 
-function compareAndHandleCustomORDContentWithExistingContent(ordContent, customORDContent) {
-    const clonedOrdContent = structuredClone(ordContent);
-    for (const key in customORDContent) {
-        const propertyType = typeof customORDContent[key];
-        if (propertyType !== "object" && propertyType !== "array") {
-            Logger.warn(
-                "Found ord top level primitive ord property in customOrdFile:",
-                key,
-                ". Please define it in .cdsrc.json.",
-            );
+    // Perform smart merge for arrays of objects
+    agents: (current, custom) => merge(current, custom, ["ordId"]),
+    vendors: (current, custom) => merge(current, custom, ["ordId"]),
+    overlays: (current, custom) => merge(current, custom, ["ordId"]),
+    products: (current, custom) => merge(current, custom, ["ordId"]),
+    packages: (current, custom) => merge(current, custom, ["ordId"]),
+    groups: (current, custom) => merge(current, custom, ["groupId"]),
+    entityTypes: (current, custom) => merge(current, custom, ["ordId"]),
+    apiResources: (current, custom) => merge(current, custom, ["ordId"]),
+    capabilities: (current, custom) => merge(current, custom, ["ordId"]),
+    dataProducts: (current, custom) => merge(current, custom, ["ordId"]),
+    eventResources: (current, custom) => merge(current, custom, ["ordId"]),
+    groupTypes: (current, custom) => merge(current, custom, ["groupTypeId"]),
+    consumptionBundles: (current, custom) => merge(current, custom, ["ordId"]),
+    integrationDependencies: (current, custom) => merge(current, custom, ["ordId"]),
+    tombstones: (current, custom) => merge(current, custom, ["ordId", "groupId", "groupTypeId"]),
+});
 
-            continue;
-        }
-        if (key in ordContent) {
-            clonedOrdContent[key] = patchGeneratedOrdResources(clonedOrdContent[key], customORDContent[key]);
-        } else {
-            clonedOrdContent[key] = customORDContent[key];
-        }
+function prune(entity) {
+    if (Array.isArray(entity)) {
+        return entity
+            .filter((value) => ![null, undefined].includes(value))
+            .map((value) => (SCALAR_TYPES.includes(typeof value) ? value : prune(value)));
     }
-    return clonedOrdContent;
+
+    return Object.fromEntries(
+        Object.entries(entity)
+            .filter(([, value]) => ![null, undefined].includes(value))
+            .map(([key, value]) => [key, SCALAR_TYPES.includes(typeof value) ? value : prune(value)]),
+    );
 }
 
-function getCustomORDContent(appConfig) {
-    if (!appConfig.env?.customOrdContentFile) return;
-    const pathToCustomORDContent = path.join(cds.root, appConfig.env?.customOrdContentFile);
-    if (!fs.existsSync(pathToCustomORDContent)) {
-        Logger.error("Custom ORD content file not found at", pathToCustomORDContent);
-        return;
-    }
-    return require(pathToCustomORDContent);
+function merge(target, source, keys) {
+    const iteratee = (entity) => keys.map((key) => entity[key] || "").join(".");
+    const sources = _.keyBy(source || [], iteratee);
+    const targets = _.keyBy(target || [], iteratee);
+
+    return Array.from(new Set([...Object.keys(targets), ...Object.keys(sources)])) //
+        .map((key) => _.assign(structuredClone(targets[key]), structuredClone(sources[key])))
+        .map(prune);
 }
 
 module.exports = {
-    getCustomORDContent,
-    compareAndHandleCustomORDContentWithExistingContent,
+    MERGE_STRATEGIES,
+    getCustomORDContent: (configuration) => {
+        if (!configuration.env?.customOrdContentFile) return {};
+
+        const file = path.join(cds.root, configuration.env?.customOrdContentFile);
+        if (!fs.existsSync(file)) {
+            Logger.error("Custom ORD content file not found at", file);
+            return {};
+        }
+
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    },
+    compareAndHandleCustomORDContentWithExistingContent: (ordContent, customORDContent) => {
+        return Object.fromEntries([
+            // Process elements found only in 'ordContent'
+            ...Object.entries(ordContent)
+                .filter(([key]) => !(key in customORDContent))
+                .map(([key, value]) => [key, structuredClone(value)]),
+
+            // Process elements found only in 'customORDContent'
+            ...Object.entries(customORDContent)
+                .filter(([key]) => !(key in ordContent))
+                .map(([key, value]) => [key, structuredClone(value)]),
+
+            // Process elements found in both 'ordContent' and 'customORDContent'
+            ...Object.entries(customORDContent)
+                .filter(([key]) => key in ordContent)
+                .filter(([, value]) => ![null, undefined].includes(value))
+                .map(([key, value]) => [key, MERGE_STRATEGIES[key](structuredClone(ordContent[key]), value)]),
+        ]);
+    },
 };