@cap-js/ord 1.4.3 → 1.4.5

package/lib/build.js

@@ -87,6 +87,14 @@ module.exports = class OrdBuildPlugin extends cds.build.Plugin {
     }
 
     async build() {
+        // @cap-js/graphql registers protocols and compile targets at runtime via cds-plugin.js,
+        // but cds build rebuilds cds.env afterwards, losing both registrations.
+        // Re-apply so endpoints4() and cds.compile.to.graphql work during build.
+        if ("@cap-js/graphql" in cds.env.plugins && !cds.env.protocols?.graphql) {
+            cds.env.protocols.graphql = { path: "/graphql", impl: "@cap-js/graphql" };
+            require("@cap-js/graphql/lib/api").registerCompileTargets();
+        }
+
         try {
             const model = await this.model();
             const ordDocument = ord(model);

package/lib/constants.js

@@ -53,6 +53,7 @@ const COMPILER_TYPES = Object.freeze({
     edmx: "edmx",
     csn: "csn",
     mcp: "mcp",
+    graphql: "graphql",
 });
 
 const CONTENT_MERGE_KEY = "ordId";
@@ -117,6 +118,45 @@ const SEM_VERSION_REGEX =
 
 const MCP_CUSTOM_TYPE = "sap:mcp-server-card:v0";
 
+const EXTERNAL_DP_ORD_ID_ANNOTATION = "@cds.dp.ordId";
+
+const EXTERNAL_SERVICE_ANNOTATION = "@cds.external";
+
+const INTEGRATION_DEPENDENCY_RESOURCE_NAME = "externalDependencies";
+
+// ORD apiProtocol values
+const ORD_API_PROTOCOL = Object.freeze({
+    ODATA_V4: "odata-v4",
+    ODATA_V2: "odata-v2",
+    REST: "rest",
+    GRAPHQL: "graphql",
+    SAP_INA: "sap-ina-api-v1",
+    SAP_DATA_SUBSCRIPTION: "sap.dp:data-subscription-api:v1",
+});
+
+// Mapping from CAP protocol kind to ORD apiProtocol
+// CAP may return 'odata', 'odata-v4', 'rest', 'graphql', etc.
+const CAP_TO_ORD_PROTOCOL_MAP = Object.freeze({
+    "odata": ORD_API_PROTOCOL.ODATA_V4,
+    "odata-v4": ORD_API_PROTOCOL.ODATA_V4,
+    "odata-v2": ORD_API_PROTOCOL.ODATA_V2,
+    "rest": ORD_API_PROTOCOL.REST,
+    "graphql": ORD_API_PROTOCOL.GRAPHQL,
+});
+
+// Protocols that ORD supports but CAP may not recognize (endpoints4 returns [])
+// These need special handling in the ORD plugin
+const ORD_ONLY_PROTOCOLS = Object.freeze({
+    ina: {
+        apiProtocol: ORD_API_PROTOCOL.SAP_INA,
+        hasEntryPoints: false,
+        hasResourceDefinitions: false,
+    },
+});
+
+// Protocols that the ORD plugin cannot currently generate definitions for
+const PLUGIN_UNSUPPORTED_PROTOCOLS = Object.freeze([]);
+
 // CF mTLS Error Reasons
 const CF_MTLS_ERROR_REASON = Object.freeze({
     NO_HEADERS: "NO_HEADERS",
@@ -146,6 +186,7 @@ module.exports = {
     BASIC_AUTH_HEADER_KEY,
     BUILD_DEFAULT_PATH,
     BLOCKED_SERVICE_NAME,
+    CAP_TO_ORD_PROTOCOL_MAP,
     CDS_ELEMENT_KIND,
     CF_MTLS_HEADERS,
     COMPILER_TYPES,
@@ -155,17 +196,23 @@ module.exports = {
     DATA_PRODUCT_TYPE,
     DESCRIPTION_PREFIX,
     ENTITY_RELATIONSHIP_ANNOTATION,
+    EXTERNAL_DP_ORD_ID_ANNOTATION,
+    EXTERNAL_SERVICE_ANNOTATION,
+    INTEGRATION_DEPENDENCY_RESOURCE_NAME,
     LEVEL,
     MCP_CUSTOM_TYPE,
     OPEN_RESOURCE_DISCOVERY_VERSION,
     OPENAPI_SERVERS_ANNOTATION,
     ORD_ACCESS_STRATEGY,
+    ORD_API_PROTOCOL,
     ORD_DOCUMENT_FILE_NAME,
     ORD_EXTENSIONS_PREFIX,
     ORD_ODM_ENTITY_NAME_ANNOTATION,
     ORD_EXISTING_PRODUCT_PROPERTY,
+    ORD_ONLY_PROTOCOLS,
     ORD_RESOURCE_TYPE,
     ORD_SERVICE_NAME,
+    PLUGIN_UNSUPPORTED_PROTOCOLS,
     RESOURCE_VISIBILITY,
     ALLOWED_VISIBILITY,
     IMPLEMENTATIONSTANDARD_VERSIONS,

package/lib/integrationDependency.js

@@ -0,0 +1,127 @@
+const {
+    DATA_PRODUCT_SIMPLE_ANNOTATION,
+    EXTERNAL_DP_ORD_ID_ANNOTATION,
+    EXTERNAL_SERVICE_ANNOTATION,
+    INTEGRATION_DEPENDENCY_RESOURCE_NAME,
+    ORD_RESOURCE_TYPE,
+    RESOURCE_VISIBILITY,
+} = require("./constants");
+const { readORDExtensions, _getPackageID } = require("./templates");
+
+/**
+ * Parses @cds.dp.ordId annotation to extract resource information.
+ * @param {string} ordId - e.g., "sap.sai:apiResource:Supplier:v1"
+ * @returns {Object} { namespace, resourceType, resourceName, version }
+ */
+function parseDataProductOrdId(ordId) {
+    const [namespace, resourceType, resourceName, version = "v1"] = ordId.split(":");
+    return { namespace, resourceType, resourceName, version };
+}
+
+/**
+ * Checks if a CSN definition is an external Data Product.
+ * @param {Object} definition - CSN definition object
+ * @returns {boolean}
+ */
+function isExternalDataProduct(definition) {
+    return !!(
+        definition.kind === "service" &&
+        definition[EXTERNAL_SERVICE_ANNOTATION] &&
+        definition[DATA_PRODUCT_SIMPLE_ANNOTATION] &&
+        definition[EXTERNAL_DP_ORD_ID_ANNOTATION]
+    );
+}
+
+/**
+ * Collects external services from CSN definitions.
+ * Returns a flat list of external services (one per service, no namespace grouping).
+ * @param {Object} csn - The CSN definitions object
+ * @returns {Array} Array of external service objects
+ */
+function collectExternalServices(csn) {
+    const externalServices = [];
+
+    for (const [serviceName, definition] of Object.entries(csn.definitions)) {
+        if (!isExternalDataProduct(definition)) continue;
+
+        const dpOrdId = definition[EXTERNAL_DP_ORD_ID_ANNOTATION];
+        const { resourceType, version } = parseDataProductOrdId(dpOrdId);
+
+        // Only support apiResource for now
+        if (resourceType !== "apiResource") continue;
+
+        externalServices.push({
+            serviceName,
+            ordId: dpOrdId,
+            minVersion: version.replace("v", "") + ".0.0",
+            definition,
+        });
+    }
+
+    return externalServices;
+}
+
+/**
+ * Creates a single IntegrationDependency with one aspect per external service.
+ * @param {Array} externalServices - Array of external service objects
+ * @param {Object} appConfig - The application configuration
+ * @param {Array} packageIds - The available package identifiers
+ * @returns {Object} IntegrationDependency object
+ */
+function createIntegrationDependency(externalServices, appConfig, packageIds) {
+    const packageId = _getPackageID(
+        appConfig.ordNamespace,
+        packageIds,
+        ORD_RESOURCE_TYPE.integrationDependency,
+        RESOURCE_VISIBILITY.public,
+    );
+
+    // Create one aspect per external service
+    const aspects = externalServices.map((service) => {
+        const ordExtensions = readORDExtensions(service.definition || {});
+        return {
+            title: service.serviceName,
+            mandatory: false,
+            apiResources: [{ ordId: service.ordId, minVersion: service.minVersion }],
+            ...ordExtensions, // Allow customization via @ORD.Extensions on the service
+        };
+    });
+
+    // Read IntegrationDependency level config from cdsrc
+    const integrationDepConfig = appConfig.env?.integrationDependency || {};
+
+    return {
+        ordId: `${appConfig.ordNamespace}:${ORD_RESOURCE_TYPE.integrationDependency}:${INTEGRATION_DEPENDENCY_RESOURCE_NAME}:v1`,
+        title: "External Dependencies",
+        version: "1.0.0",
+        releaseStatus: "active",
+        visibility: RESOURCE_VISIBILITY.public,
+        mandatory: false,
+        partOfPackage: packageId,
+        aspects,
+        ...integrationDepConfig, // Allow customization via cdsrc
+    };
+}
+
+/**
+ * Generates a single IntegrationDependency for all external services.
+ * @param {Object} csn - The CSN definitions object
+ * @param {Object} appConfig - The application configuration
+ * @param {Array} packageIds - The available package identifiers
+ * @returns {Array} Array containing single IntegrationDependency or empty array
+ */
+function getIntegrationDependencies(csn, appConfig, packageIds) {
+    const externalServices = collectExternalServices(csn);
+    if (externalServices.length === 0) return [];
+
+    return [createIntegrationDependency(externalServices, appConfig, packageIds)];
+}
+
+module.exports = {
+    getIntegrationDependencies,
+    // Exported for testing
+    collectExternalServices,
+    createIntegrationDependency,
+    parseDataProductOrdId,
+    isExternalDataProduct,
+};

package/lib/interopCsn.js

@@ -117,6 +117,12 @@ function map_annotations(csn) {
                 delete o[oldA];
             }
         }
+
+        // delete all @assert.unique annotations
+        let assertUniqueAnnos = Object.keys(o).filter(x => x.startsWith('@assert.unique'))
+        for (let a of assertUniqueAnnos) {
+            delete o[a]
+        }
     }
 }
 

package/lib/metaData.js

@@ -46,7 +46,7 @@ const getMetadata = async (url, model = null) => {
 
                 responseFile = openapi(csn, openapiOptions);
             } catch (error) {
-                Logger.error("OpenApi error:", error.message);
+                Logger.error(`OpenApi error for service ${serviceName} - ${error.message}`);
                 throw error;
             }
             break;
@@ -54,7 +54,7 @@ const getMetadata = async (url, model = null) => {
             try {
                 responseFile = asyncapi(csn, { ...options, ...(compileOptions?.asyncapi || {}) });
             } catch (error) {
-                Logger.error("AsyncApi error:", error.message);
+                Logger.error(`AsyncApi error for service ${serviceName} - ${error.message}`);
                 throw error;
             }
             break;
@@ -64,7 +64,7 @@ const getMetadata = async (url, model = null) => {
                 let effCsn = cdsc.for.effective(csn, opt_eff);
                 responseFile = interopCSN(effCsn);
             } catch (error) {
-                Logger.error("Csn error:", error.message);
+                Logger.error(`Csn error for service ${serviceName} - ${error.message}`);
                 throw error;
             }
             break;
@@ -72,7 +72,7 @@ const getMetadata = async (url, model = null) => {
             try {
                 responseFile = await cds.compile(csn).to["edmx"]({ ...options, ...(compileOptions?.edmx || {}) });
             } catch (error) {
-                Logger.error("Edmx error:", error.message);
+                Logger.error(`Edmx error for service ${serviceName} - ${error.message}`);
                 throw error;
             }
             break;
@@ -88,13 +88,28 @@ const getMetadata = async (url, model = null) => {
                 // Extract only the MCP content, not the ORD metadata
                 responseFile = mcpResult.mcp;
             } catch (error) {
-                Logger.error("MCP server definition error:", error.message);
+                Logger.error(`MCP server definition error - ${error.message}`);
+                throw error;
+            }
+            break;
+        case COMPILER_TYPES.graphql:
+            try {
+                const { generateSchema4 } = require("@cap-js/graphql/lib/schema");
+                const { lexicographicSortSchema, printSchema } = require("graphql");
+                const linked = cds.linked(csn);
+                const srv = new cds.ApplicationService(serviceName, linked);
+                let schema = generateSchema4({ [serviceName]: srv });
+                schema = lexicographicSortSchema(schema);
+                responseFile = printSchema(schema);
+            } catch (error) {
+                Logger.error("GraphQL SDL error:", error.message);
                 throw error;
             }
             break;
     }
     return {
-        contentType: `application/${compilerType === "edmx" ? "xml" : "json"}`,
+        contentType:
+            compilerType === "graphql" ? "text/plain" : `application/${compilerType === "edmx" ? "xml" : "json"}`,
         response: responseFile,
     };
 };

package/lib/ord-service.js

@@ -31,7 +31,8 @@ class OpenResourceDiscoveryService extends cds.ApplicationService {
             return res.status(404).send("404 Not Found");
         });
 
-        cds.app.get(`/ord/v1/:ordId?/:service?`, authMiddleware, async (req, res) => {
+        // Handler for metadata requests (oas3, edmx, csn, etc.)
+        const metadataHandler = async (req, res) => {
             try {
                 const { contentType, response } = await getMetadata(req.url);
                 return res.status(200).contentType(contentType).send(response);
@@ -39,7 +40,12 @@ class OpenResourceDiscoveryService extends cds.ApplicationService {
                 Logger.error(error, "Error while processing the resource definition document");
                 return res.status(500).send(error.message);
             }
-        });
+        };
+
+        // Use separate routes instead of optional parameters for path-to-regexp v8 compatibility
+        cds.app.get(`/ord/v1/:ordId/:service`, authMiddleware, metadataHandler);
+        cds.app.get(`/ord/v1/:ordId`, authMiddleware, metadataHandler);
+        cds.app.get(`/ord/v1`, authMiddleware, metadataHandler);
 
         return super.init();
     }

package/lib/ord.js

@@ -14,6 +14,7 @@ const {
     createMCPAPIResourceTemplate,
     _propagateORDVisibility,
 } = require("./templates");
+const { getIntegrationDependencies } = require("./integrationDependency");
 const { extendCustomORDContentIfExists } = require("./extendOrdWithCustom");
 const { getRFC3339Date } = require("./date");
 const { createAuthConfig } = require("./auth/authentication");
@@ -330,18 +331,17 @@ function _filterUnusedPackages(ordDocument) {
 
     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.apiResources?.forEach((api) => usedPackageIds.add(api.partOfPackage));
+    ordDocument.eventResources?.forEach((event) => usedPackageIds.add(event.partOfPackage));
+    ordDocument.dataProducts?.forEach((dp) => usedPackageIds.add(dp.partOfPackage));
+    ordDocument.integrationDependencies?.forEach((dep) => usedPackageIds.add(dep.partOfPackage));
     ordDocument.entityTypes?.forEach((et) => {
-        if (et && et.partOfPackage) {
+        if (et?.partOfPackage) {
             usedPackageIds.add(et.partOfPackage);
         }
     });
 
-    const filteredPackages = ordDocument.packages.filter((pkg) => usedPackageIds.has(pkg.ordId));
-
-    return filteredPackages;
+    return ordDocument.packages.filter((pkg) => usedPackageIds.has(pkg.ordId));
 }
 
 module.exports = (csn) => {
@@ -375,6 +375,12 @@ module.exports = (csn) => {
             ordDocument.eventResources = eventResources;
         }
     }
+
+    const integrationDependencies = getIntegrationDependencies(linkedCsn, appConfig, packageIds);
+    if (integrationDependencies.length) {
+        ordDocument.integrationDependencies = integrationDependencies;
+    }
+
     ordDocument = extendCustomORDContentIfExists(appConfig, ordDocument);
     ordDocument.packages = _filterUnusedPackages(ordDocument);
 

package/lib/protocol-resolver.js

@@ -0,0 +1,138 @@
+const cds = require("@sap/cds");
+const {
+    CAP_TO_ORD_PROTOCOL_MAP,
+    ORD_ONLY_PROTOCOLS,
+    ORD_API_PROTOCOL,
+    PLUGIN_UNSUPPORTED_PROTOCOLS,
+} = require("./constants");
+const Logger = require("./logger");
+
+/**
+ * Gets CAP endpoints for a service using CDS endpoints4().
+ *
+ * @param {string} serviceName The service name.
+ * @param {Object} srvDefinition The service definition object.
+ * @returns {Array} Raw endpoints from CDS.
+ */
+function _getCapEndpoints(serviceName, srvDefinition) {
+    const srvObj = { name: serviceName, definition: srvDefinition };
+    return cds.service.protocols.endpoints4(srvObj);
+}
+
+/**
+ * Reads the explicit @protocol annotation from service definition.
+ *
+ * @param {Object} srvDefinition The service definition object.
+ * @returns {string[]} Array of protocol names, or empty array if not explicitly set.
+ */
+function _getExplicitProtocol(srvDefinition) {
+    const protocol = srvDefinition["@protocol"];
+    if (!protocol) {
+        return [];
+    }
+    return Array.isArray(protocol) ? protocol : [protocol];
+}
+
+/**
+ * Resolves protocol for ORD API Resource generation.
+ *
+ * Design Principles:
+ * - explicit protocol is the "master switch" for all decisions
+ * - Rule A: Explicit protocol + empty endpoints → don't fall back to OData
+ * - Rule B: Only fallback to OData when no explicit protocol
+ * - Rule C: Never produce [null] in entryPoints
+ *
+ * @param {string} serviceName The service name.
+ * @param {Object} srvDefinition The service definition object.
+ * @param {Object} options Configuration options.
+ * @param {Function} options.isPrimaryDataProduct Strategy function to check if service is primary data product.
+ * @returns {Array} Array with single {apiProtocol, entryPoints, hasResourceDefinitions} object, or empty array.
+ */
+function resolveApiResourceProtocol(serviceName, srvDefinition, options = {}) {
+    const { isPrimaryDataProduct = () => false } = options;
+
+    // 1. Primary Data Product - early return
+    if (isPrimaryDataProduct(srvDefinition)) {
+        return [
+            {
+                apiProtocol: ORD_API_PROTOCOL.SAP_DATA_SUBSCRIPTION,
+                entryPoints: [],
+                hasResourceDefinitions: true,
+            },
+        ];
+    }
+
+    const capEndpoints = _getCapEndpoints(serviceName, srvDefinition);
+    const ordProtocols = [];
+    for (const endpoint of capEndpoints) {
+        if (PLUGIN_UNSUPPORTED_PROTOCOLS.includes(endpoint.kind)) {
+            Logger.warn(
+                `Protocol '${endpoint.kind}' is supported by ORD but this plugin cannot generate its resource definitions yet.`,
+            );
+            continue;
+        }
+
+        const apiProtocol = CAP_TO_ORD_PROTOCOL_MAP[endpoint.kind] ?? endpoint.kind;
+        if (apiProtocol) {
+            ordProtocols.push({
+                apiProtocol,
+                entryPoints: endpoint.path ? [endpoint.path] : [],
+                hasResourceDefinitions: true,
+            });
+        }
+    }
+
+    const explicit = _getExplicitProtocol(srvDefinition);
+    for (const protocol of explicit) {
+        // 2. Handle explicit protocol
+        // 2a. Check if it's an ORD-only protocol (e.g., INA)
+        if (ORD_ONLY_PROTOCOLS[protocol]) {
+            const config = ORD_ONLY_PROTOCOLS[protocol];
+            const path = config.hasEntryPoints ? cds.service.protocols.path4(srvDefinition) : null;
+            ordProtocols.push({
+                apiProtocol: config.apiProtocol,
+                entryPoints: path ? [path] : [],
+                hasResourceDefinitions: config.hasResourceDefinitions,
+            });
+            continue;
+        }
+
+        // 2b. Check if it's a plugin-unsupported protocol
+        if (PLUGIN_UNSUPPORTED_PROTOCOLS.includes(protocol)) {
+            Logger.warn(
+                `Protocol '${protocol}' is supported by ORD but this plugin cannot generate its resource definitions yet.`,
+            );
+            continue;
+        }
+
+        // 4. Handle explicit protocol with no CAP endpoint (Rule A)
+        if (!ordProtocols.some((p) => p.apiProtocol === protocol) && !CAP_TO_ORD_PROTOCOL_MAP[protocol]) {
+            Logger.warn(`Unknown protocol '${protocol}' is not supported, and skipped for service '${serviceName}'.`);
+        }
+    }
+
+    // no protocol found via CAP endpoints, but explicit protocol(s) defined → Rule A: don't fall back to OData, return empty array
+    if (ordProtocols.length === 0 && explicit.length > 0) {
+        return [];
+    }
+
+    if (ordProtocols.length > 0) {
+        return ordProtocols;
+    }
+
+    // 5. No explicit protocol and no CAP endpoint - fallback to OData (Rule B)
+    const path = cds.service.protocols.path4(srvDefinition);
+    return [
+        {
+            apiProtocol: ORD_API_PROTOCOL.ODATA_V4,
+            entryPoints: path ? [path] : [],
+            hasResourceDefinitions: true,
+        },
+    ];
+}
+
+module.exports = {
+    resolveApiResourceProtocol,
+    // Exported for testing
+    _getExplicitProtocol,
+};

package/lib/templates.js

@@ -1,4 +1,3 @@
-const cds = require("@sap/cds");
 const { hasSAPPolicyLevel } = require("./utils");
 const { isMCPPluginReady } = require("./mcpAdapter");
 const defaults = require("./defaults");
@@ -21,9 +20,11 @@ const {
     SHORT_DESCRIPTION_PREFIX,
     CONTENT_MERGE_KEY,
     CDS_ELEMENT_KIND,
+    ORD_API_PROTOCOL,
 } = require("./constants");
 const Logger = require("./logger");
 const { ensureAccessStrategies } = require("./access-strategies");
+const { resolveApiResourceProtocol } = require("./protocol-resolver");
 
 function unflatten(flattedObject) {
     let result = {};
@@ -44,42 +45,6 @@ function readORDExtensions(model) {
     return unflatten(ordExtensions);
 }
 
-/**
- * Reads the service definition and returns an array of entryPoint paths.
- *
- * @param {string} srv The service definition name.
- * @param {Object} srvDefinition The service definition object.
- * @returns {Array} An array containing paths and it's kind.
- */
-const _generatePaths = (srv, srvDefinition) => {
-    const srvObj = { name: srv, definition: srvDefinition };
-    const protocols = cds.service.protocols;
-
-    const paths = protocols.endpoints4(srvObj);
-
-    //TODO: check graphql replication in paths object and re-visit logic
-    //removing instances of graphql protocol from paths
-    for (var index = paths.length - 1; index >= 0; index--) {
-        if (paths[index].kind === "graphql") {
-            Logger.warn("Graphql protocol is not supported.");
-            paths.splice(index, 1);
-        }
-    }
-
-    //putting OData as default in case of non-supported protocol
-    if (paths.length === 0) {
-        if (isPrimaryDataProductService(srvDefinition)) {
-            // Data product services use REST protocol, not OData
-            paths.push({ kind: "rest", path: protocols.path4(srvDefinition) });
-        } else {
-            srvDefinition["@odata"] = true;
-            paths.push({ kind: "odata", path: protocols.path4(srvDefinition) });
-        }
-    }
-
-    return paths;
-};
-
 /**
  * This is a template function to create item of entityTypeMappings array.
  *
@@ -321,9 +286,17 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
     const visibility = _handleVisibility(ordExtensions, serviceDefinition, appConfig.env?.defaultVisibility);
     const packageId = _getPackageID(appConfig.ordNamespace, packageIds, ORD_RESOURCE_TYPE.api, visibility);
 
-    const paths = _generatePaths(serviceName, serviceDefinition);
+    const protocolResults = resolveApiResourceProtocol(serviceName, serviceDefinition, {
+        isPrimaryDataProduct: isPrimaryDataProductService,
+    });
     const apiResources = [];
 
+    // If no protocols were generated, skip this service
+    if (protocolResults.length === 0) {
+        Logger.info(`No supported protocols for service '${serviceName}', skipping API resource generation.`);
+        return apiResources;
+    }
+
     // Handle version suffix extraction for primary data product services
     let cleanServiceName,
         version,
@@ -352,16 +325,48 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
 
     const ordId = `${appConfig.ordNamespace}:apiResource:${cleanServiceName}:${version}`;
 
-    paths.forEach((generatedPath) => {
-        let resourceDefinitions = [
-            _getResourceDefinition("openapi-v3", "json", ordId, serviceName, "oas3.json", accessStrategies),
-        ];
-
-        if (generatedPath.kind !== "rest") {
-            //edmx resource definition is not generated in case of 'rest' protocol
-            resourceDefinitions.push(
-                _getResourceDefinition("edmx", "xml", ordId, serviceName, "edmx", accessStrategies),
-            );
+    protocolResults.forEach((protocolResult) => {
+        const { apiProtocol, entryPoints, hasResourceDefinitions } = protocolResult;
+
+        // Build resource definitions based on protocol
+        let resourceDefinitions = [];
+        if (hasResourceDefinitions) {
+            if (apiProtocol === ORD_API_PROTOCOL.SAP_DATA_SUBSCRIPTION) {
+                // Data product services use CSN
+                resourceDefinitions = [
+                    _getResourceDefinition(
+                        "sap-csn-interop-effective-v1",
+                        "json",
+                        ordId,
+                        serviceName,
+                        "csn.json",
+                        accessStrategies,
+                    ),
+                ];
+            } else if (apiProtocol === ORD_API_PROTOCOL.REST) {
+                // REST only has OpenAPI, no EDMX
+                resourceDefinitions = [
+                    _getResourceDefinition("openapi-v3", "json", ordId, serviceName, "oas3.json", accessStrategies),
+                ];
+            } else if (apiProtocol === ORD_API_PROTOCOL.GRAPHQL) {
+                // GraphQL only has GraphQL SDL
+                resourceDefinitions = [
+                    {
+                        type: "graphql-sdl",
+                        mediaType: "text/plain",
+                        url: `/ord/v1/${ordId}/${serviceName}.graphql`,
+                        accessStrategies: ensureAccessStrategies(accessStrategies, {
+                            resourceName: `${serviceName} (graphql-sdl)`,
+                        }),
+                    },
+                ];
+            } else {
+                // OData and others have both OpenAPI and EDMX
+                resourceDefinitions = [
+                    _getResourceDefinition("openapi-v3", "json", ordId, serviceName, "oas3.json", accessStrategies),
+                    _getResourceDefinition("edmx", "xml", ordId, serviceName, "edmx", accessStrategies),
+                ];
+            }
         }
 
         const entityTypeMappings = _getEntityTypeMappings(serviceDefinition);
@@ -378,9 +383,9 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
             partOfPackage: packageId,
             partOfGroups: [_getGroupID(serviceDefinition, defaults.groupTypeId, appConfig)],
             releaseStatus: "active",
-            apiProtocol: generatedPath.kind === "odata" ? "odata-v4" : generatedPath.kind,
-            resourceDefinitions: resourceDefinitions,
-            entryPoints: [generatedPath.path],
+            apiProtocol,
+            resourceDefinitions,
+            entryPoints,
             extensible: {
                 supported: "no",
             },
@@ -389,24 +394,13 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
             ...ordExtensions,
         };
 
+        // Special handling for data product services
         if (isPrimaryDataProductService(serviceDefinition)) {
-            obj.apiProtocol = "sap.dp:data-subscription-api:v1";
             obj.direction = "outbound";
-            obj.entryPoints = [];
             if (extracted) {
                 // Overwrite partOfGroups
                 obj.partOfGroups = [`${defaults.groupTypeId}:${appConfig.ordNamespace}:${cleanServiceName}`];
             }
-            obj.resourceDefinitions = [
-                _getResourceDefinition(
-                    "sap-csn-interop-effective-v1",
-                    "json",
-                    ordId,
-                    serviceName,
-                    "csn.json",
-                    accessStrategies,
-                ),
-            ];
         }
 
         if (obj.visibility !== RESOURCE_VISIBILITY.private) {
@@ -717,6 +711,7 @@ module.exports = {
     createAPIResourceTemplate,
     createEventResourceTemplate,
     createMCPAPIResourceTemplate,
+    readORDExtensions,
     _getPackageID,
     _getEntityTypeMappings,
     _getExposedEntityTypes,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.4.3",
+    "version": "1.4.5",
     "description": "CAP Plugin for generating ORD document.",
     "repository": "cap-js/ord",
     "author": "SAP SE (https://www.sap.com)",
@@ -28,13 +28,14 @@
         "cds:version": "cds v -i"
     },
     "devDependencies": {
-        "eslint": "^9.2.0",
+        "@cap-js/graphql": "^0.14.0",
+        "@cap-js/sqlite": "^2",
+        "@sap/cds-dk": ">=8.9.5",
+        "eslint": "^10.0.0",
         "express": "^4",
         "jest": "^30.0.0",
         "prettier": "3.8.1",
-        "supertest": "^7.0.0",
-        "@cap-js/sqlite": "^2",
-        "@sap/cds-dk": ">=8.9.5"
+        "supertest": "^7.0.0"
     },
     "peerDependencies": {
         "@sap/cds": ">=8.9.4"
@@ -49,6 +50,9 @@
     "engines": {
         "node": ">=18 <23"
     },
+    "overrides": {
+        "@sap/cds-compiler": "6.7.3"
+    },
     "cds": {
         "requires": {
             "SAP ORD Service": {