@cap-js/ord 1.3.10 → 1.3.11

package/lib/interopCsn.js

@@ -0,0 +1,127 @@
+const localize = require("@sap/cds/lib/i18n/localize");
+
+// turn effective CSN into interop CSN
+function interopCSN(csn) {
+    if (typeof csn != "object" || csn === null) return csn; // handle non-object inputs early
+    add_i18n_texts(csn);
+    map_annotations(csn);
+    add_meta_info(csn);
+    return csn;
+}
+
+//
+// add i18n texts
+//
+// First fetch all texts defined in the app,
+// then remove those that are not referenced in the csn.
+//
+function add_i18n_texts(csn) {
+    // get all texts of the app
+    const i18n = [...(localize.bundles4(csn) || [])]
+        .filter(([locale]) => !!locale)
+        .reduce((all, [locale, value]) => ({ ...all, [locale]: value }), {});
+
+    // get all i18n keys referenced in the csn
+    let i18n_keys = new Set();
+    for (let n1 in csn.definitions) {
+        let def = csn.definitions[n1];
+        collect_i18n(def, i18n_keys);
+        if (def.kind === "entity")
+            for (let n2 in def.elements) {
+                let el = def.elements[n2];
+                collect_i18n(el, i18n_keys);
+            }
+    }
+
+    // delete from i18n array all entries not occuring in i18n_keys and add result to csn
+    for (let locale in i18n) {
+        let texts = i18n[locale];
+        for (let k in texts) {
+            if (!i18n_keys.has(k)) delete texts[k];
+        }
+        if (Object.keys(texts).length === 0) delete i18n[locale];
+    }
+    csn["i18n"] = i18n;
+
+    // helper function: find all i18n keys referenced in annotations
+    // for an entity or element
+    // to be improved: currently only considers annotations with scalar, string-like value;
+    //                 doesn't drill into structured or array-like annotations
+    function collect_i18n(o, keys) {
+        for (let n in o) {
+            if (n.startsWith("@")) {
+                let annoVal = o[n];
+                if (typeof annoVal === "string" && annoVal.startsWith("{i18n>")) {
+                    let [, x] = annoVal.match(/^\{i18n>(.*)\}$/) || [];
+                    if (x) keys.add(x);
+                }
+            }
+        }
+    }
+}
+
+//
+// annotation mapping/replacement
+//
+function map_annotations(csn) {
+    for (let n1 in csn.definitions) {
+        let def = csn.definitions[n1];
+        replaceAnnos(def);
+        if (def.kind === "entity")
+            for (let n2 in def.elements) {
+                let el = def.elements[n2];
+                replaceAnnos(el);
+            }
+    }
+
+    // helper function: do the actual anno replacement
+    function replaceAnnos(o) {
+        // rhs null => anno is removed
+        const annoReplacement = {
+            "@Common.Label": "@EndUserText.label",
+            "@title": "@EndUserText.label",
+            "@label": "@EndUserText.label",
+            "@description": "@EndUserText.quickInfo",
+            "@cds.autoexpose": null,
+        };
+
+        for (const [oldA, newA] of Object.entries(annoReplacement)) {
+            if (o[oldA]) {
+                if (newA) o[newA] ??= o[oldA];
+                delete o[oldA];
+            }
+        }
+    }
+}
+
+//
+// add meta information
+//
+function add_meta_info(csn) {
+    if (typeof csn != "object") return csn; // needed to make tests pass
+    csn["csnInteropEffective"] = "1.0";
+    csn.meta ??= {};
+    csn.meta.flavor = "effective";
+
+    let services = Object.entries(csn.definitions).filter(([, def]) => def.kind === "service");
+    if (services.length === 1) {
+        // assumption: "short" service name contains no dots
+        let segments = services[0][0].split(".");
+        let v = "1";
+        let srv = segments.pop();
+        let m = srv.match(/^v(\d+)$/);
+        if (m) {
+            srv = segments.pop();
+            v = m[1];
+        }
+        csn.meta.document = { version: `${v}.0.0` };
+        csn.meta.__name = srv;
+        if (segments.length > 0) csn.meta.__namespace = segments.join(".");
+    }
+
+    return csn;
+}
+
+module.exports = {
+    interopCSN,
+};

package/lib/metaData.js

@@ -3,6 +3,7 @@ const { compile: openapi } = require("@cap-js/openapi");
 const { compile: asyncapi } = require("@cap-js/asyncapi");
 const { COMPILER_TYPES } = require("./constants");
 const { Logger } = require("./logger");
