eip-cloud-services 1.0.0

package/index.js

@@ -0,0 +1,6 @@
+// Import individual service modules
+exports.redis = require ( './src/redis' );
+exports.s3 = require ( './src/s3' );
+exports.cdn = require ( './src/cdn' );
+exports.lambda = require ( './src/lambda' );
+exports.mysql = require ( './src/mysql' );

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "eip-cloud-services",
+  "version": "1.0.0",
+  "description": "Houses a collection of helpers for connecting with Cloud services.",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "author": "Oliver Edgington <oliver@edgington.com>",
+  "license": "ISC",
+  "devDependencies": {
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-cloudfront": "^3.354.0",
+    "@aws-sdk/client-lambda": "^3.356.0",
+    "@aws-sdk/client-s3": "^3.354.0",
+    "@aws-sdk/client-secrets-manager": "^3.354.0",
+    "config": "^3.3.9",
+    "google-auth-library": "^8.8.0",
+    "mysql": "^2.18.1",
+    "redis": "^4.6.7"
+  }
+}

package/src/cdn.js

@@ -0,0 +1,86 @@
+const { CloudFrontClient, CreateInvalidationCommand } = require ( '@aws-sdk/client-cloudfront' );
+const { GoogleAuth } = require ( 'google-auth-library' );
+const { initialiseGoogleAuth } = require ( './gcp' );
+const config = require ( 'config' );
+const packageJson = require ( '../package.json' );
+
+/**
+ * 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 ];
+
+    // 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.' );
+    }
+
+    switch ( cdnSettings.type ) {
+        case 'google':
+            await invalidateGoogleCDN ( cdnSettings, paths );
+            break;
+
+        case 'amazon':
+            await invalidateAmazonCDN ( cdnSettings, paths );
+            break;
+
+        default:
+            throw new Error ( `Invalid cdn type: ${cdnSettings.type}` );
+    }
+};
+
+async function invalidateGoogleCDN ( cdnSettings, paths ) {
+    await initialiseGoogleAuth ();
+
+    const auth = new GoogleAuth ( {
+        scopes: 'https://www.googleapis.com/auth/cloud-platform'
+    } );
+
+    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 );
+
+    await Promise.all ( paths.map ( path => fetch ( url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify ( { path } )
+    } ) ) );
+}
+
+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/gcp.js

@@ -0,0 +1,41 @@
+const { SecretsManagerClient, GetSecretValueCommand } = require ( '@aws-sdk/client-secrets-manager' );
+const { writeFile, readFile } = require ( 'fs/promises' );
+const os = require ( 'os' );
+
+exports.initialiseGoogleAuth = async () => {
+
+    if ( !process.env.GOOGLE_APPLICATION_CREDENTIALS ){
+        
+        try {
+            await readFile ( `${os.tmpdir ()}/gcp.json` );
+            process.env.GOOGLE_APPLICATION_CREDENTIALS = './gcp.json';
+            
+            return;
+        }
+        catch ( error ){
+            //file doesnt exists, so continue to create it below.
+        }
+
+        const secret_name = 'gcp-tmg-product-innovation-prod-all-access';
+        const client = new SecretsManagerClient ( { region: 'eu-west-1' } );
+  
+        let response;
+  
+        try {
+            response = await client.send (
+                new GetSecretValueCommand ( {
+                    SecretId: secret_name,
+                    VersionStage: 'AWSCURRENT'
+                } )
+            );
+        }
+        catch ( error ) {
+            throw error;
+        }
+    
+        await writeFile ( `${os.tmpdir ()}/gcp.json`, response.SecretString );
+        process.env.GOOGLE_APPLICATION_CREDENTIALS = `${os.tmpdir ()}/gcp.json`;
+    }
+
+    return;
+};

package/src/lambda.js

@@ -0,0 +1,49 @@
+const { LambdaClient, InvokeCommand } = require ( '@aws-sdk/client-lambda' );
+const config = require ( 'config' );
+const packageJson = require ( '../package.json' );
+
+/**
+ * Invokes an AWS Lambda function.
+ *
+ * @param {string} functionName - The name of the function you want to invoke.
+ * @param {Object} eventPayload - The payload of an event to pass to the function.
+ * @param {boolean} [waitForExecution=false] - Flag to indicate whether to wait for the execution of the function (default: false).
+ * @param {string} [context=null] - The client context for the function execution.
+ * @param {string} [invocationType='Event'] - The invocation type for the function (default: 'Event').
+ * @param {string} [logType='None'] - The type of logging for the function (default: 'None').
+ * @returns {Promise<any> | null} - A promise that resolves with the response of the function invocation if `waitForExecution` is true, otherwise null.
+ *
+ * @description
+ * This function invokes an AWS Lambda function using the provided parameters. It allows you to specify the name of the function,
+ * the payload to pass as an event, and configure optional parameters such as whether to wait for the execution to complete,
+ * the client context, invocation type, and log type.
+ *
+ * If `waitForExecution` is set to `true`, the function will await the response from the invocation and return it as a promise.
+ * If `waitForExecution` is `false`, the function will initiate the invocation but not wait for the response, returning null.
+ *
+ * Note: The `invokeLambda` function relies on the `config` module to obtain the client context. Make sure to have the necessary configuration in place for successful execution.
+ */
+exports.invokeLambda = async ( functionName, eventPayload, waitForExecution = false, context = null, invocationType = 'Event', logType = 'None' ) => {
+    const params = {
+        FunctionName: functionName,
+        ClientContext: context ? context : packageJson.name,
+        InvocationType: invocationType,
+        LogType: logType,
+        Payload: eventPayload ? JSON.stringify ( eventPayload ) : undefined  /* Strings will be Base-64 encoded on your behalf */
+    };
+
+    const client = new LambdaClient ();
+    const command = new InvokeCommand ( params );
+    console.log ( `[LAMBDA][START] New invoke to function: ${functionName}` );
+
+    if ( waitForExecution ) {
+        const response = await client.send ( command );
+        
+        return response;
+    }
+    else {
+        client.send ( command );
+        
+        return null;
+    }
+};

