@cap-js/ord 1.3.5 → 1.3.7

package/lib/authentication.js

@@ -1,7 +1,7 @@
 const cds = require("@sap/cds");
 const { AUTHENTICATION_TYPE, BASIC_AUTH_HEADER_KEY, AUTH_TYPE_ORD_ACCESS_STRATEGY_MAP } = require("./constants");
 const { Logger } = require("./logger");
-const bcrypt = require("bcrypt");
+const bcrypt = require("bcryptjs");
 
 /**
  * Compares a plain text password with a hashed password

package/lib/build.js

@@ -3,6 +3,7 @@ const cds_dk = require("@sap/cds-dk");
 const path = require("path");
 const _ = require("lodash");
 const { ord, getMetadata } = require("./index");
+const cliProgress = require("cli-progress");
 const { BUILD_DEFAULT_PATH, ORD_SERVICE_NAME, ORD_DOCUMENT_FILE_NAME } = require("./constants");
 
 module.exports = class OrdBuildPlugin extends cds_dk.build.Plugin {
@@ -13,27 +14,58 @@ module.exports = class OrdBuildPlugin extends cds_dk.build.Plugin {
     }
 
     async _writeResourcesFiles(resObj, model, promises) {
-        for (const resource of resObj) {
-            if (resource.ordId.includes(ORD_SERVICE_NAME) || !resource.resourceDefinitions) {
-                continue;
+        let totalFiles = resObj.reduce((total, resource) => {
+            if (!resource.ordId.includes(ORD_SERVICE_NAME) && resource.resourceDefinitions) {
+                return total + resource.resourceDefinitions.length;
             }
+            return total;
+        }, 0);
 
-            for (const resourceDefinition of resource.resourceDefinitions) {
-                const url = resourceDefinition.url;
-                const fileName = path.join(resource.ordId, url.split("/").pop());
-                try {
-                    const { _, response } = await getMetadata(url, model); // eslint-disable-line no-unused-vars
-                    promises.push(
-                        this.write(response)
-                            .to(fileName.replace(/:/g, "_"))
-                            .catch((err) => {
-                                console.log("Error", `Failed to write file ${fileName}: ${err.message}`);
-                            }),
-                    );
-                } catch (error) {
-                    console.log("Error", `Failed to get metadata for ${url}: ${error.message}`);
+        const progressBar = new cliProgress.SingleBar({
+            format: "Processing resourcesFiles [{bar}] {percentage}% | {value}/{total} | ETA: {eta}s",
+            barCompleteChar: "█",
+            barIncompleteChar: "░",
+            stopOnComplete: true,
+        });
+
+        let warnings = [];
+        let completed = 0;
+        progressBar.start(totalFiles, 0);
+
+        try {
+            for (const resource of resObj) {
+                if (resource.ordId.includes(ORD_SERVICE_NAME) || !resource.resourceDefinitions) continue;
+                for (const resourceDefinition of resource.resourceDefinitions) {
+                    try {
+                        const { _, response } = await getMetadata(resourceDefinition.url, model); // eslint-disable-line no-unused-vars
+                        const fileName = path
+                            .join(resource.ordId, resourceDefinition.url.split("/").pop())
+                            .replace(/:/g, "_");
+                        promises.push(
+                            this.write(response)
+                                .to(fileName)
+                                .catch((err) => {
+                                    warnings.push(`Error writing file ${fileName}: ${err.message}`);
+                                }),
+                        );
+                        completed++;
+                        progressBar.update(completed);
+                    } catch (error) {
+                        completed++;
+                        progressBar.update(completed);
+                        warnings.push(`Error getting metadata for ${resourceDefinition.url}: ${error.message}`);
+                    } finally {
+                        completed++;
+                        progressBar.update(completed);
+                    }
                 }
             }
+            await Promise.all(promises);
+        } catch (error) {
+            warnings.push("Failed to process resources: " + error.message);
+            throw error;
+        } finally {
+            progressBar.stop();
         }
     }
 
@@ -79,7 +111,6 @@ module.exports = class OrdBuildPlugin extends cds_dk.build.Plugin {
         if (ordDocument.eventResources && ordDocument.eventResources.length > 0) {
             await this._writeResourcesFiles(ordDocument.eventResources, model, promises);
         }
-
         return Promise.all(promises);
     }
 };

package/lib/constants.js

@@ -83,6 +83,14 @@ const RESOURCE_VISIBILITY = Object.freeze({
     private: "private",
 });
 
+const ALLOWED_VISIBILITY = Object.values(RESOURCE_VISIBILITY);
+
+const IMPLEMENTATIONSTANDARD_VERSIONS = Object.freeze({
+    v1: "sap:ord-document-api:v1",
+});
+
+const SUPPORTED_IMPLEMENTATIONSTANDARD_VERSIONS = Object.values(IMPLEMENTATIONSTANDARD_VERSIONS);
+
 const SHORT_DESCRIPTION_PREFIX = "Short description of ";
 
 const SEM_VERSION_REGEX =
@@ -111,6 +119,9 @@ module.exports = {
     ORD_RESOURCE_TYPE,
     ORD_SERVICE_NAME,
     RESOURCE_VISIBILITY,
+    ALLOWED_VISIBILITY,
+    IMPLEMENTATIONSTANDARD_VERSIONS,
+    SUPPORTED_IMPLEMENTATIONSTANDARD_VERSIONS,
     SHORT_DESCRIPTION_PREFIX,
     SEM_VERSION_REGEX,
 };

package/lib/ord.js

@@ -80,10 +80,7 @@ function _triageCsnDefinitions(csn) {
     const apiEndpoints = new Set();
     const pendingEventServiceNames = new Set();
     const entityTypeTargets = [];
-    const pendingServiceNames = [];
-    const serviceNames = Object.keys(csn.definitions).filter(
-        (key) => csn.definitions[key].kind === CDS_ELEMENT_KIND.service,
-    );
+    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];
@@ -91,12 +88,11 @@ function _triageCsnDefinitions(csn) {
             definitionKey.includes(BLOCKED_SERVICE_NAME.MTXServices) ||
             definitionKey.includes(BLOCKED_SERVICE_NAME.OpenResourceDiscoveryService)
         ) {
-            Logger.warn(`ORD service name "${definitionKey}" is blocked.`);
+            Logger.warn("ORD service name", definitionKey, "is blocked.");
             continue;
         }
         switch (definitionObj.kind) {
             case CDS_ELEMENT_KIND.service: {
-                pendingServiceNames.push(definitionKey);
                 const apiResourceName = _handleApiResource(definitionKey, definitionObj);
                 if (apiResourceName) pendingApiResourceNames.push(apiResourceName);
                 break;
@@ -110,13 +106,13 @@ function _triageCsnDefinitions(csn) {
                 break;
             }
             case CDS_ELEMENT_KIND.event: {
-                const event = _handleEvent(serviceNames, definitionKey);
+                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);
+                const apiEndpoint = _handleActionOrFunction(definitionKey, definitionObj);
                 if (apiEndpoint) apiEndpoints.add(apiEndpoint);
                 break;
             }
@@ -124,7 +120,7 @@ function _triageCsnDefinitions(csn) {
     }
 
     return {
-        serviceNames: pendingServiceNames,
+        serviceNames,
         apiResourceNames: pendingApiResourceNames,
         apiEndpoints: Array.from(apiEndpoints),
         eventServiceNames: [...pendingEventServiceNames],
@@ -133,7 +129,10 @@ function _triageCsnDefinitions(csn) {
 }
 
 function _handleApiResource(apiResourceName, serviceDefinition) {
-    if (_shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) || serviceDefinition["@cds.external"]) {
+    if (
+        _shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) ||
+        !_isValidService(apiResourceName, serviceDefinition)
+    ) {
         return null;
     }
     return apiResourceName;
@@ -151,8 +150,32 @@ function _shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) {
     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")) {
+    if (!key.includes(".texts") && _shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
         const apiEndpoint = key;
         const entityTypeTarget =
             keyDefinition[ORD_ODM_ENTITY_NAME_ANNOTATION] || keyDefinition[ENTITY_RELATIONSHIP_ANNOTATION]
@@ -163,16 +186,22 @@ function _handleEntity(key, keyDefinition) {
     return null;
 }
 
-function _handleEvent(serviceNames, key) {
-    for (const serviceName of serviceNames) {
-        if (key.startsWith(serviceName + ".")) {
-            return serviceName;
+function _handleEvent(serviceNames, key, keyDefinition) {
+    if (_shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
+        for (const serviceName of serviceNames) {
+            if (key.startsWith(serviceName + ".")) {
+                return serviceName;
+            }
         }
     }
+    return null;
 }
 
-function _handleActionOrFunction(key) {
-    return key;
+function _handleActionOrFunction(key, keyDefinition) {
+    if (_shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
+        return key;
+    }
+    return null;
 }
 
 const _getPolicyLevels = (appConfig) =>

package/lib/templates.js

@@ -13,6 +13,8 @@ const {
     ORD_ODM_ENTITY_NAME_ANNOTATION,
     ORD_RESOURCE_TYPE,
     RESOURCE_VISIBILITY,
+    ALLOWED_VISIBILITY,
+    SUPPORTED_IMPLEMENTATIONSTANDARD_VERSIONS,
     SEM_VERSION_REGEX,
     SHORT_DESCRIPTION_PREFIX,
     CONTENT_MERGE_KEY,
@@ -139,7 +141,7 @@ function _getEntityVersion(entity) {
     const entityVersion = entity.ordId.split(":").pop();
     const version = entityVersion.replace("v", "") + ".0.0"; // TODO: version can be stated/overwritten by annotation
     if (!SEM_VERSION_REGEX.test(version)) {
-        Logger.warn(`Entity version "${version}" is not a valid semantic version.`);
+        Logger.warn("Entity version", version, "is not a valid semantic version.");
     }
     return version;
 }
@@ -240,16 +242,37 @@ const createEntityTypeTemplate = (appConfig, packageIds, entity) => {
     };
 };
 
-function _handleVisibility(ordExtensions, definition) {
+/**
+ * Determines the visibility of a resource based on provided extensions, definition, and default visibility.
+ *
+ * The function checks for custom visibility values, validates the default visibility,
+ * and applies specific rules based on the resource's definition and extensions.
+ *
+ * @param {Object} ordExtensions - Extensions object containing resource metadata.
+ * @param {Object} definition - The resource definition object.
+ * @param {string} [defaultVisibility=RESOURCE_VISIBILITY.public] - The default visibility value.
+ * @returns {string} The resolved visibility value for the resource.
+ */
+function _handleVisibility(ordExtensions, definition, defaultVisibility = RESOURCE_VISIBILITY.public) {
     let visibility;
+    //check for supported custom visibility value in defaultVisibility variable
+    if (!ALLOWED_VISIBILITY.includes(defaultVisibility)) {
+        Logger.warn("Default visibility", defaultVisibility, "is not supported. Using", RESOURCE_VISIBILITY.public, "as fallback.");
+        defaultVisibility = RESOURCE_VISIBILITY.public;
+    }
+    // Determine visibility
     if (isPrimaryDataProductService(definition)) {
         visibility = RESOURCE_VISIBILITY.internal;
     } else if (ordExtensions.visibility) {
         visibility = ordExtensions.visibility;
     } else if (definition[ORD_EXTENSIONS_PREFIX + "visibility"]) {
         visibility = definition[ORD_EXTENSIONS_PREFIX + "visibility"];
-    } else {
+    } else if (SUPPORTED_IMPLEMENTATIONSTANDARD_VERSIONS.includes(ordExtensions.implementationStandard)) {
+        // if the implementationStandard is for example sap:ord-document-api:v1, it should be public by default
         visibility = RESOURCE_VISIBILITY.public;
+    } else if (ALLOWED_VISIBILITY.includes(defaultVisibility)) {
+        // Default visibility from config file
+        visibility = defaultVisibility;
     }
     return visibility;
 }
