@skillswaveca/nova-shared-libraries 1.12.2

package/packages/drivers/index.js

@@ -0,0 +1,10 @@
+export * from './src/wave.js';
+export * from './src/oauth.js';
+export * from './src/nova-driver.js';
+export * from './src/kraken-driver.js';
+export * from './src/http.js';
+export * from './src/config.js';
+export * from './src/aws/sqs.js';
+export * from './src/aws/secrets-manager.js';
+export * from './src/aws/dynamodb.js';
+export * from './src/aws/aws-base-driver.js';

package/packages/drivers/package.json

@@ -0,0 +1,31 @@
+{
+  "type": "module",
+  "name": "@skillswaveca/nova-drivers",
+  "description": "Some helper drivers for AWS services",
+  "repository": "https://github.com/SkillsWave/nova-shared-libraries",
+  "version": "1.2.1",
+  "main": "index.js",
+  "scripts": {
+    "create-index": "node ../../scripts/create-index.js",
+    "generate-docs": "documentation build src/** -f html -o docs",
+    "test": "mocha --parallel 'test/**/*.test.js'"
+  },
+  "author": "SkillsWave",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "chai": "^5.1.0",
+    "eslint": "^9.0.0",
+    "mocha": "^10.4.0"
+  },
+  "dependencies": {
+    "simple-oauth2": "^5.0.0",
+    "@aws-sdk/client-dynamodb": "^3.572.0",
+    "@aws-sdk/client-secrets-manager": "^3.572.0",
+    "@aws-sdk/client-sqs": "^3.572.0",
+    "@aws-sdk/lib-dynamodb": "^3.572.0",
+    "aws-xray-sdk-core": "^3.6.0",
+    "lodash.chunk": "^4.2.0",
+    "node-fetch": "^3.1.0",
+    "pino": "^9.0.0"
+  }
+}

package/packages/drivers/src/aws/aws-base-driver.js

@@ -0,0 +1,34 @@
+import xray from 'aws-xray-sdk-core';
+import { NovaDriver } from '../nova-driver.js';
+
+/**
+ * Base driver for AWS services. You can extend this driver with any AWS service to set the client and automatically capture AWS X-Ray traces.
+ *
+ * @example
+ * import { AwsBaseDriver } from '@brightspace-ui-labs/nova/drivers';
+ *
+ * class MyAwsServiceDriver extends AwsBaseDriver {
+ *  constructor(opts) {
+ *  super(AwsServiceClient, opts);
+ *  }
+*  }
+ */
+export class AwsBaseDriver extends NovaDriver {
+
+  /**
+   * Constructor for the AWS base driver.
+   * @param clientType
+   * @param opts
+   * @param configOverrides
+   */
+  constructor(clientType, opts, configOverrides) {
+    super(configOverrides);
+    this.__client = new clientType(opts);
+    this.isProd = this.config.prod;
+    if (this.config.xray.enabled) xray.captureAWSv3Client(this.__client);
+  }
+
+  get client() {
+    return this.__client;
+  }
+}

package/packages/drivers/src/aws/dynamodb.js