package/src/mysql.js

@@ -0,0 +1,53 @@
+const mysql = require ( 'mysql' );
+const config = require ( 'config' );
+
+const pool = mysql.createPool (
+    {
+        connectionLimit: config.mysql.connectionLimit,
+        host: config.mysql.host,
+        user: config.mysql.user,
+        password: config.mysql.password,
+        database: config.mysql.database,
+        multipleStatements: true
+    }
+);
+
+const newQuery = ( connection, query ) => new Promise ( ( resolve, reject ) => {
+    connection.query ( query, ( error, results, fields ) => {
+        connection.release ();
+        if ( error ) {
+            console.error ( error );
+            console.error ( `There was a problem with query: ${ query }` );
+            reject ( `There was a problem with query: ${ query }` );
+        }
+        else {
+            resolve ( results );
+        }
+    } );
+} );
+
+const getConnection = () => new Promise ( ( resolve, reject ) => {
+    pool.getConnection ( ( error, connection ) => {
+        if ( error ) {
+            console.log ( error );
+            console.error ( 'There was a problem getting a new database connection.' );
+            reject ( 'There was a problem getting a new database connection.' );
+        }
+        else {
+            resolve ( connection );
+        }
+    } );
+} );
+
+exports.query = queryString => new Promise ( ( resolve, reject ) => {
+    if ( !queryString.endsWith ( ';' ) ){
+        queryString += ';';
+    }
+    getConnection ().then ( connection => newQuery ( connection, queryString ) ).then ( resolve ).catch ( reject );
+} );
+
+exports.kill = () => new Promise ( resolve => {
+    pool.end ( () => {
+        resolve ();
+    } );
+} );

package/src/redis.js