+const { interopCSN } = require("./interopCsn.js");
 const cdsc = require("@sap/cds-compiler/lib/main");
 
 module.exports = async (url, model = null) => {
@@ -36,8 +37,9 @@ module.exports = async (url, model = null) => {
             break;
         case COMPILER_TYPES.csn:
             try {
-                const opt2 = { beta: { effectiveCsn: true }, effectiveServiceName: serviceName };
-                responseFile = cdsc.for.effective(csn, opt2);
+                const opt_eff = { beta: { effectiveCsn: true }, effectiveServiceName: serviceName };
+                let effCsn = cdsc.for.effective(csn, opt_eff);
+                responseFile = interopCSN(effCsn);
             } catch (error) {
                 Logger.error("Csn error:", error.message);
                 throw error;

package/lib/ord-service.js

@@ -3,6 +3,7 @@ const { ord, getMetadata, defaults, authentication, Logger } = require("./index.
 
 class OpenResourceDiscoveryService extends cds.ApplicationService {
     init() {
+        const logger = Logger.Logger;
         cds.app.get(`${this.path}`, cds.middlewares.before, (_, res) => {
             return res.status(200).send(defaults.baseTemplate);
         });
@@ -22,7 +23,7 @@ class OpenResourceDiscoveryService extends cds.ApplicationService {
                 const { contentType, response } = await getMetadata(req.url);
                 return res.status(200).contentType(contentType).send(response);
             } catch (error) {
-                Logger.error(error, "Error while processing the resource definition document");
+                logger.error(error, "Error while processing the resource definition document");
                 return res.status(500).send(error.message);
             }
         });

package/lib/ord.js

@@ -101,7 +101,7 @@ function _triageCsnDefinitions(csn) {
                 const result = _handleEntity(definitionKey, definitionObj);
                 if (result) {
                     if (result.apiEndpoint) apiEndpoints.add(result.apiEndpoint);
-                    if (result.entityTypeTarget) entityTypeTargets.push(result.entityTypeTarget);
+                    if (result.entityTypeTarget) entityTypeTargets.push(...result.entityTypeTarget);
                 }
                 break;
             }
@@ -177,10 +177,12 @@ function _isValidService(key, definition) {
 function _handleEntity(key, keyDefinition) {
     if (!key.includes(".texts") && _shouldNotSkipIfServiceProtocolIsNone(keyDefinition)) {
         const apiEndpoint = key;
-        const entityTypeTarget =
-            keyDefinition[ORD_ODM_ENTITY_NAME_ANNOTATION] || keyDefinition[ENTITY_RELATIONSHIP_ANNOTATION]
-                ? createEntityTypeMappingsItemTemplate(keyDefinition)
-                : null;
+        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;

package/lib/templates.js

@@ -80,24 +80,28 @@ const _generatePaths = (srv, srvDefinition) => {
  * @returns {Object} An entry of the entityTypeMappings array.
  */
 const createEntityTypeMappingsItemTemplate = (entity) => {
+    const results = [];
     if (entity[ORD_ODM_ENTITY_NAME_ANNOTATION]) {
-        return {
+        results.push({
             ordId: `sap.odm:entityType:${entity[ORD_ODM_ENTITY_NAME_ANNOTATION]}:v1`,
             entityName: entity[ORD_ODM_ENTITY_NAME_ANNOTATION],
             isODMMapping: true,
             ...entity,
-        };
-    } else if (entity[ENTITY_RELATIONSHIP_ANNOTATION]) {
+        });
+    }
+    if (entity[ENTITY_RELATIONSHIP_ANNOTATION]) {
         const ordIdParts = entity[ENTITY_RELATIONSHIP_ANNOTATION].split(":");
         const namespace = ordIdParts[0];
         const entityName = ordIdParts[1];
         const version = ordIdParts[2] || "v1";
-        return {
+        results.push({
             ordId: `${namespace}:entityType:${entityName}:${version}`,
             entityName,
             ...entity,
-        };
+        });
     }
+    if (results.length === 0) return;
+    return results;
 };
 
 function _getGroupID(serviceDefinition, groupTypeId = defaults.groupTypeId, appConfig) {
@@ -468,7 +472,9 @@ function _getEntityTypeMappings(definitionObj) {
         return;
     }
     const entities = Object.values(definitionObj.entities).flatMap((entity) => {
-        const entityData = _flattenEntityGraph(entity).map(createEntityTypeMappingsItemTemplate);
+        const entityData = _flattenEntityGraph(entity)
+            .flatMap(createEntityTypeMappingsItemTemplate) // now returns arrays
+            .filter(Boolean);
         return _.uniqBy(entityData, CONTENT_MERGE_KEY);
     });
     const entityTypeTargets = _.uniqBy(entities, CONTENT_MERGE_KEY)
@@ -488,7 +494,7 @@ function _getExposedEntityTypes(definitionObj) {
         return;
     }
     const entities = Object.values(definitionObj.entities).flatMap((entity) => {
-        const entityData = _flattenEntityGraph(entity).map(createEntityTypeMappingsItemTemplate);
+        const entityData = _flattenEntityGraph(entity).flatMap(createEntityTypeMappingsItemTemplate).filter(Boolean);
         return _.uniqBy(entityData, CONTENT_MERGE_KEY);
     });
     const exposedEntityTypes = _.uniqBy(entities, CONTENT_MERGE_KEY)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.3.10",
+    "version": "1.3.11",
     "description": "CAP Plugin for generating ORD document.",
     "repository": "cap-js/ord",
     "author": "SAP SE (https://www.sap.com)",