@cap-js/ord 1.8.0 → 1.9.1

package/lib/interop-csn.js

@@ -1,3 +1,4 @@
+const assert = require("node:assert");
 const localize = require("@sap/cds/lib/i18n/localize");
 
 // turn effective CSN into interop CSN
@@ -20,7 +21,7 @@ function add_i18n_texts(csn) {
     // get all texts of the app
     const i18n = [...(localize.bundles4(csn) || [])]
         .filter(([locale]) => !!locale)
-        .map(([locale, value]) => [locale.replaceAll('_', '-'), value])  // CSN interop uses '-' as separator
+        .map(([locale, value]) => [locale.replaceAll("_", "-"), value]) // CSN interop uses '-' as separator
         .reduce((all, [locale, value]) => ({ ...all, [locale]: value }), {});
 
     // get all i18n keys referenced in the csn
@@ -119,9 +120,9 @@ function map_annotations(csn) {
         }
 
         // delete all @assert.unique annotations
-        let assertUniqueAnnos = Object.keys(o).filter(x => x.startsWith('@assert.unique'))
+        let assertUniqueAnnos = Object.keys(o).filter((x) => x.startsWith("@assert.unique"));
         for (let a of assertUniqueAnnos) {
-            delete o[a]
+            delete o[a];
         }
     }
 }
@@ -132,7 +133,7 @@ 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 ??= {};  // ensure there is a meta section
+    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 "__")
@@ -143,27 +144,38 @@ function add_meta_info(csn) {
             delete csn.meta[k];
         }
     }
+
     csn.meta.flavor = "effective";
 
-    let services = Object.entries(csn.definitions).filter(([, def]) => def.kind === "service");
+    const services = Object.entries(csn.definitions).filter(([, def]) => def.kind === "service");
     if (services.length === 1) {
+        const [name, definition] = services[0];
         // assumption: "short" service name contains no dots
-        let segments = services[0][0].split(".");
+        const segments = name.split(".");
+
         let v = "1";
         let srv = segments.pop();
-        let m = srv.match(/^v(\d+)$/);
+        const m = srv.match(/^v(\d+)$/);
         if (m) {
             srv = segments.pop();
             v = m[1];
         }
-        csn.meta.document = { version: `${v}.0.0` };
-        csn.meta.__name = srv;
-        if (segments.length > 0) csn.meta.__namespace = segments.join(".");
+
+        assert(
+            !definition["@ORD.Extensions.version"] || v === definition["@ORD.Extensions.version"].split(".").shift(),
+            `Major version in service name (${v}) does not match major version in @ORD.Extensions.version (${definition["@ORD.Extensions.version"]})`,
+        );
+
+        Object.assign(csn.meta, {
+            __name: srv,
+            document: { version: definition["@ORD.Extensions.version"] ?? `${v}.0.0` },
+            ...(segments.length > 0 && { __namespace: segments.join(".") }),
+        });
     }
 
     return csn;
 }
 
 module.exports = {
-    interopCSN
+    interopCSN,
 };

package/lib/logger.js

@@ -1,8 +1,6 @@
 const cds = require("@sap/cds");
 
 // Unified INFO-level logging - simple and consistent across all environments
