@cap-js/ord 1.1.0 → 1.3.0

package/lib/ord.js

@@ -1,86 +1,175 @@
-const path = require("path");
-const cds = require("@sap/cds");
-const { exists } = cds.utils;
-const _ = require("lodash");
-const defaults = require("./defaults");
+const {
+    BLOCKED_SERVICE_NAME,
+    CDS_ELEMENT_KIND,
+    CONTENT_MERGE_KEY,
+    ENTITY_RELATIONSHIP_ANNOTATION,
+    ORD_ODM_ENTITY_NAME_ANNOTATION,
+} = require("./constants");
 const {
     createAPIResourceTemplate,
+    createEntityTypeTemplate,
+    createEntityTypeMappingsItemTemplate,
     createEventResourceTemplate,
     createGroupsTemplateForService,
-    createEntityTypeTemplate
-} = require('./templates');
-const { extendCustomORDContentIfExists } = require('./extendOrdWithCustom');
-const { ORD_RESOURCE_TYPE } = require('./constants');
+    _propagateORDVisibility,
+} = require("./templates");
+const { extendCustomORDContentIfExists } = require("./extendOrdWithCustom");
+const { getRFC3339Date } = require("./date");
+const { getAuthConfig } = require("./authentication");
 
-const logger = cds.log('ord-plugin');
+const { Logger } = require("./logger");
+const _ = require("lodash");
+const cds = require("@sap/cds");
+const defaults = require("./defaults");
+const path = require("path");
 
 const initializeAppConfig = (csn) => {
-    let packagejsonPath = path.join(cds.root, 'package.json')
-    let packageJson;
-    if (exists(packagejsonPath)) {
-        packageJson = require(packagejsonPath);
-    } else {
+    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, eventNames, entityTypeTargets } = _triageCsnDefinitions(csn);
+
+    return {
+        env: cds.env["ord"],
+        lastUpdate,
+        appName,
+        apiEndpoints: Array.from(apiEndpoints),
+        eventNames,
+        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`);
     }
-    const packageName = packageJson.name;
-    const appName = packageJson.name.replace(/^[@]/, "").replace(/[@/]/g, "-");
-    const modelKeys = Object.keys(csn.definitions);
-    const events = [];
-    const serviceNames = [];
-    let odmEntity = [];
-
-    // namespace variable value if present in cdsrc.json take it there or else from package.json
-    //if cdsrc.json does not have applicationNamespace, then use just the namespace
+    return require(packageJsonPath);
+}
+
+function _formatAppName(packageName) {
+    return packageName.replace(/^[@]/, "").replace(/[@/]/g, "-");
+}
+
+function _getORDNamespace(packageName) {
     const vendorNamespace = "customer";
-    const ordNamespace = cds.env["ord"]?.namespace || `${vendorNamespace}.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
-    const eventApplicationNamespace = cds.env?.export?.asyncapi?.applicationNamespace;
+    return cds.env["ord"]?.namespace || `${vendorNamespace}.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
+}
 
+function _validateNamespaces(ordNamespace, eventApplicationNamespace) {
     if (eventApplicationNamespace && ordNamespace !== eventApplicationNamespace) {
-        console.warn("ORD and AsyncAPI namespaces should be the same.");
+        Logger.warn("ORD and AsyncAPI namespaces should be the same.");
     }
+}
 
-    for (const key of modelKeys) {
-        const keyDefinition = csn.definitions[key];
-        switch (keyDefinition.kind) {
-            case ORD_RESOURCE_TYPE.service:
-                if (!keyDefinition["@cds.external"]) {
-                    serviceNames.push(key);
-                }
+function _triageCsnDefinitions(csn) {
+    const pendingApiResourceNames = [];
+    const apiEndpoints = new Set();
+    const pendingEventNames = [];
+    const entityTypeTargets = [];
+    const pendingServiceNames = [];
+
+    for (const definitionKey of Object.keys(csn.definitions)) {
+        const definitionObj = csn.definitions[definitionKey];
+        if (definitionKey.includes(BLOCKED_SERVICE_NAME.MTXServices)) {
+            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;
-            // TODO: should be rewritten
-            case ORD_RESOURCE_TYPE.entity:
-                if (!key.includes(".texts") && keyDefinition["@ODM.entityName"]) {
-                    odmEntity.push(createEntityTypeTemplate(keyDefinition));
+            }
+            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 ORD_RESOURCE_TYPE.event:
-                events.push(key);
+            }
+            case CDS_ELEMENT_KIND.event: {
+                const event = _handleEvent(definitionKey);
+                if (event) pendingEventNames.push(event);
+                break;
+            }
+            case CDS_ELEMENT_KIND.action:
+            case CDS_ELEMENT_KIND.function: {
+                const apiEndpoint = _handleActionOrFunction(definitionKey);
+                if (apiEndpoint) apiEndpoints.add(apiEndpoint);
                 break;
+            }
         }
     }
 
-    odmEntity = _.uniqBy(odmEntity, "ordId");
-
     return {
-        env: cds.env["ord"],
-        appName,
-        events,
-        serviceNames,
-        odmEntity,
-        ordNamespace,
-        eventApplicationNamespace,
-        packageName,
+        serviceNames: pendingServiceNames,
+        apiResourceNames: pendingApiResourceNames,
+        apiEndpoints: Array.from(apiEndpoints),
+        eventNames: pendingEventNames,
+        entityTypeTargets,
     };
-};
+}
+
+function _handleApiResource(apiResourceName, serviceDefinition) {
+    if (_shouldSkipIfServiceOnlyContainsEvents(serviceDefinition) || serviceDefinition["@cds.external"]) {
+        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 _handleEntity(key, keyDefinition) {
+    if (!key.includes(".texts")) {
+        const apiEndpoint = key;
+        const entityTypeTarget =
+            keyDefinition[ORD_ODM_ENTITY_NAME_ANNOTATION] || keyDefinition[ENTITY_RELATIONSHIP_ANNOTATION]
+                ? createEntityTypeMappingsItemTemplate(keyDefinition)
+                : null;
+        return { apiEndpoint, entityTypeTarget };
+    }
+    return null;
+}
 
-const _getPolicyLevel = (appConfig) =>
-    appConfig.env?.policyLevel || defaults.policyLevel;
+function _handleEvent(key) {
+    return key;
+}
 
-const _getDescription = (appConfig) =>
-    appConfig.env?.description || defaults.description;
+function _handleActionOrFunction(key) {
+    return key;
+}
 
-const _getProducts = (appConfig) =>
-    appConfig.env?.products || defaults.products(appConfig.packageName);
+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
@@ -88,79 +177,132 @@ const _getGroups = (csn, appConfig) => {
         .filter((resource) => !!resource);
 };
 
-const _getPackages = (policyLevel, appConfig) =>
-    appConfig.env?.packages || appConfig.events.length
-        ? defaults.packages(appConfig.appName, policyLevel, appConfig.ordNamespace)
-        : defaults
-            .packages(appConfig.appName, policyLevel, appConfig.ordNamespace)
-            .slice(0, 1);
+const _getPackages = (policyLevels, appConfig) => {
+    return defaults.packages(appConfig, policyLevels);
+};
 
-const _getAPIResources = (csn, appConfig, packageIds) => {
-    return appConfig.serviceNames
-        .flatMap((serviceName) => createAPIResourceTemplate(serviceName, csn.definitions[serviceName], appConfig, packageIds) || [])
-        .filter((resource) => !!resource);
+const _getEntityTypes = (appConfig, packageIds) => {
+    if (!appConfig.entityTypeTargets?.length) return [];
+
+    return appConfig.entityTypeTargets.map((entity) => createEntityTypeTemplate(appConfig, packageIds, entity));
 };
 
-const _getEventResources = (csn, appConfig, packageIds) => {
-    if (appConfig.events.length === 0) return [];
-    return appConfig.serviceNames
-        .filter((serviceName) => appConfig.events.some((eventName) => eventName.startsWith(serviceName)))
-        .flatMap((serviceName) => createEventResourceTemplate(serviceName, csn.definitions[serviceName], appConfig, packageIds) || []);
+const _getAPIResources = (csn, appConfig, packageIds, accessStrategies) => {
+    return appConfig.apiResourceNames.flatMap((apiResourceName) =>
+        createAPIResourceTemplate(
+            apiResourceName,
+            csn.definitions[apiResourceName],
+            appConfig,
+            packageIds,
+            accessStrategies,
+        ),
+    );
 };
 
-function validateNamespace(appConfig) {
-    const validateSystemNamespace = new RegExp(`^${appConfig.eventApplicationNamespace}\\.[^.]+\\..+$`);
-    if (
-        appConfig.ordNamespace === undefined &&
-        !validateSystemNamespace.test(appConfig.ordNamespace)
-    ) {
-        let error = new Error(
-            `Namespace is not defined in cdsrc.json or it is not in the format of ${appConfig.eventApplicationNamespace}.<appName>.<service>`
-        );
-        console.error("Namespace error:", error.message);
-        throw error;
-    }
+const _getEventResources = (csn, appConfig, packageIds, accessStrategies) => {
+    return appConfig.serviceNames.flatMap((serviceName) =>
+        createEventResourceTemplate(serviceName, csn.definitions[serviceName], 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")) {
+            Logger.error(
+                "Detected sap product ordId, which should not be defined for custom products, use default value instead. Please check ord global registry.",
+            );
+        } else {
+            _.assign(productsObj[0], customProducts);
+        }
+    }
+    appConfig.products = productsObj;
+    return productsObj;
+};
+
 function createDefaultORDDocument(linkedCsn, appConfig) {
     let ordDocument = {
-        $schema: "https://sap.github.io/open-resource-discovery/spec-v1/interfaces/Document.schema.json",
-        openResourceDiscovery: "1.9",
-        policyLevel: _getPolicyLevel(appConfig),
+        $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
+        openResourceDiscovery: _getOpenResourceDiscovery(appConfig),
+        policyLevels: _getPolicyLevels(appConfig),
         description: _getDescription(appConfig),
-        products: _getProducts(appConfig),
-        groups: _getGroups(linkedCsn, appConfig),
+        consumptionBundles: _getConsumptionBundles(appConfig),
     };
 
-    if (_getAPIResources(linkedCsn, appConfig).length && _getEventResources(linkedCsn, appConfig).length) {
-        ordDocument.packages = _getPackages(ordDocument.policyLevel, appConfig);
+    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(ordDocument.policyLevels, appConfig);
+
     return ordDocument;
 }
 
 function extractPackageIds(ordDocument) {
-    const packageIds = new Set();
-    if (ordDocument.packages) {
-        ordDocument.packages.map((pkg) => packageIds.add(pkg.ordId));
-    }
-    return packageIds;
+    return ordDocument.packages?.map((pkg) => pkg.ordId) || [];
+}
+
+function _filterUnusedPackages(ordDocument) {
+    if (!ordDocument.packages?.length) return [];
+
+    const usedPackageIds = new Set();
+
+    ordDocument.apiResources?.forEach((api) => usedPackageIds?.add(api.partOfPackage));
+    ordDocument.eventResources?.forEach((event) => usedPackageIds?.add(event.partOfPackage));
+    ordDocument.dataProducts?.forEach((dp) => usedPackageIds?.add(dp.partOfPackage));
+    ordDocument.entityTypes?.forEach((et) => {
+        if (et && et.partOfPackage) {
+            usedPackageIds.add(et.partOfPackage);
+        }
+    });
+
+    const filteredPackages = ordDocument.packages.filter((pkg) => usedPackageIds.has(pkg.ordId));
+
+    return filteredPackages;
 }
 
 module.exports = (csn) => {
-    const linkedCsn = cds.linked(csn);
+    const linkedCsn = _propagateORDVisibility(cds.linked(csn));
     const appConfig = initializeAppConfig(linkedCsn);
-    validateNamespace(appConfig);
+    const accessStrategies = getAuthConfig().accessStrategies;
 
     let ordDocument = createDefaultORDDocument(linkedCsn, appConfig);
     const packageIds = extractPackageIds(ordDocument);
-    // TODO: add testcase without apiResources or event, no empty package
-    ordDocument.apiResources = _getAPIResources(linkedCsn, appConfig, packageIds);
-    const eventResources = _getEventResources(linkedCsn, appConfig, packageIds);
-    if (eventResources.length) {
-        ordDocument.eventResources = eventResources;
+    const entityTypes = _getEntityTypes(appConfig, packageIds);
+
+    if (entityTypes.length) {
+        ordDocument.entityTypes = entityTypes;
     }
 
-    ordDocument = extendCustomORDContentIfExists(appConfig, ordDocument, logger);
+    if (appConfig.apiResourceNames.length) {
+        const apiResources = _getAPIResources(linkedCsn, appConfig, packageIds, accessStrategies);
+        if (apiResources.length) {
+            ordDocument.apiResources = apiResources;
+        }
+    }
+    if (appConfig.eventNames.length) {
+        const eventResources = _getEventResources(linkedCsn, appConfig, packageIds, accessStrategies);
+        if (eventResources.length) {
+            ordDocument.eventResources = eventResources;
+        }
+    }
+    ordDocument = extendCustomORDContentIfExists(appConfig, ordDocument);
+    ordDocument.packages = _filterUnusedPackages(ordDocument);
 
     return ordDocument;
 };