@@ -0,0 +1,230 @@
+import assert from 'assert';
+
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+
+import { BatchGetCommand, DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand } from '@aws-sdk/lib-dynamodb';
+
+import { AwsBaseDriver } from './aws-base-driver.js';
+import { log } from '../../../nova-utils/src/logger.js';
+
+const DDB_WARN_TIME = 500; // milliseconds
+const DDB_WARN_RECURSION_LEVELS = 2; // recursion levels
+const ATTEMPTS = 3;
+
+/**
+ * A class which provides a simplified interface for interacting with DynamoDB.
+ *
+ * @extends AwsBaseDriver
+ */
+export class DynamoDbDriver extends AwsBaseDriver {
+  constructor(opts, config = {}) {
+    super(DynamoDBClient, opts);
+    this.log = config.log || log;
+    const marshallOptions = {
+      convertClassInstanceToMap: true,
+      removeUndefinedValues: true,
+    };
+    this.__client = DynamoDBDocumentClient.from(this.__client, { marshallOptions });
+  }
+
+  /**
+   * Recursive function to handle paged data in query results.
+   *
+   * Note: This function shouldn't be used in a production like environment. If your dynamodb query is returning this much data
+   * you should consider revising your keys to better represent your access patterns.
+   *
+   * @param {Object} params - DynamoDB query params.
+   * @param {Array} results - Array to store the results.
+   * @param {number} limit - Limit for the number of results.
+   * @param {number} level - Current recursion level.
+   * @param {number} startTime - Start time of the recursive function.
+   * @param {Object} startingParams - Initial params for the query.
+   * @returns {Promise<Array>} The results array.
+   */
+  async getAllResultsRecursive(params, results, limit, level = 0, startTime = 0, startingParams) {
+    if (level === 0) {
+      startTime = Date.now();
+      startingParams = Object.assign({}, params);
+    }
+    level++;
+
+    if (limit) {
+      params.Limit = limit - results.length;
+    }
+
+    const data = await this.query(params);
+
+    if (data?.Items?.length > 0) {
+      results.push(...data.Items);
+    }
+
+    if (data.LastEvaluatedKey) {
+      params.ExclusiveStartKey = data.LastEvaluatedKey;
+    } else if (params.ExclusiveStartKey) {
+      delete params.ExclusiveStartKey;
+    }
+
+    if (data.LastEvaluatedKey && (!limit || results.length < limit)) {
+      return await this.getAllResultsRecursive(params, results, limit, level, startTime, startingParams);
+    } else {
+      const endTime = Date.now();
+      const timeTaken = endTime - startTime;
+      if ((level >= DDB_WARN_RECURSION_LEVELS) || (timeTaken >= DDB_WARN_TIME)) {
+        this.log.warn({ startingParams, timeTaken, recursionLevel: level }, `getAllResultsRecursive: ${level} ${(level === 1) ? 'query' : 'queries'} for startingParams; took ${timeTaken} ms`);
+      }
+
+      return limit ? results.slice(0, limit) : results;
+    }
+  }
+
+  /**
+   * This function returns the array of recursively retrieved results based
+   * on a DynamoDB query with the given parameters. It uses the
+   * getAllResultsRecursive function and returns all pages of results.
+   *
+   * Note: This function shouldn't be used in a production like environment. If your dynamodb query is returning this much data
+   * you should consider revising your keys to better represent your access patterns.
+   *
+   * @param {Object} params - DynamoDB query params
+   * @returns {Array<*>} recursively retrieved results from dynamoDb query
+   */
+  async getAllResults(params) {
+    const results = [];
+    await this.getAllResultsRecursive(params, results);
+    return results?.Items || results;
+  }
+
+  /**
+   * Retrieves a limited number of paged results for a given DynamoDB query.
+   *
+   * @param {Object} params - The parameters for the DynamoDB query.
+   * @param {number} limit - The maximum number of items to fetch.
+   * @returns {Promise<Object>} A promise that resolves to an object containing the results array and possibly a LastEvaluatedKey.
+   */
+  async getPagedResults(params, limit) {
+    const results = [];
+    await this.getAllResultsRecursive(params, results, limit);
+    return {
+      Items: results?.Items || results,
+      LastEvaluatedKey: params.ExclusiveStartKey,
+    };
+  }
+
+  /**
+   * Performs a batch get operation on DynamoDB.
+   *
+   * @param {Object} params - The parameters for the batch get operation.
+   * @returns {Promise<Object>} A promise that resolves to the results of the batch get operation.
+   */
+  async batchGet(params) {
+    const results = {};
+    let callParams = Object.assign({}, params);
+    let attempts = 0;
+
+    /* eslint-disable no-await-in-loop */
+    while (attempts < ATTEMPTS) {
+      attempts += 1;
+
+      const { Responses, UnprocessedKeys } = await this._call(callParams, BatchGetCommand);
+
+      Object.entries(Responses).forEach(([tableName, responses]) => {
+        results[tableName] = (results[tableName] || []).concat(responses);
+      });
+
+      if (Object.keys(UnprocessedKeys).length > 0) {
+        callParams = Object.assign({}, callParams, {
+          RequestItems: UnprocessedKeys,
+        });
+      } else {
+        return { Responses: results };
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+
+    throw new Error({
+      message: 'unable to fetch all requested items after too many retries',
+    });
+  }
+
+  /**
+   * Deletes an item from DynamoDB.
+   *
+   * @param {Object} params - The parameters for the delete operation.
+   * @returns {Promise<Object>} A promise that resolves to the result of the delete operation.
+   */
+  delete(params) {
+    return this._call(params, DeleteCommand);
+  }
+
+  /**
+   * Retrieves an item from DynamoDB.
+   *
+   * @param {Object} params - The parameters for the get operation.
+   * @returns {Promise<Object>} A promise that resolves to the retrieved item.
+   */
+  get(params) {
+    return this._call(params, GetCommand);
+  }
+
+  /**
+   * Inserts or replaces an item in DynamoDB.
+   *
+   * @param {Object} params - The parameters for the put operation.
+   * @returns {Promise<Object>} A promise that resolves to the result of the put operation.
+   */
+  put(params) {
+    return this._call(params, PutCommand);
+  }
+
+  /**
+   * Queries DynamoDB and returns the matching items.
+   *
+   * @param {Object} params - The parameters for the query operation.
+   * @returns {Promise<Object>} A promise that resolves to the results of the query.
+   */
+  query(params) {
+    return this._call(params, QueryCommand);
+  }
+
+  /**
+   * Updates an existing item in DynamoDB.
+   *
+   * @param {Object} params - The parameters for the update operation.
+   * @returns {Promise<Object>} A promise that resolves to the result of the update operation.
+   */
+  update(params) {
+    return this._call(params, UpdateCommand);
+  }
+
+  /**
+   * A private helper method to abstract common logic for making calls to DynamoDB.
+   *
+   * @param {Object} params - The parameters for the DynamoDB operation.
+   * @param {Function} method - The DynamoDB operation to perform.
+   * @returns {Promise<Object>} A promise that resolves to the result of the DynamoDB operation.
+   * @private
+   */
+  async _call(params, method) {
+    assert(params, 'missing params');
+    assert(method, 'missing method');
+
+    this.log.trace({ params }, `making DynamoDB call: ${method.name}`);
+    try {
+      return await this.__client.send(new method(params));
+    } catch (error) {
+      const message = `failed to make DynamoDB call: ${method.name}`;
+      this.log.error({
+        params,
+        error: {
+          message: error.message,
+          stack: error.stack,
+          code: error.code,
+          statusCode: error.statusCode,
+          requestId: error.requestId,
+        },
+      }, message);
+
+      throw error;
+    }
+  }
+}

package/packages/drivers/src/aws/secrets-manager.js

@@ -0,0 +1,52 @@
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import { AwsBaseDriver } from './aws-base-driver.js';
+
+/**
+ * SecretsManager class to simplify fetching secrets from AWS Secret Manager.
+ */
+export class SecretsManager extends AwsBaseDriver {
+  constructor() {
+    super(SecretsManagerClient, {
+      region: process.env.AWS_REGION || 'us-east-1',
+    });
+  }
+
+  /**
+   * This function wraps the AWS-provided action "GetSecretValue", and converts it into
+   * a thenable promise. The function will attempt to return any secret matching the
+   * provided secret name, assuming the proper IAM role is in place.
+   *
+   * Currently, we rethrow the exception by default.
+   *
+   * For more info:
+   * See https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html
+   *
+   * @param {*} secretName - The name of the secret stored in AWS Secret Manager.
+   * @param {string} [keyId] - An optional key to retrieve a specific value from an AWS secret object.
+   * @returns - The secret value. If the secret was created via the web interface, this string
+   *  is a JSON. Otherwise (e.g. via the API), this string is the secret itself.
+   */
+  async getSecret(secretName, keyId) {
+    if (!secretName) throw new Error('Missing secret name to fetch secret');
+
+    try {
+      const data = await this.client.send(new GetSecretValueCommand({ SecretId: secretName }));
+      const DEFAULT_SECRET_KEY = 'secretValue';
+      const ALL_KEYS = 'allKeys';
+      const secretData = JSON.parse(data.SecretString);
+      const secretKey = keyId ?? DEFAULT_SECRET_KEY;
+
+      if (keyId === ALL_KEYS) return secretData;
+      if (secretData[secretKey]) return secretData[secretKey];
+      if (!keyId && this.isProdEnvironment && secretData.prod) return secretData.prod;
+      if (!keyId && secretData.dev) return secretData.dev;
+
+      throw new Error(`${keyId || 'env value'} does not exist`);
+    } catch (error) {
+      this.log.error({ secretName, message: error.message }, 'Failed getting secret');
+      throw new Error(`SecretsManager: ${error.message}`);
+    }
+  }
+}
+
+export const secretsManager = new SecretsManager();

package/packages/drivers/src/aws/sqs.js

@@ -0,0 +1,140 @@
+import assert from 'assert';
+import chunk from 'lodash.chunk';
+
+import { SendMessageBatchCommand, SQS } from '@aws-sdk/client-sqs';
+
+import { AwsBaseDriver } from './aws-base-driver.js';
+import { log } from '../../../nova-utils/src/logger.js';
+
+const BATCH_SIZE = 10;
+const RETRY_COUNT = 2;
+
+/**
+ * SQSDriver class to simplify sending messages to an SQS queue.
+ */
+export class SQSDriver extends AwsBaseDriver {
+  constructor() {
+    super(SQS);
+  }
+
+  /**
+   * Send messages to an SQS queue.
+   * @param queueUrl The URL of the SQS queue.
+   * @param items The items to send to the SQS queue.
+   * @param retryCount The number of times to retry sending the messages to the SQS queue.
+   * @returns {Promise<Awaited<*|ChangeMessageVisibilityBatchResultEntry[]|DeleteMessageBatchResultEntry[]|SendMessageBatchResultEntry[]|*[]|undefined>[]>}
+   */
+  send(queueUrl, items, retryCount) {
+    const messages = [].concat(items);
+    return this._sendBatch(queueUrl, messages, retryCount);
+  }
+
+  /**
+   * @private
+   * Get the entries for a batch of messages.
+   *
+   * @param batch
+   * @returns {*}
+   * @private
+   */
+  _getEntriesForBatch(batch) {
+    return batch.map(({ body, delaySeconds, messageAttributes, dedupId, groupId }, index) => {
+      const entry = {
+        Id: index.toString(),
+        MessageBody: JSON.stringify(body),
+      };
+
+      if (delaySeconds) {
+        entry.DelaySeconds = delaySeconds;
+      }
+
+      if (messageAttributes) {
+        entry.MessageAttributes = Object.keys(messageAttributes).reduce((acc, key) => {
+          const value = messageAttributes[key];
+          return Object.assign(acc, {
+            [key]: {
+              DataType: `String.${typeof value}`,
+              StringValue: value.toString(),
+            },
+          });
+        }, {});
+      }
+
+      if (dedupId) {
+        entry.MessageDeduplicationId = dedupId;
+      }
+
+      if (groupId) {
+        entry.MessageGroupId = groupId;
+      }
+
+      return entry;
+    });
+  }
+
+  /**
+   * @private
+   *
+   * Send a batch of messages to an SQS queue.
+   *
+   * @param queueUrl
+   * @param messages
+   * @param retryCount
+   * @returns {Promise<Awaited<*|ChangeMessageVisibilityBatchResultEntry[]|DeleteMessageBatchResultEntry[]|SendMessageBatchResultEntry[]|*[]|undefined>[]>}
+   * @private
+   */
+  _sendBatch(queueUrl, messages, retryCount = RETRY_COUNT) {
+    assert(queueUrl, 'missing queueUrl');
+    assert(messages, 'missing messages');
+
+    const chunks = chunk(messages, BATCH_SIZE);
+    return Promise.all(chunks.map(async batch => {
+      const params = {
+        QueueUrl: queueUrl,
+        Entries: this._getEntriesForBatch(batch),
+      };
+
+      log.info({ params }, 'sending SQS messages');
+      try {
+        const data = await this.client.send(new SendMessageBatchCommand(params));
+        const successful = data.Successful || [];
+
+        if (data.Failed && data.Failed.length) {
+          if (!retryCount) {
+            throw new Error({
+              message: 'failed to send messages to SQS queue due to retry limit reached',
+              details: {
+                failed: data.Failed,
+                params,
+              },
+            });
+          }
+
+          const failedMessages = data.Failed.map(failed => {
+            if (failed.SenderFault) {
+              throw new Error({
+                message: 'failed to send messages to SQS queue due to sender fault',
+                details: {
+                  failed,
+                  params,
+                },
+              });
+            }
+            return batch[failed.Id];
+          });
+
+          return this._sendBatch(queueUrl, failedMessages, retryCount - 1)
+            .then(result => successful.concat(result[0]));
+        }
+        return successful;
+      } catch (err) {
+        log.error({ params, err }, 'failed to send messages to SQS queue');
+        throw new Error({
+          message: 'failed to send messages to SQS queue',
+          cause: err,
+          details: { params },
+        });
+      }
+    }));
+  }
+}

package/packages/drivers/src/config.js

@@ -0,0 +1,13 @@
+import yn from 'yn';
+
+import { log } from '../../nova-utils/src/logger.js';
+
+export const DEFAULT_CONFIG = {
+  aws: {
+    region: 'us-east-1',
+  },
+  xray: {
+    enabled: yn(process.env.XRAY_ENABLED),
+  },
+  logger: log,
+};

package/packages/drivers/src/http.js

@@ -0,0 +1,162 @@
+// eslint-disable-next-line no-shadow
+import fetch from 'node-fetch';
+import { NovaDriver } from './nova-driver.js';
+
+/**
+ * HttpDriver class to simplify making HTTP requests.
+ *
+ * @extends NovaDriver
+ */
+export class HttpDriver extends NovaDriver {
+
+  /**
+   * HttpDriver constructor.
+   *
+   * @param {string} baseUrl - The base URL for the HTTP driver.
+   * @param {Object} configOverrides - Configuration overrides for the HTTP driver.
+   */
+  constructor(baseUrl, configOverrides = {}) {
+    super(configOverrides);
+    this.baseUrl = baseUrl;
+  }
+
+  /**
+   * This doesn't need to be async, but it is for other drivers that might need to do async work to get the headers
+   * @returns {Promise<{"Content-Type": string}>}
+   */
+  async getHeaders() {
+    return {
+      'Content-Type': 'application/json',
+    };
+  }
+
+  /**
+   * Send a POST request.
+   *
+   * @param {string} path - The path for the POST request.
+   * @param {Object} body - The body of the POST request.
+   * @param {Object} headers - The headers for the POST request.
+   * @returns {Promise<Object>} The response from the POST request.
+   */
+  async post(path, body, headers = {}) {
+    return await this._request('POST', path, body, headers);
+  }
+
+  /**
+   * Send a PUT request.
+   *
+   * @param {string} path - The path for the PUT request.
+   * @param {Object} body - The body of the PUT request.
+   * @param {Object} headers - The headers for the PUT request.
+   * @returns {Promise<Object>} The response from the PUT request.
+   */
+  async put(path, body, headers = {}) {
+    return await this._request('PUT', path, body, headers);
+  }
+
+  /**
+   * Send a PATCH request.
+   *
+   * @param {string} path - The path for the PATCH request.
+   * @param {Object} body - The body of the PATCH request.
+   * @param {Object} headers - The headers for the PATCH request.
+   * @returns {Promise<Object>} The response from the PATCH request.
+   */
+  async patch(path, body, headers = {}) {
+    return await this._request('PATCH', path, body, headers);
+  }
+
+  /**
+   * Send a GET request.
+   *
+   * @param {string} path - The path for the GET request.
+   * @param {Object} headers - The headers for the GET request.
+   * @returns {Promise<Object>} The response from the GET request.
+   */
+  async get(path, headers = {}) {
+    return await this._request('GET', path, {}, headers);
+  }
+
+  /**
+   * Send a DELETE request.
+   * @param {string} path - The path for the DELETE request.
+   * @param {Object} headers - The headers for the DELETE request.
+   * @returns {Promise<Object>} The response from the DELETE request.
+   */
+  async delete(path, headers = {}) {
+    return await this._request('DELETE', path, {}, headers);
+  }
+
+  /**
+   * @private
+   * Handle the response from the HTTP request.
+   *
+   * @param {string} url - The URL of the request.
+   * @param {Object} options - The options used for the request.
+   * @param {Object} response - The response from the request.
+   * @returns {Promise<Object>} The processed response.
+   */
+  async _handleResponse(url, options, response) {
+    if (!response) {
+      return { success: false, error: 'No response' };
+    }
+    const success = response.status >= 200 && response.status <= 299;
+    let body;
+    let error;
+
+    if (success) {
+      this.log.trace({ url: url, method: options.method, status: response.status }, 'HTTP request successful');
+      body = await response.json();
+    } else {
+      this.log.error({ url: url, method: options.method, status: response.status }, 'HTTP request failed');
+      error = await response.text();
+    }
+
+    return { success, body, error };
+  }
+
+  /**
+   * @private
+   *
+   * Send a HTTP request.
+   * @param {string} method - The HTTP method for the request.
+   * @param {string} path - The path for the request.
+   * @param {Object} body - The body of the request.
+   * @param {Object} headers - The headers for the request.
+   * @returns {Promise<Object>} The response from the request.
+   */
+  async _request(method, path, body = {}, headers = {}) {
+    if (!this.enabled) {
+      this.log.warn({ baseUrl: this.baseUrl }, 'Driver is disabled');
+      return { success: false, error: 'Driver is disabled' };
+    }
+    const url = `${this.baseUrl}${path}`;
+    const options = {
+      method,
+      headers: {
+        ...await this.getHeaders(),
+        ...headers,
+      },
+    };
+
+    if (this.novaRequestId) {
+      options.headers = { ...options.headers, 'x-nova-request-id': this.novaRequestId };
+    }
+
+    if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+      options.body = JSON.stringify(body);
+    }
+
+    try {
+      const response = await this._fetch(url, options);
+      return await this._handleResponse(url, options, response);
+    } catch (error) {
+      this.log.error({ url: url, method: method, error, message: error.message }, 'HTTP request failed');
+      return { success: false, error: error.message };
+    }
+  }
+
+  _fetch(...args) {
+    return fetch(...args);
+  }
+}