-const Logger = cds.log("ord-plugin", {
+module.exports = cds.log("ord-plugin", {
     level: cds.log?.levels?.INFO,
 });
-
-module.exports = Logger;

package/lib/meta-data.js

@@ -7,18 +7,10 @@ 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");
+const { 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) {
+const COMPILERS = Object.freeze({
+    csn: function (csn, options) {
         return {
             contentType: "application/json",
             response: interopCSN(
@@ -26,13 +18,13 @@ const compilers = Object.freeze({
             ),
         };
     },
-    [COMPILER_TYPES.mcp]: async function (csn, options) {
+    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) {
+    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 || {}) };
@@ -47,15 +39,13 @@ const compilers = Object.freeze({
             response: openapi(csn, openapiOptions),
         };
     },
-    [COMPILER_TYPES.edmx]: function (csn, options) {
+    edmx: function (csn, options) {
         return {
             contentType: "application/xml",
-            response: cds
-                .compile(csn)
-                .to["edmx"]({ ...options, ...(cds.env?.ord?.compileOptions?.edmx || {}) }),
+            response: cds.compile(csn).to["edmx"]({ ...options, ...(cds.env?.ord?.compileOptions?.edmx || {}) }),
         };
     },
-    [COMPILER_TYPES.graphql]: function (csn, options) {
+    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));
@@ -65,7 +55,7 @@ const compilers = Object.freeze({
             response: printSchema(lexicographicSortSchema(generateSchema4({ [options.service]: srv }))),
         };
     },
-    [COMPILER_TYPES.asyncapi2]: function (csn, options) {
+    asyncapi2: function (csn, options) {
         return {
             contentType: "application/json",
             response: asyncapi(csn, { ...options, ...(cds.env?.ord?.compileOptions?.asyncapi || {}) }),
@@ -74,16 +64,14 @@ const compilers = Object.freeze({
 });
 
 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: [] };
+    const type = path.basename(url, ".json").split(".").pop();
+    const name = path.basename(url, ".json").split(".").slice(0, -1).join(".");
 
-    assert(Object.hasOwn(compilers, type), `Unsupported format: ${type}`);
+    assert(Object.hasOwn(COMPILERS, type), `Unsupported format: ${type}`);
 
     try {
-        return await compilers[type](csn, options);
-    } catch(error) {
+        return await COMPILERS[type](model ?? cds.services[name]?.model, { service: name, as: "str", messages: [] });
+    } catch (error) {
         Logger.error(`Compilation failed for service ${name} (compiler: ${type}) - ${error.message}`);
         throw error;
     }

package/lib/ord.js

@@ -1,130 +1,67 @@
-const _ = require("lodash");
-const cds = require("@sap/cds");
-
-const Logger = require("./logger");
 const defaults = require("./defaults");
-const { createAuthConfig } = require("./auth/authentication");
+const utils = require("./common/utils");
 const Configuration = require("./configuration");
-const { getIntegrationDependencies } = require("./integration-dependency");
+const { createGroups } = require("./templates/group");
+const { createPackages } = require("./templates/package");
+const { createProducts } = require("./templates/product");
+const { createEntityTypes } = require("./templates/entity-type");
+const { createAPIResources } = require("./templates/api-resource");
+const { createEventResources } = require("./templates/event-resource");
+const { createIntegrationDependencies } = require("./templates/integration-dependency");
 const {
     getCustomORDContent,
     compareAndHandleCustomORDContentWithExistingContent,
 } = require("./extend-ord-with-custom");
-const {
-    createAPIResourceTemplate,
-    createEntityTypeTemplate,
-    createEventResourceTemplate,
-    createGroupsTemplateForService,
-    _propagateORDVisibility,
-} = require("./templates");
-
-const _getGroups = (csn, appConfig) => {
-    return appConfig.serviceNames
-        .map((name) => csn.definitions[name])
-        .flatMap((srvDefinition) => createGroupsTemplateForService(srvDefinition, appConfig))
-        .filter((resource) => !!resource);
-};
-
-const _getAPIResources = (csn, appConfig, packageIds, accessStrategies) => {
-    return appConfig.apiResourceNames
-        .map((name) => csn.definitions[name])
-        .flatMap((srvDefinition) => createAPIResourceTemplate(srvDefinition, appConfig, packageIds, accessStrategies));
-};
-
-const _getEventResources = (csn, appConfig, packageIds, accessStrategies) => {
-    return appConfig.eventServiceNames
-        .map((name) => csn.definitions[name])
-        .flatMap((srvDefinition) => createEventResourceTemplate(srvDefinition, appConfig, packageIds, accessStrategies));
-};
-
-const _getProducts = (appConfig) => {
-    const productsObj = defaults.products(appConfig.packageName);
-
-    if (appConfig.env?.products) {
-        const customProducts = appConfig.env.products[0];
-        if (customProducts?.ordId?.toLowerCase().startsWith("sap")) {
-            Logger.error(
-                "Detected sap product ordId, which should not be defined for custom products, use default value instead. Please check ord global registry.",
-            );
-        } else {
-            _.assign(productsObj[0], customProducts);
-        }
-    }
-
-    return productsObj;
-};
-
-const _createDefaultORDDocument = (linkedCsn, appConfig, authConfig) => {
-    const products = _getProducts(appConfig);
-    const packages = defaults.packages(appConfig, products);
-    const packageIds = packages?.map((pkg) => pkg.ordId) || [];
-    const entityTypes = _getEntityTypes(appConfig, packageIds);
-    const integrationDependencies = getIntegrationDependencies(linkedCsn, appConfig, packageIds);
-    const apiResources = _getAPIResources(linkedCsn, appConfig, packageIds, authConfig.accessStrategies);
-    const eventResources = _getEventResources(linkedCsn, appConfig, packageIds, authConfig.accessStrategies);
-
-    return {
-        // Unconditionally added top-level properties
-        $schema: "https://open-resource-discovery.github.io/specification/spec-v1/interfaces/Document.schema.json",
-        policyLevels: appConfig.policyLevels,
-        packages: packages,
-        description: appConfig.env?.description || defaults.description,
-        openResourceDiscovery: appConfig.env?.openResourceDiscovery || defaults.openResourceDiscovery,
-
-        // Conditionally added top-level properties
-        ...(!entityTypes.length ? {} : { entityTypes: entityTypes }),
-        ...(!apiResources.length ? {} : { apiResources: apiResources }),
-        ...(!eventResources.length ? {} : { eventResources: eventResources }),
-        ...(appConfig.existingProductORDId ? {} : { products: [products[0]] }),
-        ...(!appConfig.serviceNames.length ? {} : { groups: _getGroups(linkedCsn, appConfig) }),
-        ...(!integrationDependencies.length ? {} : { integrationDependencies: integrationDependencies }),
-        ...(!appConfig.env?.consumptionBundles?.length ? {} : { consumptionBundles: appConfig.env.consumptionBundles }),
-    };
-};
-
-const _filterUnusedPackages = (ordDocument) => {
-    if (!ordDocument.packages?.length) return [];
-
-    const usedPackageIds = new Set();
-
-    ordDocument.apiResources?.forEach((api) => usedPackageIds.add(api.partOfPackage));
-    ordDocument.eventResources?.forEach((event) => usedPackageIds.add(event.partOfPackage));
-    ordDocument.dataProducts?.forEach((dp) => usedPackageIds.add(dp.partOfPackage));
-    ordDocument.integrationDependencies?.forEach((dep) => usedPackageIds.add(dep.partOfPackage));
-    ordDocument.entityTypes?.forEach((et) => {
-        if (et?.partOfPackage) {
-            usedPackageIds.add(et.partOfPackage);
-        }
-    });
-
-    return ordDocument.packages.filter((pkg) => usedPackageIds.has(pkg.ordId));
-};
-
-const _getEntityTypes = (appConfig, packageIds) => {
-    return appConfig.entityTypeTargets.flatMap((entity) => createEntityTypeTemplate(appConfig, packageIds, entity));
-};
-
-const _createAuthConfig = () => {
-    const authConfig = createAuthConfig();
-
-    // Create auth config and fail-closed on configuration errors
-    if (authConfig.error) {
-        throw new Error(`Authentication configuration error: ${authConfig.error}`);
-    }
-
-    return authConfig;
-};
-
-module.exports = (csn, extensions = []) => {
-    const authConfig = _createAuthConfig();
-    const linkedCsn = _propagateORDVisibility(cds.linked(csn));
-    const appConfig = new Configuration(linkedCsn);
-    const ordDocument = [...(extensions || []), getCustomORDContent(appConfig)]
-        .filter((extension) => !!extension)
-        .reduce(
-            (document, extension) => compareAndHandleCustomORDContentWithExistingContent(document, extension),
-            _createDefaultORDDocument(linkedCsn, appConfig, authConfig),
-        );
 
-    return Object.assign(ordDocument, { packages: _filterUnusedPackages(ordDocument) });
+function prune(document) {
+    const usedPackageIds = new Set(
+        document.packages?.length === 0
+            ? []
+            : [
+                  ...(document.entityTypes?.map((et) => et.partOfPackage) ?? []),
+                  ...(document.dataProducts?.map((dp) => dp.partOfPackage) ?? []),
+                  ...(document.apiResources?.map((ar) => ar.partOfPackage) ?? []),
+                  ...(document.eventResources?.map((er) => er.partOfPackage) ?? []),
+                  ...(document.integrationDependencies?.map((id) => id.partOfPackage) ?? []),
+              ],
+    );
+
+    return utils.prune(
+        Object.assign(document, {
+            // remove unused packages
+            packages: document.packages?.filter((pkg) => usedPackageIds.has(pkg.ordId)),
+        }),
+    );
+}
+
+function extend(extensions, document) {
+    return extensions.reduce(
+        (ord, extension) => compareAndHandleCustomORDContentWithExistingContent(ord, extension),
+        document,
+    );
+}
+
+module.exports = (csn, extensions) => {
+    const appConfig = new Configuration(csn);
+
+    return prune(
+        extend(
+            [...(extensions || []), getCustomORDContent(appConfig)].filter(Boolean), //
+            {
+                $schema: defaults.$schema,
+                groups: createGroups(appConfig),
+                baseUrl: appConfig?.env?.baseUrl,
+                products: createProducts(appConfig),
+                packages: createPackages(appConfig),
+                policyLevels: appConfig.policyLevels,
+                entityTypes: createEntityTypes(appConfig),
+                apiResources: createAPIResources(appConfig),
+                eventResources: createEventResources(appConfig),
+                consumptionBundles: appConfig.env?.consumptionBundles,
+                description: appConfig.env?.description ?? defaults.description,
+                integrationDependencies: createIntegrationDependencies(appConfig),
+                openResourceDiscovery: appConfig.env?.openResourceDiscovery ?? defaults.openResourceDiscovery,
+            },
+        ),
+    );
 };

package/lib/protocol-resolver.js

@@ -1,25 +1,8 @@
 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");
 
-/**
- * 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];
-}
+const Logger = require("./logger");
+const { isPrimaryDataProductService } = require("./common/utils");
+const { CAP_TO_ORD_PROTOCOL_MAP, ORD_ONLY_PROTOCOLS, ORD_API_PROTOCOL } = require("./constants");
 
 /**
  * Resolves protocol for ORD API Resource generation.
@@ -31,95 +14,55 @@ function _getExplicitProtocol(srvDefinition) {
  * - Rule C: Never produce [null] in entryPoints
  *
  * @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(srvDefinition, options = {}) {
-    const { isPrimaryDataProduct = () => false } = options;
-
+function resolveApiResourceProtocol(srvDefinition) {
     // 1. Primary Data Product - early return
-    if (isPrimaryDataProduct(srvDefinition)) {
+    if (isPrimaryDataProductService(srvDefinition)) {
         return [
             {
-                apiProtocol: ORD_API_PROTOCOL.SAP_DATA_SUBSCRIPTION,
                 entryPoints: [],
                 hasResourceDefinitions: true,
+                apiProtocol: ORD_API_PROTOCOL.SAP_DATA_SUBSCRIPTION,
             },
         ];
     }
 
-    const capEndpoints = cds.service.protocols.endpoints4({ name: srvDefinition.name, definition: 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 ordProtocols = cds.service.protocols
+        .endpoints4({ name: srvDefinition.name, definition: srvDefinition })
+        .filter((endpoint) => Boolean(CAP_TO_ORD_PROTOCOL_MAP[endpoint.kind]))
+        .map((endpoint) => ({
+            hasResourceDefinitions: true,
+            entryPoints: endpoint.path ? [endpoint.path] : [],
+            apiProtocol: CAP_TO_ORD_PROTOCOL_MAP[endpoint.kind],
+        }));
 
-    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)
+    const cdsProtocols = Object.keys(cds.service.protocols.for(srvDefinition));
+    for (const protocol of cdsProtocols) {
+        // 2. Handle explicit protocol - 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;
+            const { apiProtocol, hasEntryPoints, hasResourceDefinitions } = ORD_ONLY_PROTOCOLS[protocol];
+            const path = hasEntryPoints ? cds.service.protocols.path4(srvDefinition) : null;
+
             ordProtocols.push({
-                apiProtocol: config.apiProtocol,
+                apiProtocol: apiProtocol,
                 entryPoints: path ? [path] : [],
-                hasResourceDefinitions: config.hasResourceDefinitions,
+                hasResourceDefinitions: hasResourceDefinitions,
             });
             continue;
         }
 
-        // 2b. Check if it's a plugin-unsupported protocol
-        if (PLUGIN_UNSUPPORTED_PROTOCOLS.includes(protocol)) {
+        // 3. Handle explicit protocol with no CAP endpoint (Rule A)
+        if (!ordProtocols.some((p) => p.apiProtocol === protocol) && !CAP_TO_ORD_PROTOCOL_MAP[protocol]) {
             Logger.warn(
-                `Protocol '${protocol}' is supported by ORD but this plugin cannot generate its resource definitions yet.`,
+                `Unknown protocol '${protocol}' is not supported, and skipped for service '${srvDefinition.name}'.`,
             );
-            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 '${srvDefinition.name}'.`);
-        }
-    }
-
-    // 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,
-        },
-    ];
+    return ordProtocols;
 }
 
 module.exports = {
     resolveApiResourceProtocol,
-    // Exported for testing
-    _getExplicitProtocol,
 };

package/lib/services/ord-service.js

@@ -1,11 +1,12 @@
 const cds = require("@sap/cds");
 
+const { slice } = require("../common/slice");
 const ord = require("../ord.js");
 const Logger = require("../logger.js");
 const defaults = require("../defaults.js");
-const { LOCAL_TENANT_ID_HEADER_KEY, DOCUMENT_PERSPECTIVES } = require("../constants");
 const compileMetadata = require("../meta-data.js");
 const { createAuthConfig, createAuthMiddleware } = require("../auth/authentication.js");
+const { LOCAL_TENANT_ID_HEADER_KEY, DOCUMENT_PERSPECTIVES } = require("../constants");
 
 const validationMiddleware = (req, res, next) => {
     const toggles = cds.env.requires.toggles;
@@ -13,7 +14,10 @@ const validationMiddleware = (req, res, next) => {
     const extensibility = cds.env.requires.extensibility;
     const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
 
-    if (perspective && ![DOCUMENT_PERSPECTIVES.SystemVersion, DOCUMENT_PERSPECTIVES.SystemInstance].includes(perspective)) {
+    if (
+        perspective &&
+        ![DOCUMENT_PERSPECTIVES.SystemVersion, DOCUMENT_PERSPECTIVES.SystemInstance].includes(perspective)
+    ) {
         return res.status(400).send(`Required query parameter 'perspective' is invalid`);
     }
 
@@ -79,19 +83,39 @@ class OpenResourceDiscoveryService extends cds.ApplicationService {
         const authMiddleware = createAuthMiddleware(authConfig);
 
         // Default: /.well-known/open-resource-discovery
-        cds.app.get(`${this.path}`, (req, res) => {
+        cds.app.get(`${this.path}`, async (req, res) => {
+            const toggles = cds.env.requires.toggles;
+            const extensibility = cds.env.requires.extensibility;
             const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+            const extensions = Array.from(Object.values(this.extensions));
 
-            return res.status(200).send(defaults.baseTemplate(authConfig, tenant));
+            return res
+                .status(200)
+                .send(
+                    defaults.baseTemplate(
+                        authConfig,
+                        ord(cds.model, extensions),
+                        !tenant || (!toggles && !extensibility)
+                            ? undefined
+                            : ord(await resolveCdsModel(DOCUMENT_PERSPECTIVES.SystemInstance, tenant), extensions),
+                    ),
+                );
         });
 
         cds.app.get(`/ord/v1/documents/ord-document`, [authMiddleware, validationMiddleware], async (req, res) => {
-            const perspective = req.query.perspective || DOCUMENT_PERSPECTIVES.SystemVersion;
+            const part = req.query.part || 0;
             const tenant = req.headers[LOCAL_TENANT_ID_HEADER_KEY];
+            const perspective = req.query.perspective || DOCUMENT_PERSPECTIVES.SystemVersion;
             const model = await resolveCdsModel(perspective, tenant);
             const extensions = Array.from(Object.values(this.extensions));
+            const document = defaults.adjustForPerspective(ord(model, extensions), perspective);
+            const slices = slice(document, defaults.sizeLimit);
+
+            if (isNaN(part) || part < 0 || part >= slices.length) {
+                return res.status(400).send(`Required query parameter 'part' is invalid`);
+            }
 
-            return res.status(200).send(defaults.adjustForPerspective(ord(model, extensions), perspective));
+            return res.status(200).send(slices[part]);
         });
 
         cds.app.get(`/ord/v1/documents/:id`, [authMiddleware, validationMiddleware], async (_, res) => {