@cap-js/ord 1.6.0 → 1.7.0

package/lib/build.js

@@ -1,13 +1,14 @@
+const os = require("os");
 const path = require("path");
 const cds = require("@sap/cds");
 const _ = require("lodash");
 const Piscina = require("piscina");
 const cliProgress = require("cli-progress");
 
-const os = require("os");
+const defaults = require("./defaults.js");
 const { ord } = require("./index");
 const registerCompileTargets = require("./common/register-compile-targets");
-const { BUILD_DEFAULT_PATH, ORD_DOCUMENT_FILE_NAME } = require("./constants");
+const { BUILD_DEFAULT_PATH, ORD_DOCUMENT_FILE_NAME, DOCUMENT_PERSPECTIVES } = require("./constants");
 
 module.exports = class OrdBuildPlugin extends cds.build.Plugin {
     static taskDefaults = { src: cds.env.folders.srv };
@@ -53,7 +54,7 @@ module.exports = class OrdBuildPlugin extends cds.build.Plugin {
                 resourceDefinition.url = this._createRelativePath(resourceDefinition.url);
             });
 
-        return clone;
+        return defaults.adjustForPerspective(clone, DOCUMENT_PERSPECTIVES.SystemVersion);
     }
 
     _createRelativePath(url) {

package/lib/common/register-compile-targets.js

@@ -12,7 +12,7 @@ module.exports = () => {
     // registrations. Re-apply so that compilation works accordingly during build and runtime.
 
     Object.keys(cds.env.plugins || {})
-        .filter((plugin) => plugin !== "@cap-js/ord")
+        .filter((plugin) => !!PROTOCOL_PROVIDERS[plugin])
         .forEach((plugin) => {
             try {
                 const protocol = PROTOCOL_PROVIDERS[plugin];

package/lib/configuration.js

@@ -0,0 +1,161 @@
+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");
+
+module.exports = class Configuration {
+    constructor(csn) {
+        const env = cds.env["ord"];
+        const 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;
+
+        if (eventApplicationNamespace && ordNamespace !== eventApplicationNamespace) {
+            Logger.warn("ORD and AsyncAPI namespaces should be the same.");
+        }
+
+        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._appName = packageName.replace(/^@/, "").replace(/[@/]/g, "-");
+        this._policyLevels = env?.policyLevels || (env?.policyLevel && [env?.policyLevel]) || defaults.policyLevels;
+    }
+
+    get env() {
+        return this._env;
+    }
+
+    get appName() {
+        return this._appName;
+    }
+
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+
+    get packageName() {
+        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 entityTypeTargets() {
+        return this._entityTypeTargets;
+    }
+
+    get eventServiceNames() {
+        return this._eventServiceNames;
+    }
+
+    get hasSAPPolicyLevel() {
+        return this.policyLevels.some((policyLevel) => policyLevel.split(":")[0].toLowerCase() === "sap");
+    }
+
+    get existingProductORDId() {
+        return this._existingProductORDId;
+    }
+
+    _resolveServiceNames(csn) {
+        return Object.keys(csn.definitions) //
+            .filter((name) => this._isValidService(name, csn.definitions[name]));
+    }
+
+    _loadNameFromPackageJson() {
+        const packageJsonPath = path.join(cds.root, "package.json");
+
+        if (!cds.utils.exists(packageJsonPath)) {
+            throw new Error("package.json not found in the project root directory");
+        }
+
+        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]));
+    }
+
+    _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)
+        );
+    }
+
+    _serviceOnlyContainsEvents(definition) {
+        return (
+            Object.keys(definition.events || {}).length > 0 &&
+            ["actions", "entities", "functions"].every((key) => Object.keys(definition[key] || {}).length === 0)
+        );
+    }
+};

package/lib/constants.js

@@ -8,11 +8,6 @@ const BASIC_AUTH_HEADER_KEY = "authorization";
 
 const BUILD_DEFAULT_PATH = "gen/ord";
 
