@cap-js/ord 1.4.4 → 1.5.0

package/README.md

@@ -231,6 +231,20 @@ const ord = cds.compile.to.ord(csn);
 
 Build all ord related documents, including ordDocument and services resources files:
 
+
+##### Supported Options
+
+1. **workers**:
+    * **Description**: Max number of workers to use during execution
+    * **Supported Values**:
+       * _**workers=N**_ - max number of N (int) workers (e.g. 2 workers => _**workers=2**_)
+       * _**workers=NC**_ - max N (int/float) workers per CPU core (e.g. max 5 workers on a 2 core machine, max 10 workers on a 4 core machine => _**workers=2.5C**_)
+    * **Default Value**: max 1 worker per every 2 CPU cores => _**workers=0.5C**_
+    * **Usage Examples**:
+      * `cds build --for ord --opts 'workers=2'`
+      * `cds build --for ord --opts 'workers=2.5C'`
+      * `cds build --for ord --opts 'workers=0.5C'` (equivalent to `cds build --for ord`)
+
 ```sh
 cds build --for ord
 

package/lib/auth/mtls-endpoint-service.js

@@ -48,7 +48,7 @@ async function fetchMtlsCertInfo(endpoint, timeoutMs) {
     } catch (error) {
         clearTimeout(timeoutId);
         if (error.name === "AbortError") {
-            throw new Error(`Request timeout after ${timeoutMs}ms`);
+            throw new Error(`Request timeout after ${timeoutMs}ms`, { cause: error });
         }
         throw error;
     }

package/lib/build.js

@@ -1,83 +1,64 @@
-const cds = require("@sap/cds");
 const path = require("path");
+const cds = require("@sap/cds");
 const _ = require("lodash");
-const { ord, getMetadata } = require("./index");
+const Piscina = require("piscina");
 const cliProgress = require("cli-progress");
-const { BUILD_DEFAULT_PATH, ORD_SERVICE_NAME, ORD_DOCUMENT_FILE_NAME } = require("./constants");
-const { isMCPPluginInPackageJson } = require("./mcpAdapter");
 
-const { BuildError } = cds.build;
+const os = require("os");
+const { ord } = require("./index");
+const { BUILD_DEFAULT_PATH, ORD_DOCUMENT_FILE_NAME } = require("./constants");
 
 module.exports = class OrdBuildPlugin extends cds.build.Plugin {
     static taskDefaults = { src: cds.env.folders.srv };
 
     init() {
-        if (this.task.dest === undefined) {
-            this.task.dest = path.join(cds.root, BUILD_DEFAULT_PATH);
+        this.task.dest = this.task.dest ?? path.join(cds.root, BUILD_DEFAULT_PATH);
+    }
+
+    async build() {
+        // @cap-js/graphql registers protocols and compile targets at runtime via cds-plugin.js,
+        // but cds build rebuilds cds.env afterward, 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();
         }
+
+        return this.model()
+            .then((model) => ({ model, document: ord(model) }))
+            .then(({ model, document }) =>
+                Promise.all([
+                    this.write(this._postProcess(document)).to(ORD_DOCUMENT_FILE_NAME),
+                    this._generateResourcesFiles(model, [
+                        ...(document.apiResources || []),
+                        ...(document.eventResources || []),
+                    ]),
+                ]),
+            )
+            .catch((error) => {
+                throw new cds.build.BuildError(`ORD build failed: ${error.message}`);
+            });
     }
 
-    _createProgressBar(totalFiles) {
-        const progressBar = new cliProgress.SingleBar({
+    _createProgressBar() {
+        return new cliProgress.SingleBar({
             format: "Processing resourcesFiles [{bar}] {percentage}% | {value}/{total} | ETA: {eta}s",
             barCompleteChar: "█",
             barIncompleteChar: "░",
             stopOnComplete: true,
         });
-        progressBar.start(totalFiles, 0);
-        return progressBar;
     }
 
-    _countTotalFiles(resObj) {
-        return resObj.reduce((total, resource) => {
-            if (!resource.ordId.includes(ORD_SERVICE_NAME) && resource.resourceDefinitions) {
-                return total + resource.resourceDefinitions.length;
-            }
-            return total;
-        }, 0);
-    }
+    _postProcess(document) {
+        const clone = _.cloneDeep(document);
 
-    async _writeResourcesFiles(resObj, model, promises) {
-        const totalFiles = this._countTotalFiles(resObj);
-        const progressBar = this._createProgressBar(totalFiles);
-        let completed = 0;
-
-        try {
-            for (const resource of resObj) {
-                const shouldGenerate = resource.resourceDefinitions || isMCPPluginInPackageJson();
-                if (!shouldGenerate) continue;
-
-                for (const resourceDefinition of resource.resourceDefinitions) {
-                    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));
-                    progressBar.update(++completed);
-                }
-            }
-            await Promise.all(promises);
-        } finally {
-            progressBar.stop();
-        }
-    }
+        [...(clone.apiResources || []), ...(clone.eventResources || [])]
+            .flatMap((resource) => resource.resourceDefinitions || [])
+            .forEach((resourceDefinition) => {
+                resourceDefinition.url = this._createRelativePath(resourceDefinition.url);
+            });
 
-    postProcess(ordDocument) {
-        const clonedOrdDocument = _.cloneDeep(ordDocument);
-        const _updateResourceUrls = (resources) => {
-            for (const resource of resources || []) {
-                if (resource.resourceDefinitions) {
-                    for (const resourceDefinition of resource.resourceDefinitions) {
-                        resourceDefinition.url = this._createRelativePath(resourceDefinition.url);
-                    }
-                }
-            }
-        };
-
-        _updateResourceUrls(clonedOrdDocument.apiResources);
-        _updateResourceUrls(clonedOrdDocument.eventResources);
-
-        return clonedOrdDocument;
+        return clone;
     }
 
     _createRelativePath(url) {
@@ -86,26 +67,42 @@ module.exports = class OrdBuildPlugin extends cds.build.Plugin {
         return path.join(...relative.replace(/:/g, "_").split("/"));
     }
 
-    async build() {
-        try {
-            const model = await this.model();
-            const ordDocument = ord(model);
-            const postProcessedOrdDocument = this.postProcess(ordDocument);
-
-            const promises = [];
-            promises.push(this.write(postProcessedOrdDocument).to(ORD_DOCUMENT_FILE_NAME));
+    _createWorkerPool(tasks, model) {
+        const size = cds.cli?.options?.taskOptions?.workers || os.availableParallelism();
+        const maxThreads = Math.ceil(Number(size) || os.availableParallelism() * Number(size.replace(/C$/i, "")));
 
-            if (ordDocument.apiResources?.length > 0) {
-                await this._writeResourcesFiles(ordDocument.apiResources, model, promises);
-            }
+        return new Piscina({
+            filename: path.join(__dirname, "threads", "compile.js"),
+            workerData: { model: JSON.parse(JSON.stringify(model)) },
+            minThreads: Math.min(tasks, maxThreads, Math.ceil(os.availableParallelism() * 1.5)),
+            maxThreads: Math.min(tasks, maxThreads, Math.ceil(os.availableParallelism() * 1.5)),
+        });
+    }
 
-            if (ordDocument.eventResources?.length > 0) {
-                await this._writeResourcesFiles(ordDocument.eventResources, model, promises);
-            }
+    _extractCompileTasks(resources) {
+        return resources
+            .filter(({ resourceDefinitions }) => !!resourceDefinitions)
+            .flatMap(({ ordId, resourceDefinitions }) => resourceDefinitions.map(({ url }) => ({ url, ordId })));
+    }
 
-            return Promise.all(promises);
-        } catch (error) {
-            throw new BuildError(`ORD build failed: ${error.message}`);
-        }
+    _generateResourcesFiles(model, resources) {
+        const progressBar = this._createProgressBar();
+        const tasks = this._extractCompileTasks(resources);
+        const pool = !tasks.length ? null : this._createWorkerPool(tasks.length, model);
+
+        progressBar.start(tasks.length, 0);
+
+        return Promise.all(
+            tasks.map(({ url, ordId }) =>
+                pool.run({ url }).then((response) =>
+                    this.write(response)
+                        .to(path.join(ordId, url.split("/").pop()).replace(/:/g, "_"))
+                        .then(() => progressBar.increment()),
+                ),
+            ),
+        ).finally(() => {
+            progressBar.stop();
+            return pool?.close({ force: true });
+        });
     }
 };

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";
@@ -115,7 +116,13 @@ const SHORT_DESCRIPTION_PREFIX = "Short description of ";
 const SEM_VERSION_REGEX =
     /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 
-const MCP_CUSTOM_TYPE = "sap:mcp-server-card:v0";
+const MCP_RESOURCE_DEFINITION_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({
@@ -125,21 +132,23 @@ const ORD_API_PROTOCOL = Object.freeze({
     GRAPHQL: "graphql",
     SAP_INA: "sap-ina-api-v1",
     SAP_DATA_SUBSCRIPTION: "sap.dp:data-subscription-api:v1",
+    MCP: "mcp",
 });
 
 // Mapping from CAP protocol kind to ORD apiProtocol
-// CAP may return 'odata', 'odata-v4', 'rest', etc.
+// 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 doesn't recognize (endpoints4 returns [])
+// 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": {
+    ina: {
         apiProtocol: ORD_API_PROTOCOL.SAP_INA,
         hasEntryPoints: false,
         hasResourceDefinitions: false,
@@ -147,8 +156,7 @@ const ORD_ONLY_PROTOCOLS = Object.freeze({
 });
 
 // Protocols that the ORD plugin cannot currently generate definitions for
-// GraphQL is supported by ORD spec, but plugin can't emit graphql-sdl yet
-const PLUGIN_UNSUPPORTED_PROTOCOLS = Object.freeze(["graphql"]);
+const PLUGIN_UNSUPPORTED_PROTOCOLS = Object.freeze([]);
 
 // CF mTLS Error Reasons
 const CF_MTLS_ERROR_REASON = Object.freeze({
@@ -189,8 +197,11 @@ 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,
+    MCP_RESOURCE_DEFINITION_TYPE,
     OPEN_RESOURCE_DISCOVERY_VERSION,
     OPENAPI_SERVERS_ANNOTATION,
     ORD_ACCESS_STRATEGY,

package/lib/extendOrdWithCustom.js

@@ -20,37 +20,7 @@ function patchGeneratedOrdResources(destinationObj, sourceObj) {
     const destObj = _.keyBy(destinationObj, CONTENT_MERGE_KEY);
     const srcObj = _.keyBy(sourceObj, CONTENT_MERGE_KEY);
 
-    // Helper: extract MCP merge logic for clarity & reuse
-    const mergeMCPResource = (ordId, existingKey) => {
-        const baseKey = ordId in destObj ? ordId : existingKey;
-        if (baseKey) {
-            const base = structuredClone(destObj[baseKey]);
-            const override = structuredClone(srcObj[ordId]);
-            const merged = {
-                ...base, // preserve generated structural fields
-                ...override, // overlay custom changes
-                apiProtocol: "mcp", // enforce protocol
-                partOfPackage: base.partOfPackage || override.partOfPackage,
-                resourceDefinitions: base.resourceDefinitions || override.resourceDefinitions,
-            };
-            if (baseKey !== ordId) delete destObj[baseKey];
-            destObj[ordId] = merged;
-        } else {
-            // MCP plugin not available: do not introduce brand-new MCP resource purely from custom file
-            // This preserves contract: MCP resource only exists when plugin is available.
-            // Silently skip or log (warn) to avoid test noise.
-            // Logger.warn could be added here if desired.
-            return; // skip adding
-        }
-    };
-
-    const existingMCPKey = Object.keys(destObj).find((k) => destObj[k]?.apiProtocol === "mcp");
-
     for (const ordId in srcObj) {
-        if (ordId.endsWith(":apiResource:mcp-server:v1")) {
-            mergeMCPResource(ordId, existingMCPKey);
-            continue;
-        }
         destObj[ordId] =
             ordId in destObj
                 ? _.assignWith(structuredClone(destObj[ordId]), structuredClone(srcObj[ordId]))

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]
+        }
     }
 }
 
@@ -126,10 +132,18 @@ function map_annotations(csn) {
 function add_meta_info(csn) {
     if (typeof csn != "object") return csn; // needed to make tests pass
     csn["csnInteropEffective"] = "1.0";
-    csn.meta ??= {};
+    csn.meta ??= {};  // ensure there is a meta section
+
+    // Keep only the properties of csn.meta that are relevant for interop:
+    //   "flavor", "document", "features", and private extension names (starting with "__")
+    // Remove everything else, including "creator" (leaks build details) and
+    // any unknown compiler-added properties (e.g. "compilerCsnFlavor").
+    for (let k in csn.meta) {
+        if (!["flavor", "document", "features"].includes(k) && !k.startsWith("__")) {
+            delete csn.meta[k];
+        } 
+    }
     csn.meta.flavor = "effective";
-    // Remove compiler creator information – not relevant for ORD interop and leaks build details
-    if (csn.meta.creator) delete csn.meta.creator;
 
     let services = Object.entries(csn.definitions).filter(([, def]) => def.kind === "service");
     if (services.length === 1) {

package/lib/metaData.js

@@ -5,7 +5,6 @@ const { COMPILER_TYPES, OPENAPI_SERVERS_ANNOTATION } = require("./constants");
 const Logger = require("./logger");
 const { interopCSN } = require("./interopCsn.js");
 const cdsc = require("@sap/cds-compiler/lib/main");
-const { isMCPPluginReady, buildMcpServerDefinition } = require("./mcpAdapter");
 
 /**
  * Read @OpenAPI.servers annotation from service definition
@@ -46,7 +45,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 +53,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 +63,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,29 +71,36 @@ 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;
         case COMPILER_TYPES.mcp:
-            if (!isMCPPluginReady()) {
-                throw new Error("MCP plugin is not available or not ready for use");
+            try {
+                responseFile = await cds.compile(csn).to["mcp"]({ ...options, ...(compileOptions?.mcp || {}) });
+            } catch (error) {
+                Logger.error("MCP error:", error.message);
+                throw error;
             }
+            break;
+        case COMPILER_TYPES.graphql:
             try {
-                // Get all available CDS services
-                const allServices = Object.values(cds.services);
-                // Generate metadata from runtime services using adapter
-                const mcpResult = await buildMcpServerDefinition(allServices);
-                // Extract only the MCP content, not the ORD metadata
-                responseFile = mcpResult.mcp;
+                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("MCP server definition error:", error.message);
+                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

@@ -1,6 +1,6 @@
 const cds = require("@sap/cds");
 const ord = require("./ord.js");
-const getMetadata = require("./metaData.js");
+const compileMetadata = require("./metaData.js");
 const defaults = require("./defaults.js");
 const { createAuthConfig, createAuthMiddleware } = require("./auth/authentication.js");
 const Logger = require("./logger.js");
@@ -31,15 +31,21 @@ 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);
+                const { contentType, response } = await compileMetadata(req.url);
                 return res.status(200).contentType(contentType).send(response);
             } catch (error) {
                 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

@@ -11,13 +11,12 @@ const {
     createEntityTypeMappingsItemTemplate,
     createEventResourceTemplate,
     createGroupsTemplateForService,
-    createMCPAPIResourceTemplate,
     _propagateORDVisibility,
 } = require("./templates");
+const { getIntegrationDependencies } = require("./integrationDependency");
 const { extendCustomORDContentIfExists } = require("./extendOrdWithCustom");
 const { getRFC3339Date } = require("./date");
 const { createAuthConfig } = require("./auth/authentication");
-const { isMCPPluginReady } = require("./mcpAdapter");
 
 const Logger = require("./logger");
 const _ = require("lodash");
@@ -25,24 +24,6 @@ const cds = require("@sap/cds");
 const defaults = require("./defaults");
 const path = require("path");
 
-const _addMCPResourceIfAvailable = (apiResources, appConfig, packageIds, accessStrategies) => {
-    // Use comprehensive check for MCP plugin readiness
-    const shouldAddMCP = isMCPPluginReady();
-    if (shouldAddMCP) {
-        try {
-            const mcpResources = createMCPAPIResourceTemplate(appConfig, packageIds, accessStrategies);
-            // Handle both array and single object responses from MCP plugin
-            if (Array.isArray(mcpResources)) {
-                apiResources.push(...mcpResources);
-            } else if (mcpResources) {
-                apiResources.push(mcpResources);
-            }
-        } catch (error) {
-            Logger.warn("Failed to create MCP API resource:", error.message);
-        }
-    }
-};
-
 const initializeAppConfig = (csn) => {
     const packageJson = _loadPackageJson();
     const packageName = packageJson.name;
@@ -260,9 +241,6 @@ const _getAPIResources = (csn, appConfig, packageIds, accessStrategies) => {
         ),
     );
 
-    // Conditionally add MCP API resource if plugin is available
-    _addMCPResourceIfAvailable(apiResources, appConfig, packageIds, accessStrategies);
-
     return apiResources;
 };
 
@@ -330,18 +308,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 +352,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

@@ -23,14 +23,14 @@ function _getCapEndpoints(serviceName, srvDefinition) {
  * Reads the explicit @protocol annotation from service definition.
  *
  * @param {Object} srvDefinition The service definition object.
- * @returns {string|null} Protocol name, or null if not explicitly set.
+ * @returns {string[]} Array of protocol names, or empty array if not explicitly set.
  */
 function _getExplicitProtocol(srvDefinition) {
     const protocol = srvDefinition["@protocol"];
     if (!protocol) {
-        return null;
+        return [];
     }
-    return Array.isArray(protocol) ? protocol[0] : protocol;
+    return Array.isArray(protocol) ? protocol : [protocol];
 }
 
 /**
@@ -38,7 +38,7 @@ function _getExplicitProtocol(srvDefinition) {
  *
  * Design Principles:
  * - explicit protocol is the "master switch" for all decisions
- * - Rule A: Explicit protocol + empty endpoints → don't fallback to OData
+ * - 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
  *
@@ -62,34 +62,8 @@ function resolveApiResourceProtocol(serviceName, srvDefinition, options = {}) {
         ];
     }
 
-    const explicit = _getExplicitProtocol(srvDefinition);
-
-    // 2. Handle explicit protocol
-    if (explicit) {
-        // 2a. Check if it's an ORD-only protocol (e.g., INA)
-        if (ORD_ONLY_PROTOCOLS[explicit]) {
-            const config = ORD_ONLY_PROTOCOLS[explicit];
-            const path = config.hasEntryPoints ? cds.service.protocols.path4(srvDefinition) : null;
-            return [
-                {
-                    apiProtocol: config.apiProtocol,
-                    entryPoints: path ? [path] : [],
-                    hasResourceDefinitions: config.hasResourceDefinitions,
-                },
-            ];
-        }
-
-        // 2b. Check if it's a plugin-unsupported protocol
-        if (PLUGIN_UNSUPPORTED_PROTOCOLS.includes(explicit)) {
-            Logger.warn(
-                `Protocol '${explicit}' is supported by ORD but this plugin cannot generate its resource definitions yet.`,
-            );
-            return [];
-        }
-    }
-
-    // 3. Try to resolve from CAP endpoints
     const capEndpoints = _getCapEndpoints(serviceName, srvDefinition);
+    const ordProtocols = [];
     for (const endpoint of capEndpoints) {
         if (PLUGIN_UNSUPPORTED_PROTOCOLS.includes(endpoint.kind)) {
             Logger.warn(
@@ -100,22 +74,52 @@ function resolveApiResourceProtocol(serviceName, srvDefinition, options = {}) {
 
         const apiProtocol = CAP_TO_ORD_PROTOCOL_MAP[endpoint.kind] ?? endpoint.kind;
         if (apiProtocol) {
-            return [
-                {
-                    apiProtocol,
-                    entryPoints: endpoint.path ? [endpoint.path] : [],
-                    hasResourceDefinitions: true,
-                },
-            ];
+            ordProtocols.push({
+                apiProtocol,
+                entryPoints: endpoint.path ? [endpoint.path] : [],
+                hasResourceDefinitions: true,
+            });
         }
     }
 
-    // 4. Handle explicit protocol with no CAP endpoint (Rule A)
-    if (explicit) {
-        Logger.warn(`Unknown protocol '${explicit}' is not supported, skipping service '${serviceName}'.`);
+    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 [

package/lib/templates.js

@@ -1,5 +1,4 @@
 const { hasSAPPolicyLevel } = require("./utils");
-const { isMCPPluginReady } = require("./mcpAdapter");
 const defaults = require("./defaults");
 const _ = require("lodash");
 const {
@@ -9,7 +8,6 @@ const {
     DESCRIPTION_PREFIX,
     ENTITY_RELATIONSHIP_ANNOTATION,
     LEVEL,
-    MCP_CUSTOM_TYPE,
     ORD_EXTENSIONS_PREFIX,
     ORD_ODM_ENTITY_NAME_ANNOTATION,
     ORD_RESOURCE_TYPE,
@@ -21,6 +19,7 @@ const {
     CONTENT_MERGE_KEY,
     CDS_ELEMENT_KIND,
     ORD_API_PROTOCOL,
+    MCP_RESOURCE_DEFINITION_TYPE,
 } = require("./constants");
 const Logger = require("./logger");
 const { ensureAccessStrategies } = require("./access-strategies");
@@ -348,6 +347,22 @@ const createAPIResourceTemplate = (serviceName, serviceDefinition, appConfig, pa
                 resourceDefinitions = [
                     _getResourceDefinition("openapi-v3", "json", ordId, serviceName, "oas3.json", accessStrategies),
                 ];
+            } else if (apiProtocol === ORD_API_PROTOCOL.MCP) {
+                resourceDefinitions = [
+                    _getResourceDefinition(MCP_RESOURCE_DEFINITION_TYPE, "json", ordId, serviceName, "mcp.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 = [
@@ -572,107 +587,6 @@ function _getPackageID(namespace, packageIds, resourceType, visibility = RESOURC
     return packageIds.find((id) => id.includes(`-${resourceType}-`)) || packageIds.find((id) => id.includes(namespace));
 }
 
-/**
- * Helper function to create a single MCP API resource.
- *
- * @param {object} metadata - The MCP metadata object.
- * @param {object} appConfig - The application configuration.
- * @param {Array} packageIds - The available package identifiers.
- * @param {Array} accessStrategies - The array of accessStrategies objects.
- * @returns {Object} An MCP API resource object.
- */
-function createSingleMCPResource(metadata, appConfig, packageIds, accessStrategies) {
-    const visibility = metadata?.visibility || RESOURCE_VISIBILITY.public;
-
-    // Generate ordId based on visibility
-    let resourceId;
-    if (visibility === RESOURCE_VISIBILITY.public) {
-        resourceId = "mcp-server"; // Default public resource
-    } else {
-        resourceId = `mcp-server-${visibility}`; // mcp-server-internal, mcp-server-private
-    }
-
-    const ordId = `${appConfig.ordNamespace}:apiResource:${resourceId}:v1`;
-
-    // Use metadata with proper fallbacks
-    const title = metadata?.title || `MCP Server for ${appConfig.appName}`;
-    const shortDescription =
-        metadata?.shortDescription || `This is the MCP server to interact with the ${appConfig.appName}`;
-    const description = metadata?.description || `This is the MCP server to interact with the ${appConfig.appName}`;
-    const version = metadata?.version || "1.0.0";
-
-    // Handle entryPoints: convert string to array, with fallback
-    const entryPoints = metadata?.entryPoints ? metadata.entryPoints : ["/rest/mcp/streaming"];
-
-    const packageId = _getPackageID(appConfig.ordNamespace, packageIds, ORD_RESOURCE_TYPE.api, visibility);
-    // Fallback: ensure partOfPackage never undefined to satisfy generic apiResources tests
-    const effectivePackageId = packageId || `${appConfig.ordNamespace}:package:${visibility}:v1`;
-
-    return {
-        ordId,
-        title,
-        shortDescription,
-        description,
-        version,
-        lastUpdate: appConfig.lastUpdate,
-        visibility,
-        partOfPackage: effectivePackageId,
-        releaseStatus: "active",
-        apiProtocol: "mcp",
-        resourceDefinitions: [
-            {
-                type: "custom",
-                customType: MCP_CUSTOM_TYPE,
-                mediaType: "application/json",
-                url: `/ord/v1/${ordId}/mcp-server-definition.mcp.json`,
-                accessStrategies,
-            },
-        ],
-        entryPoints,
-        extensible: { supported: "no" },
-    };
-}
-
-/**
- * This is a template function to create MCP API Resource object(s).
- *
- * The generated MCP API resource(s) can be customized via the generic overwrite mechanism
- * using custom.ord.json. Properties like visibility, title, version, entryPoints, etc.
- * can be overridden by matching the ordId pattern.
- *
- * Metadata values are sourced from the MCP plugin's generateORDMetadata function when available,
- * which reads from cds.env.mcp configuration. This allows users to customize MCP metadata via
- * package.json or .cdsrc.json files.
- *
- * @param {object} appConfig - The application configuration.
- * @param {Array} packageIds - The available package identifiers.
- * @param {Array} accessStrategies The array of accessStrategies objects
- * @returns {Object|Array} An MCP API resource object or array of objects.
- */
-const createMCPAPIResourceTemplate = (appConfig, packageIds, accessStrategies) => {
-    // Get ORD metadata from MCP plugin if available
-    let ordMetadata = null;
-    // Use comprehensive check for MCP plugin readiness
-    const shouldAddMCP = isMCPPluginReady();
-    if (shouldAddMCP) {
-        try {
-            const { generateORDMetadata } = require("@btp-ai/mcp-plugin/lib/utils/metadata");
-            ordMetadata = generateORDMetadata();
-        } catch (error) {
-            Logger.warn("Failed to generate MCP ORD metadata:", error.message);
-        }
-    }
-
-    // Handle both array and single object responses from MCP plugin
-    if (Array.isArray(ordMetadata)) {
-        return ordMetadata.map((metadata) =>
-            createSingleMCPResource(metadata, appConfig, packageIds, accessStrategies),
-        );
-    } else {
-        return createSingleMCPResource(ordMetadata || {}, appConfig, packageIds, accessStrategies);
-    }
-};
-
 function _propagateORDVisibility(model) {
     for (const [name, def] of Object.entries(model.definitions)) {
         if (def.kind === CDS_ELEMENT_KIND.service && def[ORD_EXTENSIONS_PREFIX + "visibility"]) {
@@ -698,7 +612,7 @@ module.exports = {
     createGroupsTemplateForService,
     createAPIResourceTemplate,
     createEventResourceTemplate,
-    createMCPAPIResourceTemplate,
+    readORDExtensions,
     _getPackageID,
     _getEntityTypeMappings,
     _getExposedEntityTypes,

package/lib/threads/compile.js

@@ -0,0 +1,10 @@
+const { workerData } = require("piscina");
+
+const compileMetadata = require("../metaData");
+
+module.exports = ({ url }) => {
+    // JSON round-trip: CDS compiler output may contain Generator objects
+    // that cannot be transferred via postMessage (structured clone algorithm).
+    return compileMetadata(url, workerData.model) //
+        .then(({ response }) => JSON.parse(JSON.stringify(response)));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cap-js/ord",
-    "version": "1.4.4",
+    "version": "1.5.0",
     "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"
@@ -44,13 +45,14 @@
         "@cap-js/openapi": "^1.2.1",
         "bcryptjs": "3.0.3",
         "cli-progress": "^3.12.0",
-        "lodash": "^4.17.21"
+        "lodash": "^4.17.21",
+        "piscina": "^5.1.4"
     },
     "engines": {
         "node": ">=18 <23"
     },
     "overrides": {
-        "@sap/cds-compiler": "6.6.2"
+        "@sap/cds-compiler": "6.7.3"
     },
     "cds": {
         "requires": {

package/lib/mcpAdapter.js

@@ -1,132 +0,0 @@
-const Logger = require("./logger");
-const cds = require("@sap/cds");
-const path = require("path");
-
-/**
- * MCP Plugin Adapter
- * Provides an abstraction layer for interacting with @btp-ai/mcp-plugin
- * This allows for easy mocking and testing without requiring the actual plugin
- */
-
-/**
- * Load package.json from project root
- * @returns {Object} Package.json content
- * @throws {Error} If package.json is not found
- */
-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`);
-    }
-    return require(packageJsonPath);
-}
-
-/**
- * Check if MCP plugin is listed in package.json dependencies
- * @param {Function} loadPackageJsonFn - Optional function to load package.json (for testing)
- * @returns {boolean} True if plugin is in dependencies or devDependencies
- */
-function isMCPPluginInPackageJson(loadPackageJsonFn = _loadPackageJson) {
-    try {
-        const packageJson = loadPackageJsonFn();
-        const allDependencies = {
-            ...(packageJson.dependencies || {}),
-            ...(packageJson.devDependencies || {}),
-        };
-        const isInstalled = "@btp-ai/mcp-plugin" in allDependencies;
-        if (isInstalled) {
-            Logger.log("MCP plugin found in package.json dependencies");
-        }
-        return isInstalled;
-    } catch (error) {
-        Logger.error("Could not check package.json for MCP plugin:", error.message);
-        return false;
-    }
-}
-
-/**
- * Check if MCP plugin is available at runtime
- * @param {Function} resolveFunction - Optional custom resolve function for testing
- * @returns {boolean} True if plugin is available
- */
-function isMCPPluginAvailable(resolveFunction = require.resolve) {
-    try {
-        resolveFunction("@btp-ai/mcp-plugin");
-        Logger.log("MCP plugin is available at runtime");
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Get MCP plugin instance
- * Returns null if plugin is not available
- * @returns {Object|null} MCP plugin module or null
- */
-function getMcpPlugin() {
-    if (!isMCPPluginAvailable()) {
-        return null;
-    }
-
-    try {
-        return require("@btp-ai/mcp-plugin");
-    } catch (error) {
-        Logger.error("Failed to load MCP plugin:", error.message);
-        return null;
-    }
-}
-
-/**
- * Check if MCP plugin is ready for use (both installed and available)
- * This function combines the logic of both isMCPPluginInPackageJson and isMCPPluginAvailable
- * to provide a comprehensive check for MCP plugin readiness.
- * Maintains the original AND logic: both conditions must be true.
- *
- * @param {Object} options - Options for checking
- * @param {Function} options.resolveFunction - Custom resolve function for testing
- * @param {Function} options.loadPackageJsonFn - Custom package.json loader for testing
- * @returns {boolean} True if plugin is ready for use
- */
-function isMCPPluginReady(options = {}) {
-    const { resolveFunction, loadPackageJsonFn } = options;
-
-    // Both conditions must be satisfied: declared in package.json AND available at runtime
-    return isMCPPluginInPackageJson(loadPackageJsonFn) && isMCPPluginAvailable(resolveFunction);
-}
-
-/**
- * Build MCP server definition
- * @param {Array} services - Array of CDS services
- * @returns {Promise<Object>} MCP server definition
- * @throws {Error} If MCP plugin is not available
- */
-async function buildMcpServerDefinition(services = []) {
-    const plugin = getMcpPlugin();
-
-    if (!plugin) {
-        throw new Error("MCP plugin not available");
-    }
-
-    // Validate services parameter
-    if (!Array.isArray(services)) {
-        throw new Error("Services parameter must be an array");
-    }
-
-    try {
-        const { exposeMcpServerDefinitionForOrd } = require("@btp-ai/mcp-plugin/lib/utils/metadata");
-        return await exposeMcpServerDefinitionForOrd(services);
-    } catch (error) {
-        Logger.error("Failed to build MCP server definition:", error.message);
-        throw error;
-    }
-}
-
-module.exports = {
-    isMCPPluginAvailable,
-    isMCPPluginInPackageJson,
-    isMCPPluginReady,
-    getMcpPlugin,
-    buildMcpServerDefinition,
-    _loadPackageJson, // Export for testing
-};