@cap-js/ord 1.5.0 → 1.7.0

package/cds-plugin.js

@@ -4,17 +4,7 @@ if (cds.cli.command === "build") {
     cds.build?.register?.("ord", require("./lib/build"));
 }
 
-function _lazyRegisterCompileTarget() {
-    const ord = require("./lib/index").ord;
-    Object.defineProperty(this, "ord", { ord });
-    return ord;
-}
-
-const registerORDCompileTarget = () => {
-    Object.defineProperty(cds.compile.to, "ord", {
-        get: _lazyRegisterCompileTarget,
-        configurable: true,
-    });
-};
-
-registerORDCompileTarget();
+Object.defineProperty(cds.compile.to, "ord", {
+    configurable: true,
+    get: () => (model) => require("./lib/index").ord(model, []),
+});

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

@@ -5,7 +5,7 @@
  * from external configuration endpoints and merge with static configuration.
  */
 
-/* global AbortController */
+/* global AbortController */ // eslint-disable-line no-redeclare
 
 const { HTTP_CONFIG } = require("../constants");
 

package/lib/build.js

@@ -1,12 +1,14 @@
+const os = require("os");
 const path = require("path");
 const cds = require("@sap/cds");
 const _ = require("lodash");
 const Piscina = require("piscina");
 const cliProgress = require("cli-progress");
 
-const os = require("os");
+const defaults = require("./defaults.js");
 const { ord } = require("./index");
-const { BUILD_DEFAULT_PATH, ORD_DOCUMENT_FILE_NAME } = require("./constants");
+const registerCompileTargets = require("./common/register-compile-targets");
+const { BUILD_DEFAULT_PATH, ORD_DOCUMENT_FILE_NAME, DOCUMENT_PERSPECTIVES } = require("./constants");
 
 module.exports = class OrdBuildPlugin extends cds.build.Plugin {
     static taskDefaults = { src: cds.env.folders.srv };
@@ -16,13 +18,7 @@ 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 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();
-        }
+        registerCompileTargets();
 
         return this.model()
             .then((model) => ({ model, document: ord(model) }))
@@ -58,7 +54,7 @@ module.exports = class OrdBuildPlugin extends cds.build.Plugin {
                 resourceDefinition.url = this._createRelativePath(resourceDefinition.url);
             });
 