-const BLOCKED_SERVICE_NAME = Object.freeze({
-    MTXServices: "cds.xt.MTXServices",
-    OpenResourceDiscoveryService: "OpenResourceDiscoveryService",
-});
-
 const ORD_ACCESS_STRATEGY = Object.freeze({
     Open: "open",
     Basic: "basic-auth",
@@ -76,8 +71,6 @@ const LEVEL = Object.freeze({
     subEntity: "sub-entity",
 });
 
-const OPEN_RESOURCE_DISCOVERY_VERSION = "1.12";
-
 const OPENAPI_SERVERS_ANNOTATION = "@OpenAPI.servers";
 
 const ORD_EXTENSIONS_PREFIX = "@ORD.Extensions.";
@@ -89,8 +82,9 @@ const ORD_EXISTING_PRODUCT_PROPERTY = "existingProductORDId";
 const ORD_RESOURCE_TYPE = Object.freeze({
     api: "api",
     event: "event",
-    integrationDependency: "integrationDependency",
     entityType: "entityType",
+    dataProduct: "dataProduct",
+    integrationDependency: "integrationDependency",
 });
 
 const ORD_SERVICE_NAME = "OpenResourceDiscoveryService";
@@ -181,12 +175,18 @@ const AUTH_STRINGS = Object.freeze({
     WWW_AUTHENTICATE_REALM: 'Basic realm="401"',
 });
 
+const DOCUMENT_PERSPECTIVES = Object.freeze({
+    SystemVersion: "system-version",
+    SystemInstance: "system-instance",
+});
+
+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,
-    BLOCKED_SERVICE_NAME,
     CAP_TO_ORD_PROTOCOL_MAP,
     CDS_ELEMENT_KIND,
     CF_MTLS_HEADERS,
@@ -202,7 +202,6 @@ module.exports = {
     INTEGRATION_DEPENDENCY_RESOURCE_NAME,
     LEVEL,
     MCP_RESOURCE_DEFINITION_TYPE,
-    OPEN_RESOURCE_DISCOVERY_VERSION,
     OPENAPI_SERVERS_ANNOTATION,
     ORD_ACCESS_STRATEGY,
     ORD_API_PROTOCOL,
@@ -223,4 +222,6 @@ module.exports = {
     CF_MTLS_ERROR_REASON,
     HTTP_CONFIG,
     AUTH_STRINGS,
+    DOCUMENT_PERSPECTIVES,
+    LOCAL_TENANT_ID_HEADER_KEY,
 };

package/lib/defaults.js

@@ -1,15 +1,15 @@
-const { OPEN_RESOURCE_DISCOVERY_VERSION, SHORT_DESCRIPTION_PREFIX, RESOURCE_VISIBILITY } = require("./constants");
-const { hasSAPPolicyLevel } = require("./utils");
+const fs = require("fs");
 const _ = require("lodash");
+const cds = require("@sap/cds");
+const { join } = require("path");
 
-const packageTypes = [
-    { tag: "-api", type: "APIs" },
-    { tag: "-event", type: "Events" },
-    { tag: "-consumptionBundle", type: "Consumption Bundles" },
-    { tag: "-integrationDependency", type: "Integration Dependencies" },
-    { tag: "-entityType", type: "Entity Types" },
-    { tag: "-dataProduct", type: "Data Products" },
-];
+const {
+    ORD_RESOURCE_TYPE,
+    SHORT_DESCRIPTION_PREFIX,
+    RESOURCE_VISIBILITY,
+    DOCUMENT_PERSPECTIVES,
+    CONTENT_MERGE_KEY,
+} = require("./constants");
 
 const stringTypeCheck = (value) => typeof value === "string";
 const arrayTypeCheck = (value) => Array.isArray(value);
@@ -77,8 +77,9 @@ const mapEnvPackageInfo = (packageConfig) => {
  */
 module.exports = {
     $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
-    openResourceDiscovery: OPEN_RESOURCE_DISCOVERY_VERSION,
+    openResourceDiscovery: "1.14",
     policyLevels: ["none"],
+    groupTypeId: "sap.cds:service",
     description: "this is an application description",
     products: (name) => [
         {
@@ -88,40 +89,38 @@ module.exports = {
             vendor: "customer:vendor:Customer:",
         },
     ],
-    groupTypeId: "sap.cds:service",
-    packages: function getPackageData(appConfig) {
+    packages: (appConfig, products) => {
         const name = appConfig.appName;
         const ordNamespace = appConfig.ordNamespace;
-        const productsOrdId = appConfig.existingProductORDId || appConfig.products?.[0]?.ordId;
+        const productsOrdId = appConfig.existingProductORDId || products?.[0]?.ordId;
         const { vendor, ...envValues } = mapEnvPackageInfo(appConfig?.env?.packages?.[0]);
-        if (hasSAPPolicyLevel(appConfig.policyLevels)) {
-            return _.uniqBy(
-                packageTypes.flatMap(({ tag, type }) =>
-                    Object.values(RESOURCE_VISIBILITY).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,
-                    })),
-                ),
-                "ordId",
-            );
-        } else {
-            return [
-                {
-                    ordId: generateUniquePackageOrdId(ordNamespace, name, "", RESOURCE_VISIBILITY.public),
+        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, "General", RESOURCE_VISIBILITY.public),
+                    ...generatePackageDescriptions(name, type, visibility),
                     version: "1.0.0",
                     ...(productsOrdId && { partOfProducts: [productsOrdId || defaultProductOrdId(name)] }),
                     vendor: vendor || "customer:vendor:Customer:",
                     ...envValues,
-                },
-            ];
-        }
+                })),
+            ),
+            CONTENT_MERGE_KEY,
+        );
     },
     consumptionBundles: (appConfig) => [
         {
@@ -134,23 +133,55 @@ module.exports = {
                 "This Consumption Bundle contains all resources of the reference app which are unprotected and do not require authentication",
         },
     ],
-
-    apiResources: [],
-    eventResources: [],
-    entityTypes: [],
-    baseTemplate: (authConfig) => {
+    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 || [];
+
         return {
             openResourceDiscoveryV1: {
                 documents: [
                     {
                         url: "/ord/v1/documents/ord-document",
+                        perspective: DOCUMENT_PERSPECTIVES.SystemVersion,
                         accessStrategies,
                     },
+                    ...(!tenant || !(toggles || extensibility)
+                        ? []
+                        : [
+                              {
+                                  url: `/ord/v1/documents/ord-document?perspective=${encodeURIComponent(DOCUMENT_PERSPECTIVES.SystemInstance)}`,
+                                  perspective: DOCUMENT_PERSPECTIVES.SystemInstance,
+                                  accessStrategies,
+                              },
+                          ]),
                 ],
             },
         };
     },
+    adjustForPerspective: (document, perspective) => {
+        document.perspective = perspective;
+
+        if (perspective === DOCUMENT_PERSPECTIVES.SystemVersion) {
+            document.describedSystemVersion = cds.env["ord"]?.describedSystemVersion ?? {
+                version: JSON.parse(fs.readFileSync(join(cds.root, "package.json"), "utf-8")).version,
+            };
+        } else if (perspective === DOCUMENT_PERSPECTIVES.SystemInstance) {
+            (document.apiResources || []).forEach((apiResource) => {
+                (apiResource.resourceDefinitions || []).forEach((apiResourceDefinition) => {
+                    apiResourceDefinition.url += `?perspective=${encodeURIComponent(perspective)}`;
+                });
+            });
+
+            (document.eventResources || []).forEach((eventResource) => {
+                (eventResource.resourceDefinitions || []).forEach((eventResourceDefinition) => {
+                    eventResourceDefinition.url += `?perspective=${encodeURIComponent(perspective)}`;
+                });
+            });
+        }
+
+        return document;
+    },
 };