@@ -267,7 +290,7 @@ function _handleVisibility(ordExtensions, definition) {
  */
 const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, packageIds, accessStrategies) => {
     const ordExtensions = readORDExtensions(serviceDefinition);
-    const visibility = _handleVisibility(ordExtensions, serviceDefinition);
+    const visibility = _handleVisibility(ordExtensions, serviceDefinition, appConfig.env?.defaultVisibility);
     const packageId = _getPackageID(appConfig.ordNamespace, packageIds, ORD_RESOURCE_TYPE.api, visibility);
 
     const paths = _generatePaths(serviceName, serviceDefinition);
@@ -287,6 +310,7 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
         }
 
         const entityTypeMappings = _getEntityTypeMappings(serviceDefinition);
+        const exposedEntityTypes = _getExposedEntityTypes(serviceDefinition);
 
         let obj = {
             ordId,
@@ -306,6 +330,7 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
                 supported: "no",
             },
             ...(entityTypeMappings ? { entityTypeMappings } : {}),
+            ...(exposedEntityTypes ? { exposedEntityTypes } : []),
             ...ordExtensions,
         };
 
@@ -349,10 +374,11 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
  */
 const createEventResourceTemplate = (serviceName, serviceDefinition, appConfig, packageIds, accessStrategies) => {
     const ordExtensions = readORDExtensions(serviceDefinition);
-    const visibility = _handleVisibility(ordExtensions, 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 exposedEntityTypes = _getExposedEntityTypes(serviceDefinition);
 
     let obj = {
         ordId,
@@ -376,6 +402,7 @@ const createEventResourceTemplate = (serviceName, serviceDefinition, appConfig,
         ],
         extensible: { supported: "no" },
         ...(entityTypeMappings ? { entityTypeMappings } : {}),
+        ...(exposedEntityTypes ? { exposedEntityTypes } : []),
         ...ordExtensions,
     };
 
@@ -408,6 +435,26 @@ function _getEntityTypeMappings(definitionObj) {
     }
 }
 
+function _getExposedEntityTypes(definitionObj) {
+    if (!definitionObj.entities) {
+        return;
+    }
+    const entities = Object.values(definitionObj.entities).flatMap((entity) => {
+        const entityData = _flattenEntityGraph(entity).map(createEntityTypeMappingsItemTemplate);
+        return _.uniqBy(entityData, CONTENT_MERGE_KEY);
+    });
+    const exposedEntityTypes = _.uniqBy(entities, CONTENT_MERGE_KEY)
+        .filter((entity) => entity !== undefined)
+        .map(({ ordId }) => ({
+            ordId,
+        }));
+    if (exposedEntityTypes.length > 0) {
+        return exposedEntityTypes;
+    } else {
+        return;
+    }
+}
+
 function _flattenEntityGraph(currentEntity, processedEntities = []) {
     if (!currentEntity.associations) {
         return [currentEntity];
@@ -481,5 +528,7 @@ module.exports = {
     createEventResourceTemplate,
     _getPackageID,
     _getEntityTypeMappings,
+    _getExposedEntityTypes,
     _propagateORDVisibility,
+    _handleVisibility,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.3.5",
+    "version": "1.3.7",
     "description": "CAP Plugin for generating ORD document.",
     "repository": "cap-js/ord",
     "author": "SAP SE (https://www.sap.com)",
@@ -34,13 +34,17 @@
     "dependencies": {
         "@cap-js/asyncapi": "^1.0.3",
         "@cap-js/openapi": "^1.2.1",
-        "bcrypt": "^5.1.1",
+        "bcryptjs": "3.0.2",
+        "cli-progress": "^3.12.0",
         "lodash": "^4.17.21"
     },
     "cds": {
         "requires": {
             "SAP ORD Service": {
                 "model": "@cap-js/ord/lib/ord-service"
+            },
+            "[java]": {
+                "SAP ORD Service": false
             }
         }
     }