@cap-js/ord 1.3.6 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.3.6",
+    "version": "1.3.7",
     "description": "CAP Plugin for generating ORD document.",
     "repository": "cap-js/ord",
     "author": "SAP SE (https://www.sap.com)",
@@ -34,7 +34,7 @@
     "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"
     },