package/lib/integration-dependency.js

@@ -122,6 +122,4 @@ module.exports = {
     // Exported for testing
     collectExternalServices,
     createIntegrationDependency,
-    parseDataProductOrdId,
-    isExternalDataProduct,
 };

package/lib/interop-csn.js

@@ -54,7 +54,7 @@ function add_i18n_texts(csn) {
             if (n.startsWith("@")) {
                 let annoVal = o[n];
                 if (typeof annoVal === "string" && annoVal.startsWith("{i18n>")) {
-                    let [, x] = annoVal.match(/^\{i18n>(.*)\}$/) || [];
+                    let [, x] = annoVal.match(/^\{i18n>(.*)}$/) || [];
                     if (x) keys.add(x);
                 }
             }

package/lib/ord.js

@@ -1,221 +1,22 @@
+const _ = require("lodash");
+const cds = require("@sap/cds");
+
+const Logger = require("./logger");
+const defaults = require("./defaults");
+const { createAuthConfig } = require("./auth/authentication");
+const Configuration = require("./configuration");
+const { getIntegrationDependencies } = require("./integration-dependency");
 const {
-    BLOCKED_SERVICE_NAME,
-    CDS_ELEMENT_KIND,
-    CONTENT_MERGE_KEY,
-    ENTITY_RELATIONSHIP_ANNOTATION,
-    ORD_ODM_ENTITY_NAME_ANNOTATION,
-} = require("./constants");
+    getCustomORDContent,
+    compareAndHandleCustomORDContentWithExistingContent,
+} = require("./extend-ord-with-custom");
 const {
     createAPIResourceTemplate,
     createEntityTypeTemplate,
-    createEntityTypeMappingsItemTemplate,
     createEventResourceTemplate,
     createGroupsTemplateForService,
     _propagateORDVisibility,
 } = require("./templates");