-        return clone;
+        return defaults.adjustForPerspective(clone, DOCUMENT_PERSPECTIVES.SystemVersion);
     }
 
     _createRelativePath(url) {

package/lib/common/register-compile-targets.js

@@ -0,0 +1,31 @@
+const cds = require("@sap/cds");
+const Logger = require("../logger");
+
+const PROTOCOL_PROVIDERS = Object.freeze({
+    ["@cap-js/mcp"]: "mcp",
+    ["@cap-js/graphql"]: "graphql",
+});
+
+module.exports = () => {
+    // Plugins like @cap-js/mcp and @cap-js/graphql register protocols and compile targets
+    // at runtime via cds-plugin.js, but cds build rebuilds cds.env afterward, losing both
+    // registrations. Re-apply so that compilation works accordingly during build and runtime.
+
+    Object.keys(cds.env.plugins || {})
+        .filter((plugin) => !!PROTOCOL_PROVIDERS[plugin])
+        .forEach((plugin) => {
+            try {
+                const protocol = PROTOCOL_PROVIDERS[plugin];
+
+                require(`${plugin}/lib/api`)?.registerCompileTargets?.();
+                cds.env.protocols = {
+                    ...cds.env.protocols,
+                    ...(!protocol || cds.env.protocols?.[protocol]
+                        ? {}
+                        : { [protocol]: { path: `/${protocol}`, impl: plugin } }),
+                };
+            } catch (error) {
+                Logger.warn(`Failed to register compile targets for ${plugin}: ${error}`);
+            }
+        });
+};

package/lib/configuration.js

@@ -0,0 +1,161 @@
+const path = require("path");
+const cds = require("@sap/cds");
+const _ = require("lodash");
+const { readFileSync } = require("fs");
+
+const Logger = require("./logger");
+const { getRFC3339Date } = require("./date");
+const defaults = require("./defaults");
+const { createEntityTypeMappingsItemTemplate } = require("./templates");
+const { CONTENT_MERGE_KEY, CDS_ELEMENT_KIND } = require("./constants");
+
+module.exports = class Configuration {
+    constructor(csn) {
+        const env = cds.env["ord"];
+        const packageName = this._loadNameFromPackageJson();
+        const eventApplicationNamespace = cds.env?.export?.asyncapi?.applicationNamespace;
+        const ordNamespace = cds.env["ord"]?.namespace || `customer.${packageName.replace(/[^a-zA-Z0-9]/g, "")}`;
+        const internalNamespace = env?.internalNamespace;
+
+        if (eventApplicationNamespace && ordNamespace !== eventApplicationNamespace) {
+            Logger.warn("ORD and AsyncAPI namespaces should be the same.");
+        }
+
+        this._env = env;
+        this._packageName = packageName;
+        this._ordNamespace = ordNamespace;
+        this._internalNamespace = internalNamespace;
+        this._lastUpdate = getRFC3339Date();
+        this._serviceNames = this._resolveServiceNames(csn);
+        this._existingProductORDId = env?.existingProductORDId;
+        this._apiResourceNames = this._resolveApiResourceNames(csn);
+        this._entityTypeTargets = this._resolveEntityTypeTargets(csn);
+        this._eventServiceNames = this._resolveEventServiceNames(csn);
+        this._appName = packageName.replace(/^@/, "").replace(/[@/]/g, "-");
+        this._policyLevels = env?.policyLevels || (env?.policyLevel && [env?.policyLevel]) || defaults.policyLevels;
+    }
+
+    get env() {
+        return this._env;
+    }
+
+    get appName() {
+        return this._appName;
+    }
+
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+
+    get packageName() {
+        return this._packageName;
+    }
+
+    get serviceNames() {
+        return this._serviceNames;
+    }
+
+    get ordNamespace() {
+        return this._ordNamespace;
+    }
+
+    get internalNamespace() {
+        return this._internalNamespace;
+    }
+
+    get policyLevels() {
+        return this._policyLevels;
+    }
+
+    get apiResourceNames() {
+        return this._apiResourceNames;
+    }
+
+    get entityTypeTargets() {
+        return this._entityTypeTargets;
+    }
+
+    get eventServiceNames() {
+        return this._eventServiceNames;
+    }
+
+    get hasSAPPolicyLevel() {
+        return this.policyLevels.some((policyLevel) => policyLevel.split(":")[0].toLowerCase() === "sap");
+    }
+
+    get existingProductORDId() {
+        return this._existingProductORDId;
+    }
+
+    _resolveServiceNames(csn) {
+        return Object.keys(csn.definitions) //
+            .filter((name) => this._isValidService(name, csn.definitions[name]));
+    }
+
+    _loadNameFromPackageJson() {
+        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 JSON.parse(readFileSync(packageJsonPath, "utf-8")).name;
+    }
+
+    _isBlockedServiceName(name) {
+        return ["cds.xt.MTXServices", "MtxOrdProviderService", "OpenResourceDiscoveryService"] //
+            .some((blocked) => name.includes(blocked));
+    }
+
+    _resolveApiResourceNames(csn) {
+        return Object.keys(csn.definitions)
+            .filter((name) => this._isValidService(name, csn.definitions[name]))
+            .filter((name) => !this._serviceOnlyContainsEvents(csn.definitions[name]));
+    }
+
+    _resolveEntityTypeTargets(csn) {
+        return _.uniqBy(
+            Object.keys(csn.definitions)
+                .filter((name) => !name.includes(".texts"))
+                .filter((name) => !this._isBlockedServiceName(name))
+                .filter((name) => csn.definitions[name].kind === CDS_ELEMENT_KIND.entity)
+                .filter((name) => csn.definitions[name]["_service"]?.["@protocol"] !== "none")
+                .flatMap((name) => createEntityTypeMappingsItemTemplate(csn.definitions[name]) || []),
+            CONTENT_MERGE_KEY,
+        );
+    }
+
+    _resolveEventServiceNames(csn) {
+        const serviceNames = this._resolveServiceNames(csn);
+
+        return [
+            ...new Set(
+                Object.keys(csn.definitions)
+                    .filter((name) => !this._isBlockedServiceName(name))
+                    .filter((name) => csn.definitions[name].kind === CDS_ELEMENT_KIND.event)
+                    .filter((name) => csn.definitions[name]["_service"]?.["@protocol"] !== "none")
+                    .filter((name) => serviceNames.some((serviceName) => name.startsWith(`${serviceName}.`)))
+                    .map((name) => serviceNames.find((serviceName) => name.startsWith(`${serviceName}.`))),
+            ),
+        ];
+    }
+
+    _isValidService(key, definition) {
+        const isExternalService = Object.keys(cds).includes("requires") && Object.keys(cds.requires).includes(key);
+
+        return (
+            definition.kind === CDS_ELEMENT_KIND.service &&
+            !definition["@cds.external"] &&
+            definition["@protocol"] !== "none" &&
+            !isExternalService &&
+            !this._isBlockedServiceName(key)
+        );
+    }
+
+    _serviceOnlyContainsEvents(definition) {
+        return (
+            Object.keys(definition.events || {}).length > 0 &&
+            ["actions", "entities", "functions"].every((key) => Object.keys(definition[key] || {}).length === 0)
+        );
+    }
+};

package/lib/constants.js

@@ -8,11 +8,6 @@ const BASIC_AUTH_HEADER_KEY = "authorization";
 
 const BUILD_DEFAULT_PATH = "gen/ord";
 
-const BLOCKED_SERVICE_NAME = Object.freeze({
-    MTXServices: "cds.xt.MTXServices",
-    OpenResourceDiscoveryService: "OpenResourceDiscoveryService",
-});
-
 const ORD_ACCESS_STRATEGY = Object.freeze({
     Open: "open",
     Basic: "basic-auth",
@@ -76,8 +71,6 @@ const LEVEL = Object.freeze({
     subEntity: "sub-entity",
 });
 
-const OPEN_RESOURCE_DISCOVERY_VERSION = "1.12";
-
 const OPENAPI_SERVERS_ANNOTATION = "@OpenAPI.servers";
 
 const ORD_EXTENSIONS_PREFIX = "@ORD.Extensions.";
@@ -89,8 +82,9 @@ const ORD_EXISTING_PRODUCT_PROPERTY = "existingProductORDId";
 const ORD_RESOURCE_TYPE = Object.freeze({
     api: "api",
     event: "event",
-    integrationDependency: "integrationDependency",
     entityType: "entityType",
+    dataProduct: "dataProduct",
+    integrationDependency: "integrationDependency",
 });
 
 const ORD_SERVICE_NAME = "OpenResourceDiscoveryService";
@@ -181,12 +175,18 @@ const AUTH_STRINGS = Object.freeze({
     WWW_AUTHENTICATE_REALM: 'Basic realm="401"',
 });
 
+const DOCUMENT_PERSPECTIVES = Object.freeze({
+    SystemVersion: "system-version",
+    SystemInstance: "system-instance",
+});
+
+const LOCAL_TENANT_ID_HEADER_KEY = "local-tenant-id";
+
 module.exports = {
     AUTHENTICATION_TYPE,
     AUTH_TYPE_ORD_ACCESS_STRATEGY_MAP,
     BASIC_AUTH_HEADER_KEY,
     BUILD_DEFAULT_PATH,
-    BLOCKED_SERVICE_NAME,
     CAP_TO_ORD_PROTOCOL_MAP,
     CDS_ELEMENT_KIND,
     CF_MTLS_HEADERS,
@@ -202,7 +202,6 @@ module.exports = {
     INTEGRATION_DEPENDENCY_RESOURCE_NAME,
     LEVEL,
     MCP_RESOURCE_DEFINITION_TYPE,
-    OPEN_RESOURCE_DISCOVERY_VERSION,
     OPENAPI_SERVERS_ANNOTATION,
     ORD_ACCESS_STRATEGY,
     ORD_API_PROTOCOL,
@@ -223,4 +222,6 @@ module.exports = {
     CF_MTLS_ERROR_REASON,
     HTTP_CONFIG,
     AUTH_STRINGS,
+    DOCUMENT_PERSPECTIVES,
+    LOCAL_TENANT_ID_HEADER_KEY,
 };

package/lib/defaults.js

@@ -1,15 +1,15 @@
-const { OPEN_RESOURCE_DISCOVERY_VERSION, SHORT_DESCRIPTION_PREFIX, RESOURCE_VISIBILITY } = require("./constants");
-const { hasSAPPolicyLevel } = require("./utils");
+const fs = require("fs");
 const _ = require("lodash");
+const cds = require("@sap/cds");
+const { join } = require("path");
 
-const packageTypes = [
-    { tag: "-api", type: "APIs" },
-    { tag: "-event", type: "Events" },
-    { tag: "-consumptionBundle", type: "Consumption Bundles" },
-    { tag: "-integrationDependency", type: "Integration Dependencies" },
-    { tag: "-entityType", type: "Entity Types" },
-    { tag: "-dataProduct", type: "Data Products" },
-];
+const {
+    ORD_RESOURCE_TYPE,
+    SHORT_DESCRIPTION_PREFIX,
+    RESOURCE_VISIBILITY,
+    DOCUMENT_PERSPECTIVES,
+    CONTENT_MERGE_KEY,
+} = require("./constants");
 
 const stringTypeCheck = (value) => typeof value === "string";
 const arrayTypeCheck = (value) => Array.isArray(value);
@@ -77,8 +77,9 @@ const mapEnvPackageInfo = (packageConfig) => {
  */
 module.exports = {
     $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
-    openResourceDiscovery: OPEN_RESOURCE_DISCOVERY_VERSION,
+    openResourceDiscovery: "1.14",
     policyLevels: ["none"],
+    groupTypeId: "sap.cds:service",
     description: "this is an application description",
     products: (name) => [
         {
@@ -88,40 +89,38 @@ module.exports = {
             vendor: "customer:vendor:Customer:",
         },
     ],
-    groupTypeId: "sap.cds:service",
-    packages: function getPackageData(appConfig) {
+    packages: (appConfig, products) => {
         const name = appConfig.appName;
         const ordNamespace = appConfig.ordNamespace;
-        const productsOrdId = appConfig.existingProductORDId || appConfig.products?.[0]?.ordId;
+        const productsOrdId = appConfig.existingProductORDId || products?.[0]?.ordId;
         const { vendor, ...envValues } = mapEnvPackageInfo(appConfig?.env?.packages?.[0]);
-        if (hasSAPPolicyLevel(appConfig.policyLevels)) {
-            return _.uniqBy(
-                packageTypes.flatMap(({ tag, type }) =>
-                    Object.values(RESOURCE_VISIBILITY).map((visibility) => ({
-                        ordId: generateUniquePackageOrdId(ordNamespace, name, tag, visibility),
-                        title: nameWithSpaces(name),
-                        ...generatePackageDescriptions(name, type, visibility),
-                        version: "1.0.0",
-                        ...(productsOrdId && { partOfProducts: [productsOrdId || defaultProductOrdId(name)] }),
-                        vendor: vendor || "customer:vendor:Customer:",
-                        ...envValues,
-                    })),
-                ),
-                "ordId",
-            );
-        } else {
-            return [
-                {
-                    ordId: generateUniquePackageOrdId(ordNamespace, name, "", RESOURCE_VISIBILITY.public),
+        const visibilities = !appConfig.hasSAPPolicyLevel
+            ? [RESOURCE_VISIBILITY.public]
+            : Object.values(RESOURCE_VISIBILITY);
+        const packageTypes = !appConfig.hasSAPPolicyLevel
+            ? [{ tag: "", type: "General" }]
+            : [
+                  { tag: `-${ORD_RESOURCE_TYPE.api}`, type: "APIs" },
+                  { tag: `-${ORD_RESOURCE_TYPE.event}`, type: "Events" },
+                  { tag: `-${ORD_RESOURCE_TYPE.entityType}`, type: "Entity Types" },
+                  { tag: `-${ORD_RESOURCE_TYPE.dataProduct}`, type: "Data Products" },
+                  { tag: `-${ORD_RESOURCE_TYPE.integrationDependency}`, type: "Integration Dependencies" },
+              ];
+
+        return _.uniqBy(
+            packageTypes.flatMap(({ tag, type }) =>
+                visibilities.map((visibility) => ({
+                    ordId: generateUniquePackageOrdId(ordNamespace, name, tag, visibility),
                     title: nameWithSpaces(name),
-                    ...generatePackageDescriptions(name, "General", RESOURCE_VISIBILITY.public),
+                    ...generatePackageDescriptions(name, type, visibility),
                     version: "1.0.0",
                     ...(productsOrdId && { partOfProducts: [productsOrdId || defaultProductOrdId(name)] }),
                     vendor: vendor || "customer:vendor:Customer:",
                     ...envValues,
-                },
-            ];
-        }
+                })),
+            ),
+            CONTENT_MERGE_KEY,
+        );
     },
     consumptionBundles: (appConfig) => [
         {
@@ -134,23 +133,55 @@ module.exports = {
                 "This Consumption Bundle contains all resources of the reference app which are unprotected and do not require authentication",
         },
     ],
-
-    apiResources: [],
-    eventResources: [],
-    entityTypes: [],
-    baseTemplate: (authConfig) => {
+    baseTemplate: (authConfig, tenant) => {
         // Get access strategies from the provided authConfig
         // If auth config is not available, fall back to empty array
+        const toggles = cds.env.requires.toggles;
+        const extensibility = cds.env.requires.extensibility;
         const accessStrategies = authConfig?.accessStrategies || [];
+
         return {
             openResourceDiscoveryV1: {
                 documents: [
                     {
                         url: "/ord/v1/documents/ord-document",
+                        perspective: DOCUMENT_PERSPECTIVES.SystemVersion,
                         accessStrategies,
                     },
+                    ...(!tenant || !(toggles || extensibility)
+                        ? []
+                        : [
+                              {
+                                  url: `/ord/v1/documents/ord-document?perspective=${encodeURIComponent(DOCUMENT_PERSPECTIVES.SystemInstance)}`,
+                                  perspective: DOCUMENT_PERSPECTIVES.SystemInstance,
+                                  accessStrategies,
+                              },
+                          ]),
                 ],
             },
         };
     },
+    adjustForPerspective: (document, perspective) => {
+        document.perspective = perspective;
+
+        if (perspective === DOCUMENT_PERSPECTIVES.SystemVersion) {
+            document.describedSystemVersion = cds.env["ord"]?.describedSystemVersion ?? {
+                version: JSON.parse(fs.readFileSync(join(cds.root, "package.json"), "utf-8")).version,
+            };
+        } else if (perspective === DOCUMENT_PERSPECTIVES.SystemInstance) {
+            (document.apiResources || []).forEach((apiResource) => {
+                (apiResource.resourceDefinitions || []).forEach((apiResourceDefinition) => {
+                    apiResourceDefinition.url += `?perspective=${encodeURIComponent(perspective)}`;
+                });
+            });
+
+            (document.eventResources || []).forEach((eventResource) => {
+                (eventResource.resourceDefinitions || []).forEach((eventResourceDefinition) => {
+                    eventResourceDefinition.url += `?perspective=${encodeURIComponent(perspective)}`;
+                });
+            });
+        }
+
+        return document;
+    },
 };

package/lib/{extendOrdWithCustom.js → extend-ord-with-custom.js}

@@ -62,13 +62,7 @@ function getCustomORDContent(appConfig) {
     return require(pathToCustomORDContent);
 }
 
-function extendCustomORDContentIfExists(appConfig, ordContent) {
-    const customORDContent = getCustomORDContent(appConfig);
-    return customORDContent
-        ? compareAndHandleCustomORDContentWithExistingContent(ordContent, customORDContent)
-        : ordContent;
-}
-
 module.exports = {
-    extendCustomORDContentIfExists,
+    getCustomORDContent,
+    compareAndHandleCustomORDContentWithExistingContent,
 };

package/lib/index.js

@@ -7,5 +7,5 @@
  */
 module.exports = {
     ord: require("./ord.js"),
-    getMetadata: require("./metaData.js"),
+    getMetadata: require("./meta-data.js"),
 };

package/lib/{integrationDependency.js → integration-dependency.js}

@@ -122,6 +122,4 @@ module.exports = {
     // Exported for testing
     collectExternalServices,
     createIntegrationDependency,
-    parseDataProductOrdId,
-    isExternalDataProduct,
 };

package/lib/{interopCsn.js → interop-csn.js}

@@ -54,7 +54,7 @@ function add_i18n_texts(csn) {
             if (n.startsWith("@")) {
                 let annoVal = o[n];
                 if (typeof annoVal === "string" && annoVal.startsWith("{i18n>")) {
-                    let [, x] = annoVal.match(/^\{i18n>(.*)\}$/) || [];
+                    let [, x] = annoVal.match(/^\{i18n>(.*)}$/) || [];
                     if (x) keys.add(x);
                 }
             }
@@ -73,7 +73,7 @@ function remove_localized_assoc(csn) {
     // - name is "localized"
     // - type is "cds.Association"
     // - target name is source name + ".texts"
-    // - there is an ON condition 
+    // - there is an ON condition
     for (let n1 in csn.definitions) {
         let def = csn.definitions[n1];
         if (def.kind === "entity")
@@ -141,7 +141,7 @@ function add_meta_info(csn) {
     for (let k in csn.meta) {
         if (!["flavor", "document", "features"].includes(k) && !k.startsWith("__")) {
             delete csn.meta[k];
-        } 
+        }
     }
     csn.meta.flavor = "effective";
 
@@ -165,5 +165,5 @@ function add_meta_info(csn) {
 }
 
 module.exports = {
-    interopCSN,
+    interopCSN
 };

package/lib/meta-data.js

@@ -0,0 +1,90 @@
+const path = require("path");
+const cds = require("@sap/cds/lib");
+const assert = require("node:assert");
+const cdsc = require("@sap/cds-compiler/lib/main");
+const { compile: openapi } = require("@cap-js/openapi");
+const { compile: asyncapi } = require("@cap-js/asyncapi");
+
+const Logger = require("./logger");
+const { interopCSN } = require("./interop-csn.js");
+const { COMPILER_TYPES, OPENAPI_SERVERS_ANNOTATION } = require("./constants");
+
+function extractServiceName(url) {
+    return path.basename(url, ".json").split(".").slice(0, -1).join(".");
+}
+
+function extractCompilerType(url) {
+    return path.basename(url, ".json").split(".").pop();
+}
+
+const compilers = Object.freeze({
+    [COMPILER_TYPES.csn]: function (csn, options) {
+        return {
+            contentType: "application/json",
+            response: interopCSN(
+                cdsc.for.effective(csn, { beta: { effectiveCsn: true }, effectiveServiceName: options.service }),
+            ),
+        };
+    },
+    [COMPILER_TYPES.mcp]: async function (csn, options) {
+        return {
+            contentType: "application/json",
+            response: cds.compile(csn).to["mcp"]({ ...options, ...(cds.env.ord?.compileOptions?.mcp || {}) }),
+        };
+    },
+    [COMPILER_TYPES.oas3]: function (csn, options) {
+        // Check for service-level @OpenAPI.servers annotation
+        const servers = csn?.definitions?.[options.service]?.[OPENAPI_SERVERS_ANNOTATION];
+        const openapiOptions = { ...options, ...(cds.env?.ord?.compileOptions?.openapi || {}) };
+
+        // Service-level annotation takes precedence over global config
+        if (Array.isArray(servers) && servers.length) {
+            openapiOptions["openapi:servers"] = JSON.stringify(servers);
+        }
+
+        return {
+            contentType: "application/json",
+            response: openapi(csn, openapiOptions),
+        };
+    },
+    [COMPILER_TYPES.edmx]: function (csn, options) {
+        return {
+            contentType: "application/xml",
+            response: cds
+                .compile(csn)
+                .to["edmx"]({ ...options, ...(cds.env?.ord?.compileOptions?.edmx || {}) }),
+        };
+    },
+    [COMPILER_TYPES.graphql]: function (csn, options) {
+        const { generateSchema4 } = require("@cap-js/graphql/lib/schema");
+        const { printSchema, lexicographicSortSchema } = require("graphql");
+        const srv = new cds.ApplicationService(options.service, cds.linked(csn));
+
+        return {
+            contentType: "text/plain",
+            response: printSchema(lexicographicSortSchema(generateSchema4({ [options.service]: srv }))),
+        };
+    },
+    [COMPILER_TYPES.asyncapi2]: function (csn, options) {
+        return {
+            contentType: "application/json",
+            response: asyncapi(csn, { ...options, ...(cds.env?.ord?.compileOptions?.asyncapi || {}) }),
+        };
+    },
+});
+
+module.exports = async (url, model = null) => {
+    const name = extractServiceName(url);
+    const type = extractCompilerType(url);
+    const csn = model || cds.services[name]?.model;
+    const options = { service: name, as: "str", messages: [] };
+
+    assert(Object.hasOwn(compilers, type), `Unsupported format: ${type}`);
+
+    try {
+        return await compilers[type](csn, options);
+    } catch(error) {
+        Logger.error(`Compilation failed for service ${name} (compiler: ${type}) - ${error.message}`);
+        throw error;
+    }
+};