@@ -0,0 +1,496 @@
+const redis = require ( 'redis' );
+const config = require ( 'config' );
+let redisClient;
+
+const getClient = async () => {
+    try {
+        if ( !redisClient ) {
+            redisClient = redis.createClient ( { url: `${config.redis.host}:${config.redis.port}` } );
+            await redisClient.connect ();
+            redisClient.on ( 'error', error => {
+                console.error ( '\x1b[33mREDIS CONNECTION FAILED: Redis connection failed. If you\'re running locally, is a redis server actually active? Also, check your connection configuration.\x1b[0m' );
+                
+                throw error;
+            }, { once: true } );
+        }
+
+        return redisClient;
+    }
+    catch ( error ){
+        throw new Error ( 'Redis connection failed. If running locally is redis actually running? Also check your connection configuration.' );
+    }
+};
+
+/**
+ * Retrieves all keys matching a pattern.
+ * @param {string} pattern - The pattern to match.
+ * @returns {Promise} - A promise that resolves with the keys matching the pattern.
+ *
+ * @description This method retrieves all keys from Redis that match the specified pattern.
+ * The pattern can include wildcards (* and ?) to perform pattern matching.
+ */
+exports.keys = async ( pattern ) => {
+    try {
+        if ( typeof pattern === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                pattern.startsWith ( config.redis.prefix ) ? pattern : config.redis.prefix + pattern,
+            ];
+
+            return await client.sendCommand ( [ 'KEYS', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.keys expects a string pattern, instead the type provided was: ${typeof pattern}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [keys]', error );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves the value of a key.
+ * @param {string} key - The key to retrieve.
+ * @returns {Promise} - A promise that resolves with the value of the key.
+ *
+ * @description This method retrieves the value associated with the specified key from Redis.
+ * If the value is a JSON string, it will be parsed and returned as a JavaScript object.
+ * If the value is not a valid JSON string, it will be returned as a string.
+ */
+exports.get = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            const data = await client.sendCommand ( [ 'GET', ...commandArgs ] );
+
+            try {
+                return JSON.parse ( data );
+            }
+            catch {
+                return data;
+            }
+        }
+
+        throw new Error ( `redis.get expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [get]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Sets the value of a key.
+ * @param {string} key - The key to set.
+ * @param {*} value - The value to set for the key.
+ * @param {string} [ex] - Optional EX parameter to set expiration in seconds.
+ * @param {number} [px] - Optional PX parameter to set expiration in milliseconds.
+ * @returns {Promise} - A promise that resolves with the result of the SET command.
+ *
+ * @description This method sets the value for the specified key in Redis.
+ * If the value is an object or array, it will be automatically converted to a JSON string before storing.
+ * Optionally, you can set an expiration time for the key using the `ex` parameter in seconds or the `px` parameter in milliseconds.
+ */
+exports.set = async ( key, value, ex, px ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                value,
+            ];
+
+            if ( ex ) commandArgs.push ( 'EX', String ( ex ) );
+            if ( px ) commandArgs.push ( 'PX', String ( px ) );
+
+            return await client.sendCommand ( [ 'SET', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.set expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [set]', error );
+        throw error;
+    }
+};
+
+/**
+ * Deletes a key.
+ * @param {string} key - The key to delete.
+ * @returns {Promise} - A promise that resolves with the result of the DEL command.
+ *
+ * @description This method deletes the specified key from Redis.
+ * If the key does not exist, it will simply return 0 indicating no deletion occurred.
+ * If the key is successfully deleted, it will return 1 indicating one key was deleted.
+ */
+exports.del = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            return await client.sendCommand ( [ 'DEL', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.del expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [del]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Adds one or more members to a set.
+ * @param {string} key - The key of the set.
+ * @param {string|string[]} members - The member(s) to add to the set.
+ * @returns {Promise} - A promise that resolves with the result of the SADD command.
+ *
+ * @description This method adds one or more members to the specified set in Redis.
+ * If the set does not exist, it will be created.
+ * If any member already exists in the set, it will be ignored.
+ * It returns the number of members that were added to the set.
+ */
+exports.setAdd = async ( key, members ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                ...( Array.isArray ( members ) ? members : [ members ] ),
+            ];
+
+            return await client.sendCommand ( [ 'SADD', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.setAdd expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [setAdd]', error );
+        throw error;
+    }
+};
+
+/**
+ * Removes one or more members from a set.
+ * @param {string} key - The key of the set.
+ * @param {string|string[]} members - The member(s) to remove from the set.
+ * @returns {Promise} - A promise that resolves with the result of the SREM command.
+ *
+ * @description This method removes one or more members from the specified set in Redis.
+ * If the set does not exist or if any member does not exist in the set, it will be ignored.
+ * It returns the number of members that were removed from the set.
+ */
+exports.setRemove = async ( key, members ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                ...( Array.isArray ( members ) ? members : [ members ] ),
+            ];
+
+            return await client.sendCommand ( [ 'SREM', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.setRemove expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [setRemove]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves all members of a set.
+ * @param {string} key - The key of the set.
+ * @returns {Promise} - A promise that resolves with the result of the SMEMBERS command.
+ *
+ * @description This method retrieves all members of the specified set in Redis.
+ * If the set does not exist, it will return an empty array.
+ */
+exports.setMembers = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            return await client.sendCommand ( [ 'SMEMBERS', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.setMembers expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [setMembers]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Removes and returns a random member from a set.
+ * @param {string} key - The key of the set.
+ * @returns {Promise} - A promise that resolves with the removed member, or null if the set is empty.
+ *
+ * @description
+ * This function removes and returns a random member from a set identified by the provided key.
+ * It uses the SPOP command in Redis to perform the operation.
+ *
+ * @throws {Error} If the key parameter is not a string.
+ */
+exports.setPop = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+  
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+  
+            const member = await client.sendCommand ( [ 'SPOP', ...commandArgs ] );
+        
+            // If the member is null or an empty string, return null
+            if ( member === null || member === '' ) {
+                return null;
+            }
+  
+            return member;
+        }
+  
+        throw new Error ( `redis.setPop expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [setPop]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Prepends multiple values to the head of a list.
+ * @param {string} key - The key of the list.
+ * @param {string|string[]} values - The values to prepend to the list.
+ * @returns {Promise} - A promise that resolves with the result of the LPUSH command.
+ *
+ * @description This method prepends one or more values to the head of the specified list in Redis.
+ * If the list does not exist, it will be created.
+ * The values are inserted in the same order as they are provided.
+ * It returns the length of the list after the prepend operation.
+ */
+exports.listUnshift = async ( key, values ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            if ( typeof values === 'string' ) {
+                commandArgs.push ( values );
+            }
+            else if ( Array.isArray ( values ) ) {
+                commandArgs.push ( ...values );
+            }
+            else {
+                throw new Error ( `redis.listUnshift expects a string or an array of strings as the values, instead the type provided was: ${typeof values}` );
+            }
+
+            return await client.sendCommand ( [ 'LPUSH', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.listUnshift expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [listUnshift]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Pushes values to the tail of a list.
+ * @param {string} key - The key of the list.
+ * @param {string|string[]} values - The value(s) to push to the list.
+ * @returns {Promise} - A promise that resolves with the result of the RPUSH command.
+ *
+ * @description This method pushes one or more values to the tail of the specified list in Redis.
+ * If the list does not exist, it will be created.
+ * The values are inserted in the same order as they are provided.
+ * It returns the length of the list after the push operation.
+ */
+exports.listPush = async ( key, values ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            if ( typeof values === 'string' ) {
+                commandArgs.push ( values );
+            }
+            else if ( Array.isArray ( values ) ) {
+                commandArgs.push ( ...values );
+            }
+            else {
+                throw new Error ( `redis.listPush expects a string or an array of strings as the values, instead the type provided was: ${typeof values}` );
+            }
+
+            return await client.sendCommand ( [ 'RPUSH', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.listPush expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [listPush]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Removes and returns the first element of a list.
+ * @param {string} key - The key of the list.
+ * @param {number} count - The number of items to remove (default: 0).
+ * @returns {Promise} - A promise that resolves with the result of the LPOP command.
+ *
+ * @description This method removes and returns the first element(s) from the specified list in Redis.
+ * If the list is empty or does not exist, it will return null.
+ * If the count parameter is provided, it specifies the number of items to remove.
+ * If count is greater than the number of items in the list, it will remove all items.
+ */
+exports.listPop = async ( key, count = 1 ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                String ( count ),
+            ];
+
+            return await client.sendCommand ( [ 'LPOP', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.listPop expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [listPop]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves a range of elements from a list.
+ * @param {string} key - The key of the list.
+ * @param {number} start - The starting index (default: 0).
+ * @param {number} end - The ending index (default: -1).
+ * @returns {Promise} - A promise that resolves with the result of the LRANGE command.
+ *
+ * @description This method retrieves a range of elements from the specified list in Redis.
+ * The range is specified by the start and end indices.
+ * If the list is empty or does not exist, it will return an empty array.
+ * If the end index is omitted or set to -1, it will include all elements from the start index to the end of the list.
+ */
+exports.listRange = async ( key, start = 0, end = -1 ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                String ( start ),
+                String ( end ),
+            ];
+
+            return await client.sendCommand ( [ 'LRANGE', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.listRange expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [listRange]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Retrieves the expiration time of a key in seconds.
+ * @param {string} key - The key to get the expiration time of.
+ * @returns {Promise} - A promise that resolves with the result of the TTL command.
+ *
+ * @description This method retrieves the expiration time (in seconds) of the specified key in Redis.
+ * If the key does not exist or does not have an expiration set, it will return -1.
+ * If the key exists but has no associated expiration time, it will return -1.
+ * If the key exists and has an expiration time, it will return the number of seconds remaining until the key expires.
+ */
+exports.getExpiryInSeconds = async ( key ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+            ];
+
+            return await client.sendCommand ( [ 'TTL', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.getExpiryInSeconds expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [getExpiryInSeconds]', error.stack );
+        throw error;
+    }
+};
+
+/**
+ * Sets the expiration time for a key in seconds.
+ * @param {string} key - The key to set the expiration time for.
+ * @param {number} seconds - The expiration time in seconds (default: 0).
+ * @returns {Promise} - A promise that resolves with the result of the EXPIRE command.
+ *
+ * @description This method sets the expiration time (in seconds) for the specified key in Redis.
+ * If the key does not exist, it will return 0 indicating no expiration was set.
+ * If the key is successfully set to expire, it will return 1 indicating the expiration was set.
+ */
+exports.setExpiry = async ( key, seconds = 0 ) => {
+    try {
+        if ( typeof key === 'string' ) {
+            const client = await getClient ();
+
+            const commandArgs = [
+                key.startsWith ( config.redis.prefix ) ? key : config.redis.prefix + key,
+                String ( seconds ),
+            ];
+
+            return await client.sendCommand ( [ 'EXPIRE', ...commandArgs ] );
+        }
+
+        throw new Error ( `redis.setExpiry expects a string key, instead the type provided was: ${typeof key}` );
+    }
+    catch ( error ) {
+        console.log ( 'REDIS LIB ERROR [setExpiry]', error.stack );
+        throw error;
+    }
+};
+
+exports.kill = async () => {
+    const client = await getClient ();
+    client.quit ();
+
+    return;
+};

package/src/s3.js

@@ -0,0 +1,216 @@
+/**
+ * Helpful Information
+ * ----------------------------------------------------------------
+ * 
+ * Cache-Control Directives
+ *
+ * The Cache-Control header contains directives that control the caching behavior
+ * of a resource in both client and proxy caches. These directives provide fine-grained
+ * control over how and when caches should store and serve the resource. Understanding
+ * these directives is important for optimizing caching strategies and ensuring the
+ * proper handling of cached content.
+ *
+ * - max-age: Specifies the maximum age of the resource in seconds.
+ * - s-maxage: Specifies the maximum age of the resource in shared caches (e.g., CDNs e.g., CloudFront).
+ * - public: Indicates that the response can be cached by both public and private caches.
+ * - private: Indicates that the response is intended for a single user and should not be
+ *   cached by shared caches.
+ * - no-cache: Requires the cache to revalidate the resource with the server before
+ *   serving it. The resource may still be cached, but the cache must check with the server
+ *   for any updates.
+ * - no-store: Instructs caches not to store the response under any circumstances.
+ * - must-revalidate: Requires the cache to revalidate the resource with the server before
+ *   serving it to subsequent requests. If the resource is expired, the cache must send a
+ *   conditional request to the server for revalidation.
+ * - proxy-revalidate: Similar to must-revalidate, but specifically applies to proxy caches.
+ *   Instructs proxy caches to revalidate the resource with the server, even if it has
+ *   previously been validated and marked as fresh.
+ * - no-transform: Instructs intermediaries not to modify the response, such as by
+ *   transforming the content encoding or media type.
+ * - immutable: Indicates that the resource is considered immutable and should not change.
+ *   Caches can store immutable resources indefinitely.
+ *
+ * It's important to carefully consider the appropriate combination of Cache-Control
+ * directives based on your caching requirements and the desired behavior of your
+ * client and proxy caches.
+ * 
+ * Taking care of cache-control directives will ensure cloud infrastructure costs are kept low
+ * and ensures the best CWVs performance.
+ */
+
+const { S3Client, HeadObjectCommand, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, CopyObjectCommand, DeleteObjectsCommand } = require ( '@aws-sdk/client-s3' );
+const config = require ( 'config' );
+const zlib = require ( 'zlib' );
+
+const S3 = new S3Client ( { region: 'eu-west-1' } );
+
+/**
+ * Check if an object exists in S3.
+ *
+ * @param {string} key - The object key.
+ * @param {string} [bucket=config.s3.Bucket] - The bucket name. Defaults to the configured bucket.
+ * @returns {Promise<boolean>} A promise that resolves to true if the object exists, false otherwise.
+ * @description Checks if an object with the specified key exists in S3.
+ */
+exports.exists = async ( key, bucket = config.s3.Bucket ) => {
+    try {
+        const command = new HeadObjectCommand ( {
+            Bucket: bucket,
+            Key: key
+        } );
+  
+        await S3.send ( command );
+        
+        return true;
+    }
+    catch ( error ) {
+        return false;
+    }
+};
+
+/**
+ * Get an object from S3.
+ *
+ * @param {string} key - The object key.
+ * @returns {Promise} A promise that resolves to the retrieved object.
+ * @description Retrieves an object from S3 based on the provided key.
+ */
+exports.get = async ( key ) => {
+    try {
+        const command = new GetObjectCommand ( {
+            Bucket: config.s3.Bucket,
+            Key: key
+        } );
+
+        const response = await S3.send ( command );
+        let data = await streamToBuffer ( response.Body );
+
+        if ( response.ContentEncoding && response.ContentEncoding === 'gzip' ) {
+            data = zlib.unzipSync ( data );
+        }
+
+        if ( response.ContentType !== 'application/json' ) {
+            return data.toString ( 'utf8' );
+        }
+
+        return JSON.parse ( data.toString ( 'utf8' ) );
+    }
+    catch ( error ) {
+        if ( error.Code === 'NoSuchKey' ) {
+            return null;
+        }
+
+        throw error;
+    }
+};
+
+/**
+ * Set an object in S3.
+ *
+ * @param {string} key - The object key.
+ * @param {Buffer|Uint8Array|Blob|string} body - The object body.
+ * @param {object} [options] - The optional parameters for setting the object.
+ * @param {string} [options.bucket=config.s3.Bucket] - The bucket name. Defaults to the configured bucket.
+ * @param {string} [options.contentType='application/json'] - The content type of the object. Defaults to 'application/json'.
+ * @param {string} [options.acl='public-read'] - The ACL (Access Control List) of the object. Defaults to 'public-read'.
+ * @param {string} [options.cacheControl='max-age=25,s-maxage=30,must-revalidate'] - Sets cache control for the object.
+ * @returns {Promise} A promise that resolves when the object is successfully set in S3.
+ * @description Sets an object in S3 with the provided key, body, and optional parameters.
+ */
+exports.set = async ( key, body, options = {} ) => {
+    const {
+        bucket = config.s3.Bucket,
+        contentType = 'application/json',
+        acl = 'public-read',
+        cacheControl = 'max-age=25,s-maxage=30,must-revalidate'
+    } = options;
+  
+    try {
+        const command = new PutObjectCommand ( {
+            Bucket: bucket,
+            Key: key,
+            Body: body,
+            ContentType: contentType,
+            ACL: acl,
+            CacheControl: cacheControl
+        } );
+  
+        const data = await S3.send ( command );
+  
+        return data;
+    }
+    catch ( error ) {
+        throw error;
+    }
+};
+
+/**
+ * Delete an object from S3.
+ *
+ * @param {string} key - The object key.
+ * @param {string} [bucket=config.s3.Bucket] - The bucket name. Defaults to the configured bucket.
+ * @returns {Promise} A promise that resolves when the object is successfully deleted from S3.
+ * @description Deletes an object from S3 based on the provided key.
+ */
+exports.del = async ( key, bucket = config.s3.Bucket ) => {
+    try {
+        const command = new DeleteObjectCommand ( {
+            Bucket: bucket,
+            Key: key
+        } );
+
+        const data = await S3.send ( command );
+
+        return data;
+    }
+    catch ( error ) {
+        throw error;
+    }
+};
+
+/**
+ * Move an object within S3 to a different location.
+ *
+ * @param {string} sourceKey - The source object key.
+ * @param {string} destinationKey - The destination object key.
+ * @param {string} [sourceBucket=config.s3.Bucket] - The source bucket name. Defaults to the configured bucket.
+ * @param {string} [destinationBucket=config.s3.Bucket] - The destination bucket name. Defaults to the configured bucket.
+ * @returns {Promise} A promise that resolves when the object is successfully moved in S3.
+ * @description Moves an object from the source location to the destination location within S3.
+ */
+exports.move = async ( sourceKey, destinationKey, sourceBucket = config.s3.Bucket, destinationBucket = config.s3.Bucket ) => {
+    try {
+        // Copy the object to the destination location
+        const copyCommand = new CopyObjectCommand ( {
+            CopySource: `/${sourceBucket}/${sourceKey}`,
+            Bucket: destinationBucket,
+            Key: destinationKey
+        } );
+  
+        await S3.send ( copyCommand );
+  
+        // Delete the object from the source location
+        const deleteCommand = new DeleteObjectsCommand ( {
+            Bucket: sourceBucket,
+            Delete: {
+                Objects: [
+                    { Key: sourceKey }
+                ],
+                Quiet: true
+            }
+        } );
+  
+        await S3.send ( deleteCommand );
+    }
+    catch ( error ) {
+        throw error;
+    }
+};
+
+const streamToBuffer = ( stream ) =>
+    new Promise ( ( resolve, reject ) => {
+        const chunks = [];
+        stream.on ( 'data', ( chunk ) => chunks.push ( chunk ) );
+        stream.on ( 'error', reject );
+        stream.on ( 'end', () => resolve ( Buffer.concat ( chunks ) ) );
+    } );