-const { getIntegrationDependencies } = require("./integration-dependency");
-const {
-    getCustomORDContent,
-    compareAndHandleCustomORDContentWithExistingContent,
-} = require("./extend-ord-with-custom");
-const { getRFC3339Date } = require("./date");
-const { createAuthConfig } = require("./auth/authentication");
-
-const Logger = require("./logger");
-const _ = require("lodash");
-const cds = require("@sap/cds");
-const defaults = require("./defaults");
-const path = require("path");
-
-const initializeAppConfig = (csn) => {
-    const packageJson = _loadPackageJson();
-    const packageName = packageJson.name;
-    const appName = _formatAppName(packageName);
-    const lastUpdate = getRFC3339Date();
-
-    const ordNamespace = _getORDNamespace(packageName);
-    const eventApplicationNamespace = cds.env?.export?.asyncapi?.applicationNamespace;
-
-    _validateNamespaces(ordNamespace, eventApplicationNamespace);
-
-    const { serviceNames, apiResourceNames, apiEndpoints, eventServiceNames, entityTypeTargets } =
-        _triageCsnDefinitions(csn);
-
-    return {
-        env: cds.env["ord"],
-        lastUpdate,
-        appName,
-        apiEndpoints: Array.from(apiEndpoints),
-        eventServiceNames,
-        serviceNames,
-        apiResourceNames,
-        entityTypeTargets: _.uniqBy(entityTypeTargets, CONTENT_MERGE_KEY),
-        ordNamespace,
-        eventApplicationNamespace,
-        packageName,
-    };
-};
-
-function _loadPackageJson() {
-    const packageJsonPath = path.join(cds.root, "package.json");
-    if (!cds.utils.exists(packageJsonPath)) {
-        throw new Error(`package.json not found in the project root directory`);
-    }
-    return require(packageJsonPath);
-}
-
-function _formatAppName(packageName) {
-    return packageName.replace(/^[@]/, "").replace(/[@/]/g, "-");
-}
-
-function _getORDNamespace(packageName) {
-    const vendorNamespace = "customer";
-    return cds.env["ord"]?.namespace || `${vendorNamespace}.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
-}
-
-function _validateNamespaces(ordNamespace, eventApplicationNamespace) {
-    if (eventApplicationNamespace && ordNamespace !== eventApplicationNamespace) {
-        Logger.warn("ORD and AsyncAPI namespaces should be the same.");
-    }
-}
-
-function _triageCsnDefinitions(csn) {
-    const pendingApiResourceNames = [];
-    const apiEndpoints = new Set();
-    const pendingEventServiceNames = new Set();
-    const entityTypeTargets = [];
-    const serviceNames = Object.keys(csn.definitions).filter((key) => _isValidService(key, csn.definitions[key]));
-
-    for (const definitionKey of Object.keys(csn.definitions)) {
-        const definitionObj = csn.definitions[definitionKey];
-        if (
-            definitionKey.includes(BLOCKED_SERVICE_NAME.MTXServices) ||
-            definitionKey.includes(BLOCKED_SERVICE_NAME.OpenResourceDiscoveryService)
-        ) {
-            Logger.warn("ORD service name", definitionKey, "is blocked.");
-            continue;
-        }
-        switch (definitionObj.kind) {
-            case CDS_ELEMENT_KIND.service: {
-                const apiResourceName = _handleApiResource(definitionKey, definitionObj);
-                if (apiResourceName) pendingApiResourceNames.push(apiResourceName);
-                break;
-            }
-            case CDS_ELEMENT_KIND.entity: {
-                const result = _handleEntity(definitionKey, definitionObj);
-                if (result) {
-                    if (result.apiEndpoint) apiEndpoints.add(result.apiEndpoint);
-                    if (result.entityTypeTarget) entityTypeTargets.push(...result.entityTypeTarget);
-                }
-                break;
-            }
-            case CDS_ELEMENT_KIND.event: {
-                const event = _handleEvent(serviceNames, definitionKey, definitionObj);
-                if (event) pendingEventServiceNames.add(event);
-                break;
-            }
-            case CDS_ELEMENT_KIND.action:
-            case CDS_ELEMENT_KIND.function: {
-                const apiEndpoint = _handleActionOrFunction(definitionKey, definitionObj);
-                if (apiEndpoint) apiEndpoints.add(apiEndpoint);
-                break;
-            }
-        }
-    }
-
-    return {
-        serviceNames,
-        apiResourceNames: pendingApiResourceNames,
-        apiEndpoints: Array.from(apiEndpoints),
-        eventServiceNames: [...pendingEventServiceNames],
-        entityTypeTargets,
-    };
-}
-
-function _handleApiResource(apiResourceName, serviceDefinition) {
-    if (
-        _shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) ||
-        !_isValidService(apiResourceName, serviceDefinition)
-    ) {
-        return null;
-    }
-    return apiResourceName;
-}
-
-function _shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) {
-    const isActionsNotContained = !serviceDefinition.actions || Object.keys(serviceDefinition.actions).length === 0;
-    const isFunctionsNotContained =
-        !serviceDefinition.functions || Object.keys(serviceDefinition.functions).length === 0;
-    const isEntitiesNotContained = !serviceDefinition.entities || Object.keys(serviceDefinition.entities).length === 0;
-    const isEventsContained = serviceDefinition.events && Object.keys(serviceDefinition.events).length > 0;
-    if (isActionsNotContained && isFunctionsNotContained && isEntitiesNotContained && isEventsContained) {
-        return true;
-    }
-    return false;
-}
-
-function _shouldNotSkipIfServiceProtocolIsNone(keyDefinition) {
-    if (keyDefinition["_service"] && keyDefinition["_service"]["@protocol"] === "none") {
-        return false;
-    }
-    return true;
-}
-
-function _isBlockedServiceName(key) {
-    const blockedServices = [BLOCKED_SERVICE_NAME.MTXServices, BLOCKED_SERVICE_NAME.OpenResourceDiscoveryService];
-    return blockedServices.some((blocked) => key.includes(blocked));
-}
-
-function _isValidService(key, definition) {
-    const isExternalService = Object.keys(cds).includes("requires") ? Object.keys(cds.requires).includes(key) : false;
-
-    return (
-        definition.kind === CDS_ELEMENT_KIND.service &&
-        !definition["@cds.external"] &&
-        definition["@protocol"] !== "none" &&
-        !isExternalService &&
-        !_isBlockedServiceName(key)
-    );
-}
-
-function _handleEntity(key, keyDefinition) {
-    if (!key.includes(".texts") && _shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
-        const apiEndpoint = key;
-        let entityTypeTarget = null;
-        if (keyDefinition[ORD_ODM_ENTITY_NAME_ANNOTATION] || keyDefinition[ENTITY_RELATIONSHIP_ANNOTATION]) {
-            const mapping = createEntityTypeMappingsItemTemplate(keyDefinition);
-            if (Array.isArray(mapping)) entityTypeTarget = mapping;
-            else if (mapping) entityTypeTarget = [mapping];
-        }
-        return { apiEndpoint, entityTypeTarget };
-    }
-    return null;
-}
-
-function _handleEvent(serviceNames, key, keyDefinition) {
-    if (_shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
-        for (const serviceName of serviceNames) {
-            if (key.startsWith(serviceName + ".")) {
-                return serviceName;
-            }
-        }
-    }
-    return null;
-}
-
-function _handleActionOrFunction(key, keyDefinition) {
-    if (_shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
-        return key;
-    }
-    return null;
-}
-
-const _getPolicyLevels = (appConfig) =>
-    appConfig.env?.policyLevels ||
-    (appConfig.env?.policyLevel && [appConfig.env?.policyLevel]) ||
-    defaults.policyLevels;
-
-const _getDescription = (appConfig) => appConfig.env?.description || defaults.description;
 
 const _getGroups = (csn, appConfig) => {
     return appConfig.serviceNames
@@ -223,18 +24,8 @@ const _getGroups = (csn, appConfig) => {
         .filter((resource) => !!resource);
 };
 
-const _getPackages = (appConfig) => {
-    return defaults.packages(appConfig);
-};
-
-const _getEntityTypes = (appConfig, packageIds) => {
-    if (!appConfig.entityTypeTargets?.length) return [];
-
-    return appConfig.entityTypeTargets.flatMap((entity) => createEntityTypeTemplate(appConfig, packageIds, entity));
-};
-
 const _getAPIResources = (csn, appConfig, packageIds, accessStrategies) => {
-    const apiResources = appConfig.apiResourceNames.flatMap((apiResourceName) =>
+    return appConfig.apiResourceNames.flatMap((apiResourceName) =>
         createAPIResourceTemplate(
             apiResourceName,
             csn.definitions[apiResourceName],
@@ -243,8 +34,6 @@ const _getAPIResources = (csn, appConfig, packageIds, accessStrategies) => {
             accessStrategies,
         ),
     );
-
-    return apiResources;
 };
 
 const _getEventResources = (csn, appConfig, packageIds, accessStrategies) => {
@@ -253,16 +42,9 @@ const _getEventResources = (csn, appConfig, packageIds, accessStrategies) => {
     );
 };
 
-function _getOpenResourceDiscovery(appConfig) {
-    return appConfig.env?.openResourceDiscovery || defaults.openResourceDiscovery;
-}
-
-function _getConsumptionBundles(appConfig) {
-    return appConfig.env?.consumptionBundles || defaults.consumptionBundles(appConfig);
-}
-
 const _getProducts = (appConfig) => {
     const productsObj = defaults.products(appConfig.packageName);
+
     if (appConfig.env?.products) {
         const customProducts = appConfig.env.products[0];
         if (customProducts?.ordId?.toLowerCase().startsWith("sap")) {
@@ -273,40 +55,39 @@ const _getProducts = (appConfig) => {
             _.assign(productsObj[0], customProducts);
         }
     }
-    appConfig.products = productsObj;
+
     return productsObj;
 };
 
-function createDefaultORDDocument(linkedCsn, appConfig) {
-    appConfig.policyLevels = _getPolicyLevels(appConfig);
-    let ordDocument = {
+const _createDefaultORDDocument = (linkedCsn, appConfig, authConfig) => {
+    const products = _getProducts(appConfig);
+    const packages = defaults.packages(appConfig, products);
+    const packageIds = packages?.map((pkg) => pkg.ordId) || [];
+    const entityTypes = _getEntityTypes(appConfig, packageIds);
+    const integrationDependencies = getIntegrationDependencies(linkedCsn, appConfig, packageIds);
+    const apiResources = _getAPIResources(linkedCsn, appConfig, packageIds, authConfig.accessStrategies);
+    const eventResources = _getEventResources(linkedCsn, appConfig, packageIds, authConfig.accessStrategies);
+
+    return {
+        // Unconditionally added top-level properties
         $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
-        openResourceDiscovery: _getOpenResourceDiscovery(appConfig),
         policyLevels: appConfig.policyLevels,
-        description: _getDescription(appConfig),
-        consumptionBundles: _getConsumptionBundles(appConfig),
+        packages: packages,
+        description: appConfig.env?.description || defaults.description,
+        openResourceDiscovery: appConfig.env?.openResourceDiscovery || defaults.openResourceDiscovery,
+        consumptionBundles: appConfig.env?.consumptionBundles || defaults.consumptionBundles(appConfig),
+
+        // Conditionally added top-level properties
+        ...(!entityTypes.length ? {} : { entityTypes: entityTypes }),
+        ...(!apiResources.length ? {} : { apiResources: apiResources }),
+        ...(!eventResources.length ? {} : { eventResources: eventResources }),
+        ...(appConfig.existingProductORDId ? {} : { products: [products[0]] }),
+        ...(!appConfig.serviceNames.length ? {} : { groups: _getGroups(linkedCsn, appConfig) }),
+        ...(!integrationDependencies.length ? {} : { integrationDependencies: integrationDependencies }),
     };
+};
 
-    if (appConfig.serviceNames.length) {
-        ordDocument.groups = _getGroups(linkedCsn, appConfig);
-    }
-
-    if (appConfig.env?.existingProductORDId) {
-        appConfig.existingProductORDId = appConfig.env.existingProductORDId;
-    } else {
-        ordDocument.products = [_getProducts(appConfig)[0]];
-    }
-
-    ordDocument.packages = _getPackages(appConfig);
-
-    return ordDocument;
-}
-
-function extractPackageIds(ordDocument) {
-    return ordDocument.packages?.map((pkg) => pkg.ordId) || [];
-}
-
-function _filterUnusedPackages(ordDocument) {
+const _filterUnusedPackages = (ordDocument) => {
     if (!ordDocument.packages?.length) return [];
 
     const usedPackageIds = new Set();
@@ -322,52 +103,33 @@ function _filterUnusedPackages(ordDocument) {
     });
 
     return ordDocument.packages.filter((pkg) => usedPackageIds.has(pkg.ordId));
-}
+};
 
-module.exports = (csn, extensions = []) => {
-    const linkedCsn = _propagateORDVisibility(cds.linked(csn));
-    const appConfig = initializeAppConfig(linkedCsn);
+const _getEntityTypes = (appConfig, packageIds) => {
+    return appConfig.entityTypeTargets.flatMap((entity) => createEntityTypeTemplate(appConfig, packageIds, entity));
+};
 
-    // Create auth config and fail-closed on configuration errors
+const _createAuthConfig = () => {
     const authConfig = createAuthConfig();
+
+    // Create auth config and fail-closed on configuration errors
     if (authConfig.error) {
         throw new Error(`Authentication configuration error: ${authConfig.error}`);
     }
-    const accessStrategies = authConfig.accessStrategies;
-
-    let ordDocument = createDefaultORDDocument(linkedCsn, appConfig);
-    const packageIds = extractPackageIds(ordDocument);
-    const entityTypes = _getEntityTypes(appConfig, packageIds);
 
-    if (entityTypes.length) {
-        ordDocument.entityTypes = entityTypes;
-    }
-
-    if (appConfig.apiResourceNames.length) {
-        const apiResources = _getAPIResources(linkedCsn, appConfig, packageIds, accessStrategies);
-        if (apiResources.length) {
-            ordDocument.apiResources = apiResources;
-        }
-    }
-    if (appConfig.eventServiceNames.length) {
-        const eventResources = _getEventResources(linkedCsn, appConfig, packageIds, accessStrategies);
-        if (eventResources.length) {
-            ordDocument.eventResources = eventResources;
-        }
-    }
-
-    const integrationDependencies = getIntegrationDependencies(linkedCsn, appConfig, packageIds);
-    if (integrationDependencies.length) {
-        ordDocument.integrationDependencies = integrationDependencies;
-    }
+    return authConfig;
+};
 
-    [...(extensions || []), getCustomORDContent(appConfig)]
+module.exports = (csn, extensions = []) => {
+    const authConfig = _createAuthConfig();
+    const linkedCsn = _propagateORDVisibility(cds.linked(csn));
+    const appConfig = new Configuration(linkedCsn);
+    const ordDocument = [...(extensions || []), getCustomORDContent(appConfig)]
         .filter((extension) => !!extension)
-        .forEach((extension) => {
-            ordDocument = compareAndHandleCustomORDContentWithExistingContent(ordDocument, extension);
-        });
-
-    ordDocument.packages = _filterUnusedPackages(ordDocument);
+        .reduce(
+            (document, extension) => compareAndHandleCustomORDContentWithExistingContent(document, extension),
+            _createDefaultORDDocument(linkedCsn, appConfig, authConfig),
+        );
 
-    return ordDocument;
+    return Object.assign(ordDocument, { packages: _filterUnusedPackages(ordDocument) });
 };

package/lib/services/mtx-ord-provider-service.js

@@ -1,19 +1,24 @@
 const cds = require("@sap/cds/lib");
 const { ord, getMetadata } = require("@cap-js/ord/lib");
 
+const defaults = require("../defaults");
+const { DOCUMENT_PERSPECTIVES } = require("../constants");
+
 module.exports = class MtxOrdProviderService extends cds.ApplicationService {
     init() {
         this.on("getOrdDocument", async (req) => {
             req._?.res?.set("Content-Type", "application/json");
 
-            return ord(
-                await (
-                    await cds.connect.to("cds.xt.ModelProviderService")
-                ).getCsn({
-                    for: req.data.for,
-                    tenant: req.data.tenant,
-                    toggles: req.data.toggles,
-                }),
+            return defaults.adjustForPerspective(
+                ord(
+                    await (
+                        await cds.connect.to("cds.xt.ModelProviderService")
+                    ).getCsn({
+                        tenant: req.data.tenant,
+                        toggles: req.data.toggles,
+                    }),
+                ),
+                DOCUMENT_PERSPECTIVES.SystemInstance,
             );
         });
 
@@ -23,7 +28,6 @@ module.exports = class MtxOrdProviderService extends cds.ApplicationService {
                 await (
                     await cds.connect.to("cds.xt.ModelProviderService")
                 ).getCsn({
-                    for: req.data.for,
                     tenant: req.data.tenant,
                     toggles: req.data.toggles,
                 }),

package/lib/services/ord-service.js

@@ -3,9 +3,61 @@ const cds = require("@sap/cds");
 const ord = require("../ord.js");
 const Logger = require("../logger.js");
 const defaults = require("../defaults.js");
+const { LOCAL_TENANT_ID_HEADER_KEY, DOCUMENT_PERSPECTIVES } = require("../constants");
 const compileMetadata = require("../meta-data.js");
 const { createAuthConfig, createAuthMiddleware } = require("../auth/authentication.js");
 
+const validationMiddleware = (req, res, next) => {
+    const toggles = cds.env.requires.toggles;
+    const perspective = req.query.perspective;
+    const extensibility = cds.env.requires.extensibility;
+    const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+
+    if (perspective && ![DOCUMENT_PERSPECTIVES.SystemVersion, DOCUMENT_PERSPECTIVES.SystemInstance].includes(perspective)) {
+        return res.status(400).send(`Required query parameter 'perspective' is invalid`);
+    }
+
+    if (perspective === DOCUMENT_PERSPECTIVES.SystemInstance && !(toggles || extensibility)) {
+        return res.status(400).send(`Unsupported query parameter 'perspective=${perspective}'`);
+    }
+
+    if (!tenant && perspective === DOCUMENT_PERSPECTIVES.SystemInstance) {
+        return res.status(400).send(`Missing required tenant context`);
+    }
+
+    return next();
+};
+
+const metadataResponseHandler = async (req, res) => {
+    try {
+        const perspective = req.query.perspective;
+        const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+        const model = await resolveCdsModel(perspective, tenant);
+        const { contentType, response } = await compileMetadata(req.path, model);
+
+        return res.status(200).contentType(contentType).send(response);
+    } catch (error) {
+        Logger.error(error, "Error while processing the resource definition document");
+        return res.status(500).send(error.message);
+    }
+};
+
+const resolveCdsModel = async (perspective, tenant) => {
+    if (!tenant || perspective !== DOCUMENT_PERSPECTIVES.SystemInstance) {
+        Logger.info("Retrieving static CDS model...");
+        return cds.model;
+    }
+
+    Logger.info(`Retrieving dynamic CDS model for tenant ${tenant}...`);
+
+    return await (
+        await cds.connect.to("cds.xt.ModelProviderService")
+    ).getCsn({
+        tenant: tenant,
+        toggles: OpenResourceDiscoveryService.resolveFeatureToggles(tenant),
+    });
+};
+
 class OpenResourceDiscoveryService extends cds.ApplicationService {
     async init() {
         this.extensions = {};
@@ -26,38 +78,38 @@ class OpenResourceDiscoveryService extends cds.ApplicationService {
         // Create authentication middleware
         const authMiddleware = createAuthMiddleware(authConfig);
 
-        cds.app.get(`${this.path}`, (_, res) => {
-            return res.status(200).send(defaults.baseTemplate(authConfig));
+        // Default: /.well-known/open-resource-discovery
+        cds.app.get(`${this.path}`, (req, res) => {
+            const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+
+            return res.status(200).send(defaults.baseTemplate(authConfig, tenant));
         });
 
-        cds.app.get(`/ord/v1/documents/ord-document`, authMiddleware, async (_, res) => {
-            const csn = cds.context?.model || cds.model;
-            const data = ord(csn, Array.from(Object.values(this.extensions)));
-            return res.status(200).send(data);
+        cds.app.get(`/ord/v1/documents/ord-document`, [authMiddleware, validationMiddleware], async (req, res) => {
+            const perspective = req.query.perspective || DOCUMENT_PERSPECTIVES.SystemVersion;
+            const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+            const model = await resolveCdsModel(perspective, tenant);
+            const extensions = Array.from(Object.values(this.extensions));
+
+            return res.status(200).send(defaults.adjustForPerspective(ord(model, extensions), perspective));
         });
 
-        cds.app.get(`/ord/v1/documents/:id`, authMiddleware, async (_, res) => {
+        cds.app.get(`/ord/v1/documents/:id`, [authMiddleware, validationMiddleware], async (_, res) => {
             return res.status(404).send("404 Not Found");
         });
 
-        // Handler for metadata requests (oas3, edmx, csn, etc.)
-        const metadataHandler = async (req, res) => {
-            try {
-                const { contentType, response } = await compileMetadata(req.url);
-                return res.status(200).contentType(contentType).send(response);
-            } catch (error) {
-                Logger.error(error, "Error while processing the resource definition document");
-                return res.status(500).send(error.message);
-            }
-        };
-
         // Use separate routes instead of optional parameters for path-to-regexp v8 compatibility
-        cds.app.get(`/ord/v1/:ordId/:service`, authMiddleware, metadataHandler);
-        cds.app.get(`/ord/v1/:ordId`, authMiddleware, metadataHandler);
-        cds.app.get(`/ord/v1`, authMiddleware, metadataHandler);
+        cds.app.get(`/ord/v1/:ordId/:service`, [authMiddleware, validationMiddleware], metadataResponseHandler);
+        cds.app.get(`/ord/v1/:ordId`, [authMiddleware, validationMiddleware], metadataResponseHandler);
+        cds.app.get(`/ord/v1`, [authMiddleware, validationMiddleware], metadataResponseHandler);
 
         return super.init();
     }
+
+    // eslint-disable-next-line no-unused-vars
+    static resolveFeatureToggles(tenant) {
+        return ["*"];
+    }
 }
 
 module.exports = { OpenResourceDiscoveryService };

package/lib/templates.js

@@ -1,4 +1,3 @@
-const { hasSAPPolicyLevel } = require("./utils");
 const defaults = require("./defaults");
 const _ = require("lodash");
 const {
@@ -76,14 +75,22 @@ const createEntityTypeMappingsItemTemplate = (entity) => {
 };
 
 function _getGroupID(serviceDefinition, groupTypeId = defaults.groupTypeId, appConfig) {
-    return `${groupTypeId}:${appConfig.ordNamespace}:${_getGroupNameWithNestedNamespace(serviceDefinition, appConfig)}`;
+    return `${groupTypeId}:${appConfig.ordNamespace}:${_getCleanServiceName(serviceDefinition, appConfig)}`;
 }
 
-function _getGroupNameWithNestedNamespace({ name }, appConfig) {
-    if (!name.startsWith(appConfig.ordNamespace)) {
-        return name;
+function _startsWithNamespace(name, namespace) {
+    if (!name.startsWith(namespace)) return false;
+    const rest = name.substring(namespace.length);
+    return rest === "" || rest.startsWith(".");
+}
+
+function _getCleanServiceName({ name }, appConfig) {
+    let sortedName = name;
+    if (appConfig.internalNamespace && _startsWithNamespace(name, appConfig.internalNamespace)) {
+        sortedName = name.substring(appConfig.internalNamespace.length);
+    } else if (_startsWithNamespace(name, appConfig.ordNamespace)) {
+        sortedName = name.substring(appConfig.ordNamespace.length);
     }
-    let sortedName = name.substring(appConfig.ordNamespace.length);
     if (sortedName.startsWith(".")) {
         sortedName = sortedName.substring(1);
     }
@@ -157,7 +164,7 @@ function _getResourceDefinition(resourceType, mediaType, ordId, serviceName, fil
  *
  * @param {string} serviceName The name of the service.
  * @param {object} serviceDefinition The definition of the service
- * @param {Set} groupIds A set of group ids.
+ * @param {object} appConfig - The application configuration.
  * @returns {Object} A group object.
  */
 const createGroupsTemplateForService = (serviceName, serviceDefinition, appConfig) => {
@@ -197,7 +204,7 @@ const createEntityTypeTemplate = (appConfig, packageIds, entity) => {
         // ODM mappings are not created as entity types, they are only used in entityTypeMappings
         return [];
     }
-    if (hasSAPPolicyLevel(appConfig.policyLevels)) {
+    if (appConfig.hasSAPPolicyLevel) {
         // If SAP policy level is present, don't create entity type, they must be in the central repository
         return [];
     }
@@ -305,19 +312,19 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
         extracted = _extractVersionFromServiceName(serviceDefinition.name);
         if (extracted) {
             // Create a temporary service definition with the clean name for namespace processing
-            const cleanServiceDefinition = { ...serviceDefinition, name: extracted.cleanName };
-            cleanServiceName = _getGroupNameWithNestedNamespace(cleanServiceDefinition, appConfig);
+            const versionExtractedServiceDefinition = { ...serviceDefinition, name: extracted.cleanName };
+            cleanServiceName = _getCleanServiceName(versionExtractedServiceDefinition, appConfig);
             version = extracted.version;
             semanticVersion = extracted.semanticVersion;
         } else {
             // Invalid pattern - use current behavior
-            cleanServiceName = _getGroupNameWithNestedNamespace(serviceDefinition, appConfig);
+            cleanServiceName = _getCleanServiceName(serviceDefinition, appConfig);
             version = "v1";
             semanticVersion = "1.0.0";
         }
     } else {
         // Non-data product - use current behavior
-        cleanServiceName = _getGroupNameWithNestedNamespace(serviceDefinition, appConfig);
+        cleanServiceName = _getCleanServiceName(serviceDefinition, appConfig);
         version = "v1";
         semanticVersion = "1.0.0";
     }
@@ -349,7 +356,14 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
                 ];
             } else if (apiProtocol === ORD_API_PROTOCOL.MCP) {
                 resourceDefinitions = [
-                    _getResourceDefinition(MCP_RESOURCE_DEFINITION_TYPE, "json", ordId, serviceName, "mcp.json", accessStrategies),
+                    _getResourceDefinition(
+                        MCP_RESOURCE_DEFINITION_TYPE,
+                        "json",
+                        ordId,
+                        serviceName,
+                        "mcp.json",
+                        accessStrategies,
+                    ),
                 ];
             } else if (apiProtocol === ORD_API_PROTOCOL.GRAPHQL) {
                 // GraphQL only has GraphQL SDL
@@ -363,8 +377,13 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
                         }),
                     },
                 ];
+            } else if (apiProtocol === ORD_API_PROTOCOL.ODATA_V2) {
+                // openapi-v3 is not supported for OData V2, only EDMX
+                resourceDefinitions = [
+                    _getResourceDefinition("edmx", "xml", ordId, serviceName, "edmx", accessStrategies),
+                ];
             } else {
-                // OData and others have both OpenAPI and EDMX
+                // odata-v4 and others have both OpenAPI and EDMX
                 resourceDefinitions = [
                     _getResourceDefinition("openapi-v3", "json", ordId, serviceName, "oas3.json", accessStrategies),
                     _getResourceDefinition("edmx", "xml", ordId, serviceName, "edmx", accessStrategies),
@@ -372,7 +391,6 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
             }
         }
 
-        const entityTypeMappings = _getEntityTypeMappings(serviceDefinition);
         const exposedEntityTypes = _getExposedEntityTypes(serviceDefinition);
 
         let obj = {
@@ -392,7 +410,6 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
             extensible: {
                 supported: "no",
             },
-            ...(entityTypeMappings ? { entityTypeMappings } : {}),
             ...(exposedEntityTypes ? { exposedEntityTypes } : []),
             ...ordExtensions,
         };
@@ -431,8 +448,7 @@ const createEventResourceTemplate = (serviceName, serviceDefinition, appConfig,
     const ordExtensions = readORDExtensions(serviceDefinition);
     const visibility = _handleVisibility(ordExtensions, serviceDefinition, appConfig.env?.defaultVisibility);
     const packageId = _getPackageID(appConfig.ordNamespace, packageIds, ORD_RESOURCE_TYPE.event, visibility);
-    const ordId = `${appConfig.ordNamespace}:eventResource:${_getGroupNameWithNestedNamespace(serviceDefinition, appConfig)}:v1`;
-    const entityTypeMappings = _getEntityTypeMappings(serviceDefinition);
+    const ordId = `${appConfig.ordNamespace}:eventResource:${_getCleanServiceName(serviceDefinition, appConfig)}:v1`;
     const exposedEntityTypes = _getExposedEntityTypes(serviceDefinition);
 
     let obj = {
@@ -456,7 +472,6 @@ const createEventResourceTemplate = (serviceName, serviceDefinition, appConfig,
             _getResourceDefinition("asyncapi-v2", "json", ordId, serviceName, "asyncapi2.json", accessStrategies),
         ],
         extensible: { supported: "no" },
-        ...(entityTypeMappings ? { entityTypeMappings } : {}),
         ...(exposedEntityTypes ? { exposedEntityTypes } : []),
         ...ordExtensions,
     };
@@ -473,28 +488,6 @@ function isPrimaryDataProductService(serviceDefinition) {
     );
 }
 
-function _getEntityTypeMappings(definitionObj) {
-    if (!definitionObj.entities) {
-        return;
-    }
-    const entities = Object.values(definitionObj.entities).flatMap((entity) => {
-        const entityData = _flattenEntityGraph(entity)
-            .flatMap(createEntityTypeMappingsItemTemplate) // now returns arrays
-            .filter(Boolean);
-        return _.uniqBy(entityData, CONTENT_MERGE_KEY);
-    });
-    const entityTypeTargets = _.uniqBy(entities, CONTENT_MERGE_KEY)
-        .filter((entity) => entity !== undefined)
-        .map(({ ordId }) => ({
-            ordId,
-        }));
-    if (entityTypeTargets.length > 0) {
-        return [{ entityTypeTargets }];
-    } else {
-        return;
-    }
-}
-
 function _getExposedEntityTypes(definitionObj) {
     if (!definitionObj.entities) {
         return;
@@ -508,10 +501,9 @@ function _getExposedEntityTypes(definitionObj) {
         .map(({ ordId }) => ({
             ordId,
         }));
+
     if (exposedEntityTypes.length > 0) {
         return exposedEntityTypes;
-    } else {
-        return;
     }
 }
 
@@ -614,7 +606,6 @@ module.exports = {
     createEventResourceTemplate,
     readORDExtensions,
     _getPackageID,
-    _getEntityTypeMappings,
     _getExposedEntityTypes,
     _propagateORDVisibility,
     _handleVisibility,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "description": "CAP Plugin for generating ORD document.",
     "repository": "cap-js/ord",
     "author": "SAP SE (https://www.sap.com)",
@@ -25,7 +25,8 @@
         "test:integration:mtls": "jest __tests__/integration/mtls-auth.test.js --testPathIgnorePatterns=/node_modules/ --forceExit",
         "test:integration:build": "jest __tests__/integration/cds-build.test.js --testPathIgnorePatterns=/node_modules/ --forceExit",
         "update-snapshot": "jest --ci --updateSnapshot",
-        "cds:version": "cds v -i"
+        "cds:version": "cds v -i",
+        "test:all": "npm run test && npm run test:integration:basic && npm run test:integration:mtls && npm run test:integration:build"
     },
     "devDependencies": {
         "@cap-js/graphql": "^0.14.0",
@@ -52,7 +53,7 @@
         "node": ">=20 <25"
     },
     "overrides": {
-        "@sap/cds-compiler": "6.9.0"
+        "@sap/cds-compiler": "6.9.2"
     },
     "cds": {
         "requires": {

package/lib/utils.js

@@ -1,12 +0,0 @@
-/**
- * Checks if at least one policy level in the array is SAP.
- *
- * @param {string[]} policyLevels - Array of policy levels.
- */
-function hasSAPPolicyLevel(policyLevels) {
-    return policyLevels.some((policyLevel) => policyLevel.split(":")[0].toLowerCase() === "sap");
-}
-
-module.exports = {
-    hasSAPPolicyLevel,
-};