eip-cloud-services 1.3.0 → 1.5.0

package/CHANGELOG.md

@@ -3,6 +3,11 @@
 
 All notable changes to this project will be documented in this file.
 
+## Unreleased
+
+### Added
+- Added staging-safe OnDemand Content Ingest, Content Discovery, and Azure Blob upload clients with injectable fetch, timeouts, production-host guards, and signed-query redaction.
+
 ## [1.2.5] - 2026-03-02
 
 ### Fixed

package/README.md

@@ -82,6 +82,51 @@ module.exports = {
 5. [AWS Lambda Module](#aws-lambda-module)
 6. [AWS SQS Module](#aws-sqs-module)
 7. [AWS Secrets Manager Module](#aws-secrets-manager-module)
+8. [OnDemand Module](#ondemand-module)
+
+# OnDemand Module
+
+## Overview
+
+The OnDemand module provides dependency-free clients for Axel Springer's Content Ingest and Content Discovery APIs, plus streaming uploads to their Azure Blob Storage target. Staging endpoints are the defaults. Production Content Discovery/Ingest hosts are rejected unless a future caller explicitly supplies `allowProduction: true`.
+
+Secrets are caller-provided and are never stored by this package. Provider errors and returned metadata are sanitized so signed Azure query parameters are not included in thrown errors.
+
+## Usage
+
+```javascript
+const { ondemand } = require ( 'eip-cloud-services' );
+
+const ingest = ondemand.createIngestClient ( {
+    apiKey: process.env.ONDEMAND_INGEST_API_KEY
+} );
+
+const discovery = ondemand.createDiscoveryClient ( {
+    apiKey: process.env.ONDEMAND_DISCOVERY_API_KEY
+} );
+
+const assets = await discovery.search ( {
+    q: 'climate change',
+    assetType: 'video',
+    suppliers: [ 'https://cv.content-discovery.video/party/telegraph' ]
+} );
+```
+
+Available Ingest operations are `createAsset`, `getAsset`, `updateAsset`, `startIngest`, `getIngest`, `createRendition`, and `updateRendition`. Discovery operations are `getVersion`, `getAsset`, `getAssets`, `search`, `searchByExpression`, and `getMasterDownload`.
+
+Use `uploadAzureBlob` with a clean blob URL and a separate SAS token. Pass the clean URL—not the signed upload URL—to `startIngest`:
+
+```javascript
+await ondemand.uploadAzureBlob ( {
+    blobUrl: cleanBlobUrl,
+    sasToken: process.env.ONDEMAND_AZURE_SAS_TOKEN,
+    body: videoStream,
+    contentLength: videoSize,
+    contentType: 'video/mp4'
+} );
+
+await ingest.startIngest ( assetId, { url: cleanBlobUrl } );
+```
 
 # AWS Secrets Manager Module
 
@@ -273,7 +318,7 @@ The module is designed to handle errors gracefully, providing clear error messag
 
 ## Overview
 
-This module provides functionalities to manage and interact with Content Delivery Networks (CDNs) like Amazon CloudFront and Google Cloud CDN. It includes features for creating invalidations, thereby ensuring that the latest content is served to end-users.
+This module provides a shared client for CDN invalidation requests. CDN invalidation requests are sent through the shared Tools API invalidate endpoint, so callers use one centralized route while the backend implementation remains independently updateable inside the invalidation service.
 
 ## Installation
 
@@ -287,7 +332,7 @@ const cdn = require('eip-cloud-services/cdn');
 
 ### Create a CDN Invalidation
 
-To invalidate cached content in a CDN, use the `createInvalidation` method. This method supports invalidating content in both Amazon CloudFront and Google Cloud CDN.
+To invalidate cached content in a CDN, use the `createInvalidation` method. This sends the request to the shared Tools API invalidate endpoint, which executes the configured provider-specific invalidation in `eip-cdn-invalidator`.
 
 #### Invalidate in Amazon CloudFront
 
@@ -317,11 +362,9 @@ The module is equipped to handle errors gracefully, including validation of inpu
 
 ## Advanced Features
 
-- Supports both Amazon CloudFront and Google Cloud CDN.
 - Validates the key argument to ensure proper formatting.
 - Constructs invalidation paths based on the provided keys.
-- Initializes Google Auth if Google CDN is used.
-- Sends invalidation commands to the CDN client based on the type of CDN and environment.
+- Centralizes invalidation routing through the shared Tools API endpoint.
 
 
 # AWS S3 Module

package/index.js

@@ -7,3 +7,4 @@ exports.sqs = require ( './src/sqs' );
 exports.secrets = require ( './src/secrets' );
 exports.mysql = require ( './src/mysql' );
 exports.mysql8 = require ( './src/mysql8' );
+exports.ondemand = require ( './src/ondemand' );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {

package/src/cdn.js

@@ -1,114 +1,61 @@
-const { CloudFrontClient, CreateInvalidationCommand } = require ( '@aws-sdk/client-cloudfront' );
-const { GoogleAuth } = require ( 'google-auth-library' );
-const { initialiseGoogleAuth } = require ( './gcp' );
 const fs = require ( 'fs' );
 let config = {};
 const configDirPath = `${ process.cwd ()}/config`;
 if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirectory () ) {
     config = require ( 'config' ); // require the config directory if it exists
 }
-const packageJson = require ( '../package.json' );
 const { cwd } = require ( 'process' );
 const { log } = config?.s3?.logsFunction ? require ( `${  cwd ()}/${config.s3.logsFunction}` ) : console;
 
-const redis = require('./redis');
+const INVALIDATION_ENDPOINT = process.env.EIP_CDN_INVALIDATE_ENDPOINT || config?.cdn?.invalidateEndpoint || 'https://tools.eip.telegraph.co.uk/v1/invalidate';
+const shouldLog = Boolean ( config?.cdn?.log || config?.cdn?.logs );
 
-/**
- * Create a CDN invalidation for the specified key(s) and environment.
- *
- * @param {string} cdn - The CDN provider to be used (e.g., 'google', 'amazon').
- * @param {string|string[]} key - The key(s) representing the file(s) to invalidate.
- * @param {string} environment - The environment (e.g., 'staging', 'production').
- * @returns {Promise<void>} A promise that resolves when the invalidation is created.
- * @description Creates a CDN invalidation for the specified key(s) in the specified environment.
- * - The `cdn` parameter specifies the CDN provider (e.g., 'google', 'amazon').
- * - The `key` parameter can be a single string or an array of strings representing the file(s) to invalidate.
- * - The `environment` parameter specifies the environment (e.g., 'staging', 'production').
- * - The function validates the `key` argument and throws an error if it is not a string or an array of strings.
- * - The function constructs the invalidation paths based on the provided keys.
- * - The CDN client (either Google or Amazon CloudFront) is used to send the invalidation command.
- * - Returns a promise that resolves when the invalidation is created.
- * - The function initializes Google Auth if Google CDN is used.
- * - If Google CDN is used, the function makes a POST request to Google's 'invalidateCache' endpoint for each provided path.
- * - If Amazon CloudFront is used, the function sends an invalidation command to CloudFront.
- * - If the CDN type is not 'google' or 'amazon', the function throws an error.
- * - The function uses the 'config' module to access the CDN settings based on the CDN provider and environment.
- */
 exports.createInvalidation = async ( cdn, key, environment = 'production' ) => {
-    const cdnSettings = config.cdn[ cdn ][ environment ];
+    const invalidation = normalizeInvalidation ( cdn, key, environment );
 
-    // Ensure paths is an array and sanitize paths
-    const paths = ( Array.isArray ( key ) ? key : [ key ] )
-        .filter ( item => typeof item === 'string' )
-        .map ( item => item.charAt ( 0 ) !== '/' ? '/' + item : item );
-
-    if ( paths.length === 0 ) {
-        throw new Error ( 'Invalid key argument. Expected a string or an array of strings.' );
+    if ( shouldLog ) {
+        log ( `CDN [INVALIDATE][REQUEST]: ${invalidation.cdn} (${invalidation.environment}) ${invalidation.paths.join ( ', ' )}\n` );
     }
 
-    if ( config?.redis?.host ) {
-        const redisKey = `cdn-invalidation:${cdn}:${environment}:${key}`;
-        const redisValue = await redis.get(redisKey);
+    const response = await fetch ( INVALIDATION_ENDPOINT, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify ( {
+            cdn: invalidation.cdn,
+            key: invalidation.key,
+            environment: invalidation.environment
+        } )
+    } );
 
-        if(redisValue) {
-            if ( config.cdn.log )
-                log ( `CDN [INVALIDATE]: Invalidation already in progress - skipping: ${paths.map ( path => `https://${cdn}${environment !== 'production' ? '-test' : ''}.eip.telegraph.co.uk${path}` ).join ( ', ' )}\n` );
-            await redis.increment(redisKey);
+    if ( !response.ok ) {
+        const responseText = await response.text ();
 
-            return;
-        }
-        else{
-            await redis.set(redisKey, 1, cdnSettings.type === 'google' ? 300 : 120); // 5 minutes for google, 2 minutes for amazon
-        }
+        throw new Error ( `CDN invalidation request failed (${response.status}): ${responseText}` );
     }
+};
 
-    if ( config.cdn.log )
-        log ( `CDN [INVALIDATE]: ${paths.map ( path => `https://${cdn}${environment !== 'production' ? '-test' : ''}.eip.telegraph.co.uk${path}` ).join ( ', ' )}\n` );
-
-    switch ( cdnSettings.type ) {
-        case 'google':
-            await invalidateGoogleCDN ( cdnSettings, paths );
-            break;
-
-        case 'amazon':
-            await invalidateAmazonCDN ( cdnSettings, paths );
-            break;
+function normalizeInvalidation ( cdn, key, environment ) {
+    const cdnSettings = config?.cdn?.[ cdn ]?.[ environment ];
 
-        default:
-            throw new Error ( `Invalid cdn type: ${cdnSettings.type}` );
+    if ( !cdnSettings ) {
+        throw new Error ( `Missing CDN configuration for ${cdn} (${environment})` );
     }
-};
 
-async function invalidateGoogleCDN ( cdnSettings, paths ) {
-    await initialiseGoogleAuth ();
-
-    const auth = new GoogleAuth ( {
-        scopes: 'https://www.googleapis.com/auth/cloud-platform'
-    } );
+    const paths = ( Array.isArray ( key ) ? key : [ key ] )
+        .filter ( item => typeof item === 'string' )
+        .map ( item => item.charAt ( 0 ) !== '/' ? '/' + item : item );
 
-    const client = await auth.getClient ();
-    const url = `https://compute.googleapis.com/compute/v1/projects/${cdnSettings.projectId}/global/urlMaps/${cdnSettings.urlMapName}/invalidateCache`;
-    const headers = await client.getRequestHeaders ( url );
+    if ( paths.length === 0 ) {
+        throw new Error ( 'Invalid key argument. Expected a string or an array of strings.' );
+    }
 
-    await Promise.all ( paths.map ( path => fetch ( url, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify ( { path } )
-    } ) ) );
+    return {
+        cdn,
+        key,
+        environment,
+        paths,
+        cdnSettings
+    };
 }
-
-async function invalidateAmazonCDN ( cdnSettings, paths ) {
-    const client = new CloudFrontClient ();
-    const command = new CreateInvalidationCommand ( {
-        DistributionId: cdnSettings.distributionId,
-        InvalidationBatch: {
-            CallerReference: `${packageJson.name}-${Date.now ()}`,
-            Paths: {
-                Quantity: paths.length,
-                Items: paths,
-            },
-        },
-    } );
-
-    await client.send ( command );
-}

package/src/ondemand.js

@@ -0,0 +1,339 @@
+const DEFAULT_INGEST_BASE_URL = 'https://ingest.staging.content-discovery.video/v1';
+const DEFAULT_DISCOVERY_BASE_URL = 'https://api.staging.content-discovery.video/v1';
+const PRODUCTION_HOSTS = new Set ( [
+    'ingest.content-discovery.video',
+    'api.content-discovery.video'
+] );
+const DEFAULT_TIMEOUT_MS = 15000;
+
+class OnDemandRequestError extends Error {
+    constructor ( message, { status = null, details = null, cause = null } = {} ) {
+        super ( message, cause ? { cause } : undefined );
+        this.name = 'OnDemandRequestError';
+        this.status = status;
+        this.details = details;
+    }
+}
+
+const normalizeText = value => typeof value === 'string' ? value.trim () : '';
+
+const sanitizeUrl = value => {
+    try {
+        const url = new URL ( value );
+        url.search = '';
+        url.hash = '';
+        return url.toString ();
+    }
+    catch ( error ) {
+        return value;
+    }
+};
+
+const sanitizeText = value => normalizeText ( value )
+    .replace ( /https?:\/\/[^\s"'<>]+/gi, match => sanitizeUrl ( match ) )
+    .replace ( /[?&](?:sig|sv|se|sp|spr|srt|ss|st)=[^&\s"']*/gi, '' );
+
+const sanitizeDetails = value => {
+    if ( typeof value === 'string' ) return sanitizeText ( value );
+    if ( Array.isArray ( value ) ) return value.map ( sanitizeDetails );
+    if ( !value || typeof value !== 'object' ) return value;
+
+    return Object.fromEntries ( Object.entries ( value ).map ( ( [ key, item ] ) => [ key, sanitizeDetails ( item ) ] ) );
+};
+
+const resolveFetch = fetchImpl => {
+    const resolved = fetchImpl || global.fetch;
+    if ( typeof resolved !== 'function' ) {
+        throw new Error ( 'OnDemand requires a fetch implementation' );
+    }
+
+    return resolved;
+};
+
+const normalizeBaseUrl = ( value, defaultValue, allowProduction ) => {
+    const normalized = normalizeText ( value ) || defaultValue;
+    const url = new URL ( normalized );
+
+    if ( url.protocol !== 'https:' ) {
+        throw new Error ( 'OnDemand endpoint must use HTTPS' );
+    }
+    if ( PRODUCTION_HOSTS.has ( url.hostname ) && !allowProduction ) {
+        throw new Error ( 'OnDemand production endpoint is disabled' );
+    }
+
+    url.search = '';
+    url.hash = '';
+    return url.toString ().replace ( /\/$/, '' );
+};
+
+const requireApiKey = value => {
+    const apiKey = normalizeText ( value );
+    if ( !apiKey ) throw new Error ( 'OnDemand API key is required' );
+    return apiKey;
+};
+
+const parseResponse = async response => {
+    if ( response.status === 204 ) return null;
+
+    const contentType = normalizeText ( response?.headers?.get?.( 'content-type' ) ).toLowerCase ();
+    if ( contentType.includes ( 'json' ) && typeof response.json === 'function' ) {
+        return response.json ();
+    }
+
+    const text = typeof response.text === 'function' ? await response.text () : '';
+    if ( !text ) return null;
+
+    try {
+        return JSON.parse ( text );
+    }
+    catch ( error ) {
+        return text;
+    }
+};
+
+const buildErrorMessage = ( status, details ) => {
+    const detail = typeof details === 'object' && details
+        ? details.detail || details.title || details.message
+        : details;
+    const suffix = sanitizeText ( detail );
+    return `OnDemand request failed (${status})${suffix ? `: ${suffix}` : ''}`;
+};
+
+const executeRequest = async ( {
+    fetchImpl,
+    url,
+    options,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    includeResponse = false
+} ) => {
+    const controller = new AbortController ();
+    const timer = setTimeout ( () => controller.abort (), timeoutMs );
+    timer.unref?.();
+
+    try {
+        const response = await fetchImpl ( url, {
+            ...options,
+            signal: controller.signal
+        } );
+        const payload = await parseResponse ( response );
+
+        if ( !response.ok ) {
+            const sanitizedDetails = sanitizeDetails ( payload );
+            throw new OnDemandRequestError ( buildErrorMessage ( response.status, sanitizedDetails ), {
+                status: response.status,
+                details: sanitizedDetails
+            } );
+        }
+
+        return includeResponse ? { payload, response } : payload;
+    }
+    catch ( error ) {
+        if ( error instanceof OnDemandRequestError ) throw error;
+
+        const timedOut = controller.signal.aborted || error?.name === 'AbortError';
+        throw new OnDemandRequestError ( timedOut ? 'OnDemand request timed out' : 'OnDemand request failed', {
+            cause: error
+        } );
+    }
+    finally {
+        clearTimeout ( timer );
+    }
+};
+
+const createApiClient = ( {
+    apiKey,
+    baseUrl,
+    defaultBaseUrl,
+    allowProduction = false,
+    fetch: fetchOption,
+    timeoutMs = DEFAULT_TIMEOUT_MS
+} ) => {
+    const resolvedApiKey = requireApiKey ( apiKey );
+    const resolvedBaseUrl = normalizeBaseUrl ( baseUrl, defaultBaseUrl, allowProduction );
+    const fetchImpl = resolveFetch ( fetchOption );
+
+    return async ( path, { method = 'GET', body, headers = {} } = {} ) => executeRequest ( {
+        fetchImpl,
+        url: `${resolvedBaseUrl}${path}`,
+        timeoutMs,
+        options: {
+            method,
+            headers: {
+                ...( body === undefined ? {} : { 'Content-Type': 'application/json' } ),
+                'X-API-KEY': resolvedApiKey,
+                ...headers
+            },
+            ...( body === undefined ? {} : { body: JSON.stringify ( body ) } )
+        }
+    } );
+};
+
+const encodePathSegment = ( value, label ) => {
+    const normalized = normalizeText ( value );
+    if ( !normalized ) throw new Error ( `${label} is required` );
+    return encodeURIComponent ( normalized );
+};
+
+const assertCleanIngestUrl = value => {
+    const normalized = normalizeText ( value );
+    if ( !normalized ) throw new Error ( 'OnDemand ingest URL is required' );
+
+    const url = new URL ( normalized );
+    if ( url.search ) throw new Error ( 'OnDemand ingest URL must not contain query parameters' );
+    return url.toString ();
+};
+
+/**
+ * Create a Content Ingest API client. Staging is the default and production hosts
+ * are rejected unless a future caller explicitly opts in with allowProduction.
+ *
+ * @param {object} options
+ * @param {string} options.apiKey Content Ingest X-API-KEY value.
+ * @param {string} [options.baseUrl] Content Ingest base URL.
+ * @param {boolean} [options.allowProduction=false] Explicit production safety override.
+ * @param {Function} [options.fetch] Injectable fetch implementation.
+ * @param {number} [options.timeoutMs=15000] Per-request timeout.
+ * @returns {object} Content Ingest operations.
+ */
+exports.createIngestClient = options => {
+    const request = createApiClient ( {
+        ...options,
+        defaultBaseUrl: DEFAULT_INGEST_BASE_URL
+    } );
+
+    return {
+        createAsset: input => request ( '/assets', { method: 'POST', body: input } ),
+        getAsset: assetId => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}` ),
+        updateAsset: ( assetId, input ) => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}`, {
+            method: 'PATCH',
+            body: input
+        } ),
+        startIngest: ( assetId, input ) => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}/ingest`, {
+            method: 'POST',
+            body: {
+                ...input,
+                url: assertCleanIngestUrl ( input?.url )
+            }
+        } ),
+        getIngest: ingestId => request ( `/ingests/${encodePathSegment ( ingestId, 'OnDemand ingest id' )}` ),
+        createRendition: ( assetId, input ) => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}/rendition`, {
+            method: 'POST',
+            body: input
+        } ),
+        updateRendition: ( assetId, rendition, input ) => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}/rendition/${encodePathSegment ( rendition, 'OnDemand rendition' )}`, {
+            method: 'PUT',
+            body: input
+        } )
+    };
+};
+
+const buildQueryString = params => {
+    const searchParams = new URLSearchParams ();
+
+    Object.entries ( params || {} ).forEach ( ( [ key, value ] ) => {
+        if ( value === undefined || value === null || value === '' ) return;
+        searchParams.set ( key, Array.isArray ( value ) ? value.join ( ',' ) : String ( value ) );
+    } );
+
+    const query = searchParams.toString ();
+    return query ? `?${query}` : '';
+};
+
+/**
+ * Create a Content Discovery API client. Staging is the default and production
+ * hosts are rejected unless a future caller explicitly opts in.
+ *
+ * @param {object} options
+ * @param {string} options.apiKey Content Discovery X-API-KEY value.
+ * @param {string} [options.baseUrl] Content Discovery base URL.
+ * @param {boolean} [options.allowProduction=false] Explicit production safety override.
+ * @param {Function} [options.fetch] Injectable fetch implementation.
+ * @param {number} [options.timeoutMs=15000] Per-request timeout.
+ * @returns {object} Content Discovery operations.
+ */
+exports.createDiscoveryClient = options => {
+    const request = createApiClient ( {
+        ...options,
+        defaultBaseUrl: DEFAULT_DISCOVERY_BASE_URL
+    } );
+
+    return {
+        getVersion: () => request ( '/' ),
+        getAsset: assetId => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}` ),
+        getAssets: assetIds => request ( `/assets${buildQueryString ( {
+            id: ( Array.isArray ( assetIds ) ? assetIds : [ assetIds ] ).join ( ',' )
+        } )}` ),
+        search: params => request ( `/search${buildQueryString ( params )}` ),
+        searchByExpression: expression => request ( '/search', { method: 'POST', body: expression } ),
+        getMasterDownload: assetId => request ( `/assets/${encodePathSegment ( assetId, 'OnDemand asset id' )}/renditions/master/download` )
+    };
+};
+
+const buildAzureUploadUrl = ( blobUrl, sasToken ) => {
+    const url = new URL ( normalizeText ( blobUrl ) );
+    if ( url.protocol !== 'https:' || !url.hostname.endsWith ( '.blob.core.windows.net' ) ) {
+        throw new Error ( 'OnDemand Azure blob URL must be an HTTPS Azure Blob Storage URL' );
+    }
+    if ( url.search ) {
+        throw new Error ( 'OnDemand Azure blob URL must not already contain query parameters' );
+    }
+
+    const normalizedSas = normalizeText ( sasToken ).replace ( /^\?/, '' );
+    if ( !normalizedSas ) throw new Error ( 'OnDemand Azure SAS token is required' );
+    url.search = normalizedSas;
+    return url.toString ();
+};
+
+/**
+ * Stream a source video to an Azure block blob using a SAS token. The returned
+ * result never includes the signed request URL.
+ *
+ * @param {object} options
+ * @param {string} options.blobUrl Clean Azure blob URL without a query string.
+ * @param {string} options.sasToken Azure SAS query string.
+ * @param {import('stream').Readable|Buffer|Uint8Array|Blob} options.body Upload body.
+ * @param {number} options.contentLength Exact byte length.
+ * @param {string} [options.contentType='video/mp4'] MIME type.
+ * @param {Function} [options.fetch] Injectable fetch implementation.
+ * @param {number} [options.timeoutMs=300000] Upload timeout.
+ * @returns {Promise<{status: number, etag: string|null}>} Sanitized upload result.
+ */
+exports.uploadAzureBlob = async ( {
+    blobUrl,
+    sasToken,
+    body,
+    contentLength,
+    contentType = 'video/mp4',
+    fetch: fetchOption,
+    timeoutMs = 300000
+} ) => {
+    if ( !body ) throw new Error ( 'OnDemand Azure upload body is required' );
+    if ( !Number.isFinite ( Number ( contentLength ) ) || Number ( contentLength ) < 0 ) {
+        throw new Error ( 'OnDemand Azure upload content length is required' );
+    }
+
+    const fetchImpl = resolveFetch ( fetchOption );
+    const { response } = await executeRequest ( {
+        fetchImpl,
+        url: buildAzureUploadUrl ( blobUrl, sasToken ),
+        timeoutMs,
+        includeResponse: true,
+        options: {
+            method: 'PUT',
+            headers: {
+                'Content-Type': contentType,
+                'Content-Length': String ( contentLength ),
+                'x-ms-blob-type': 'BlockBlob'
+            },
+            body,
+            ...( typeof body?.pipe === 'function' ? { duplex: 'half' } : {} )
+        }
+    } );
+
+    return {
+        status: response.status,
+        etag: response.headers?.get?.( 'etag' ) || null
+    };
+};
+
+exports.OnDemandRequestError = OnDemandRequestError;