eip-cloud-services 1.3.0 → 1.4.0

package/README.md

@@ -273,7 +273,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 +287,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 +317,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.3.0",
+  "version": "1.4.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 );
-}