@cap-js/ord 1.6.0 → 1.8.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,69 +89,88 @@ 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) => [
-        {
-            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",
-        },
-    ],
-
-    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

@@ -89,11 +89,12 @@ function createIntegrationDependency(externalServices, appConfig, packageIds) {
 
     // Read IntegrationDependency level config from cdsrc
     const integrationDepConfig = appConfig.env?.integrationDependency || {};
+    const version = integrationDepConfig.version || "1.0.0";
 
     return {
-        ordId: `${appConfig.ordNamespace}:${ORD_RESOURCE_TYPE.integrationDependency}:${INTEGRATION_DEPENDENCY_RESOURCE_NAME}:v1`,
+        ordId: `${appConfig.ordNamespace}:${ORD_RESOURCE_TYPE.integrationDependency}:${INTEGRATION_DEPENDENCY_RESOURCE_NAME}:v${version.split(".")[0]}`,
         title: "External Dependencies",
-        version: "1.0.0",
+        version: version,
         releaseStatus: "active",
         visibility: RESOURCE_VISIBILITY.public,
         mandatory: false,
@@ -122,6 +123,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);
                 }
             }