@skillswaveca/nova-shared-libraries 1.12.2

package/packages/drivers/src/kraken-driver.js

@@ -0,0 +1,28 @@
+import { OAuthDriver } from './oauth.js';
+
+/**
+ * KrakenDriver
+ */
+export class KrakenDriver extends OAuthDriver {
+  constructor(configuration) {
+    super('kraken', configuration);
+  }
+
+  /**
+   * Upsert a user
+   * @param user
+   * @returns {Promise<Object>}
+   */
+  upsertUser(user) {
+    return this.put('/api/v2/users', user);
+  }
+
+  /**
+   * Upsert users
+   * @param users
+   * @returns {Promise<Object>}
+   */
+  upsertUsers(users) {
+    return this.put('/api/v2/users/bulk', { users });
+  }
+}

package/packages/drivers/src/nova-driver.js

@@ -0,0 +1,32 @@
+import { DEFAULT_CONFIG } from './config.js';
+
+/**
+ * NovaDriver class to provide a common interface for all drivers.
+
+ */
+export class NovaDriver {
+
+  /**
+   * NovaDriver constructor.
+   * @param {Object} configOverrides - Configuration overrides for the Nova driver.
+   */
+  constructor(configOverrides = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...configOverrides };
+    this.log = this.config.logger;
+    this.enabled = this.config.enabled;
+    this.novaRequestId = null;
+  }
+
+  /**
+   * Provides a way to override the context of the driver. Specifically useful for logging
+   * and sending requests making use of the `distributedLoggingMiddleware` and it's reliance
+   * on the http header `x-nova-request-id`
+   *
+   * @param novaRequestId - The unique id of the request to send to external services
+   * @param log - The provided logger to use
+   */
+  useContext({ novaRequestId, log }) {
+    this.novaRequestId = novaRequestId;
+    this.log = log || this.log;
+  }
+}

package/packages/drivers/src/oauth.js

@@ -0,0 +1,145 @@
+import { ClientCredentials } from 'simple-oauth2';
+
+import { HttpDriver } from './http.js';
+import { ApiToken } from '../../nova-model/src/model/api-token.js';
+import { apiTokenRepo } from '../../nova-model/src/repo/api-token.js';
+
+import { secretsManager } from './aws/secrets-manager.js';
+
+const TOKEN_EXPIRATION_WINDOW_SECONDS = 60;
+
+/**
+ * OAuthClient class extends HttpDriver.
+ * This class is responsible for handling OAuth client operations.
+ *
+ * @extends HttpDriver
+ */
+export class OAuthDriver extends HttpDriver {
+
+  /**
+   * Creates a new instance of the OAuthClient.
+   *
+   *  *NOTE* The clientConfig object is passed directly to the simple-oauth2 library. The simle-oauth2 library doc can be found here:
+   *  https://github.com/lelylan/simple-oauth2/blob/master/API.md
+   *
+   * @constructor
+   * @param {string} apiIdentifier - The API identifier.
+   * @param configuration
+   * @param {string} configuration.baseUrl - The base URL for making HTTP requests.
+   * @param {Object} configuration.tokenConfig - The token configuration
+   * @param {Object} configuration.oauth - The client configuration.
+   * @param {Object} configuration.oauth.client - The client details.
+   * @param {string} configuration.oauth.client.id - The client ID.
+   * @param {string} configuration.oauth.client.secret - The name of a secret stored in AWS Secret Manager.
+   * @param {string} [configuration.oauth.client.secretKeyId] -  An optional id to retrieve a specific value from an AWS secret object.
+   * @param {Object} configuration.oauth.auth - The authentication details.
+   * @param {string} configuration.oauth.auth.tokenHost - The host for the token.
+   * @param {string} configuration.oauth.auth.tokenPath - The path for the token.
+   */
+  constructor(apiIdentifier, configuration = {}) {
+    const { baseUrl, oauth, tokenConfig } = configuration;
+    super(baseUrl, configuration);
+    this.log.info({ apiIdentifier, configuration }, 'OAuthClient - creating new instance');
+    this.clientConfig = oauth;
+    this.apiIdentifier = apiIdentifier;
+    this.accessToken = null;
+    this.clientCredentialsInstance = null;
+    this.tokenConfig = tokenConfig;
+    this.secretKey = oauth.client.secret;
+    this.secretKeyId = oauth.client.secretKeyId;
+  }
+
+  /**
+   * Retrieves the headers for the OAuth client, ensuring the access token is valid.
+   * @returns {Promise<Object>} The headers for the OAuth client.
+   */
+  async getHeaders() {
+    await this.ensureAccessToken();
+    this.log.trace(this.accessToken, 'OAuthClient - getHeaders, got token');
+    const { token } = this.accessToken;
+    return {
+      'Content-Type': 'application/json',
+      Authorization: `${token.token_type} ${token.access_token}`,
+    };
+  }
+
+  /**
+   * Ensures the access token is valid, retrieving a stored token or a new token as necessary.
+   * @returns {Promise<Object>} The valid access token.
+   */
+  async ensureAccessToken() {
+    if (this.accessToken && !this.accessToken.expired(TOKEN_EXPIRATION_WINDOW_SECONDS)) {
+      return this.accessToken;
+    }
+
+    const storedToken = await this.getStoredToken();
+    if (storedToken && !storedToken.expired(TOKEN_EXPIRATION_WINDOW_SECONDS)) {
+      this.accessToken = storedToken;
+      return storedToken;
+    }
+
+    const newToken = await this.getNewToken();
+    await this.storeToken(newToken);
+    this.accessToken = newToken;
+    return newToken;
+  }
+
+  /**
+   * Retrieves a new token for the OAuth client.
+   * @returns {Promise<Object>} The new token.
+   */
+  async getNewToken() {
+    const client = await this.getClientInstance();
+    try {
+      this.log.info({ apiIdentifier: this.apiIdentifier, tokenConfig: this.tokenConfig }, 'OAuthClient - getting new token');
+      return await client.getToken(this.tokenConfig, { json: true });
+    } catch (error) {
+      this.log.error({ apiIdentifier: this.apiIdentifier, error: error.message }, 'OAuthClient - error getting new token');
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves a stored token for the OAuth client.
+   * @returns {Promise<Object>} The stored token.
+   */
+  async getStoredToken() {
+    const client = await this.getClientInstance();
+    try {
+      const storedTokenData = await apiTokenRepo.get({ apiIdentifier: this.apiIdentifier });
+      const tokenJson = JSON.parse(storedTokenData.token);
+      return client.createToken(tokenJson);
+    } catch (error) {
+      this.log.warn({ apiIdentifier: this.apiIdentifier, error: error.message }, 'OAuthClient - could not retrieve existing token');
+      return undefined;
+    }
+  }
+
+  /**
+   * Stores a token for the OAuth client.
+   * @param {Object} token - The token to store.
+   * @returns {Promise<void>}
+   */
+  async storeToken(token) {
+    const tokenData = new ApiToken({
+      apiIdentifier: this.apiIdentifier,
+      token: JSON.stringify(token),
+      ttl: token.token.expires_in,
+    });
+    await apiTokenRepo.save(tokenData);
+  }
+
+  /**
+   * Retrieves an instance of the ClientCredentials class for the OAuth client.
+   * @returns {Promise<ClientCredentials>} The ClientCredentials instance.
+   */
+  async getClientInstance() {
+    if (this.clientCredentialsInstance) {
+      return this.clientCredentialsInstance;
+    }
+    if (this.secretKey) this.clientConfig.client.secret = await secretsManager.getSecret(this.secretKey, this.secretKeyId);
+    delete this.clientConfig.client.secretKeyId;
+    this.clientCredentialsInstance = new ClientCredentials(this.clientConfig);
+    return this.clientCredentialsInstance;
+  }
+}

package/packages/drivers/src/wave.js

@@ -0,0 +1,83 @@
+import { usersBelongToSameTenant } from '../../nova-utils/index.js';
+import { OAuthDriver } from './oauth.js';
+
+/**
+ * WaveDriver class to simplify making HTTP requests to a Wave API.
+ * Inherits from HttpDriver for basic HTTP request functionalities.
+ */
+export class WaveDriver extends OAuthDriver {
+
+  /**
+   * Constructs a new WaveDriver instance.
+   *
+   * @param {Object} configuration - The configuration object for the WaveDriver.
+   * @example
+   * ```
+   * new WaveDriver({
+   *   wave: {
+   *     baseUrl: 'https://wave.example.com',
+   *     enabled: true
+   *     ...
+   *   },
+   * });
+   * ```
+   **/
+  constructor(configuration) {
+    super('wave', configuration);
+  }
+
+  /**
+   * Upserts users in the Wave platform. If a user already exists, they will be updated.
+   * Refuses to upsert if users belong to multiple tenants.
+   *
+   * @param {Array<Object>} users - An array of user objects to be upserted.
+   * @returns {Promise<Object|undefined>} A promise that resolves to an empty object if successful, or is rejected if an error occurs.
+   * If the Wave driver is disabled or users belong to multiple tenants, the promise resolves to `undefined`.
+   */
+  async upsertUsers(users) {
+
+    // We expect only 1 tenant id for all the users
+    if (!usersBelongToSameTenant(users)) {
+      this.log.error('Refusing to upsert users in wave for multiple tenants');
+      return;
+    }
+
+    const url = '/api/v2/users/bulk';
+
+    this.log.debug({ 'users': users, 'url': url }, 'Upserting users in Wave');
+    const response = await this.post(url, { users }, {});
+
+    const { success, body, error } = response;
+
+    if (response.success) {
+      this.log.info({ 'response': { success, body } }, 'Users upserted in wave');
+    } else {
+      this.log.error({ 'response': { success, error } }, 'Failed to upsert users in wave');
+      throw new Error(`Failed to upsert users in Wave:  ${error}`);
+    }
+  }
+
+  /**
+   * Gets a tenant object from the Wave platform
+   *
+   * @param tenantId the guid of the tenant
+   * @returns {Promise<*>} the tenant object
+   */
+  async getTenant(tenantId) {
+    const url = `/api/v2/tenants/${tenantId}`;
+
+    this.log.debug({ tenantId, url }, 'Getting tenant from Wave');
+    const response = await this.get(url, {});
+
+    const { success, body, error } = response;
+
+    if (response.success) {
+      this.log.info({ 'response': { success, body } }, 'Tenant retrieved from wave');
+      return body;
+    } else {
+      this.log.error({ 'response': { success, error } }, 'Failed to retrieve tenant from wave');
+      throw new Error(`Failed to retrieve tenant from Wave:  ${error}`);
+    }
+
+  }
+}

package/packages/drivers/test/.eslintrc.yaml

@@ -0,0 +1,27 @@
+extends:
+  - brightspace/testing-config
+
+rules:
+  indent:
+    - error
+    - 2
+    - SwitchCase: 1
+  no-console:
+    - off
+  sort-imports:
+    - error
+    - ignoreCase: true
+      ignoreDeclarationSort: false
+      ignoreMemberSort: false
+      memberSyntaxSortOrder:
+        - none
+        - all
+        - multiple
+        - single
+      allowSeparatedGroups: true
+  import/no-extraneous-dependencies:
+    - error
+    - devDependencies:
+        - "**/test/**/*.js"
+        - "**/*.spec.js"
+        - "**/*.test.js"

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

@@ -0,0 +1,119 @@
+import { expect } from 'chai';
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import sinon from 'sinon';
+
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { DynamoDbDriver } from '../../src/aws/dynamodb.js';
+
+describe('DynamoDb', () => {
+  let dynamoDbInstance;
+  let sandbox;
+  let mockClient;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    mockClient = {
+      send: sandbox.stub().resolves({}),
+    };
+    sandbox.stub(DynamoDBDocumentClient, 'from').returns(mockClient);
+    dynamoDbInstance = new DynamoDbDriver({});
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('put', () => {
+    it('should call the put method of the DynamoDB client', async() => {
+      const params = { TableName: 'testTable', Item: { id: '1', value: 'test' } };
+
+      await dynamoDbInstance.put(params);
+
+      expect(mockClient.send.calledOnce).to.be.true;
+      // Ensure the PutCommand was instantiated with the correct parameters
+      const [putCommand] = mockClient.send.firstCall.args;
+      expect(putCommand.input).to.deep.equal(params);
+    });
+  });
+
+  describe('get', () => {
+    it('should call the get method of the DynamoDB client', async() => {
+      const params = { TableName: 'testTable', Key: { id: '1' } };
+
+      await dynamoDbInstance.get(params);
+
+      expect(mockClient.send.calledOnce).to.be.true;
+      const [getCommand] = mockClient.send.firstCall.args;
+      expect(getCommand.input).to.deep.equal(params);
+    });
+  });
+
+  describe('batchGet', () => {
+    it('should process batch get requests', async() => {
+      const params = {
+        RequestItems: {
+          'testTable': {
+            Keys: [{ id: '1' }, { id: '2' }],
+          },
+        },
+      };
+      mockClient.send.resolves({
+        Responses: { 'testTable': [{ id: '1', value: 'item1' }, { id: '2', value: 'item2' }] },
+        UnprocessedKeys: {},
+      });
+
+      const result = await dynamoDbInstance.batchGet(params);
+
+      expect(result).to.have.property('Responses').that.is.an('object');
+      expect(result.Responses['testTable']).to.have.lengthOf(2);
+    });
+  });
+
+  describe('delete', () => {
+    it('should call the delete method of the DynamoDB client', async() => {
+      const params = { TableName: 'testTable', Key: { id: '1' } };
+
+      await dynamoDbInstance.delete(params);
+
+      expect(mockClient.send.calledOnce).to.be.true;
+      const [deleteCommand] = mockClient.send.firstCall.args;
+      expect(deleteCommand.input).to.deep.equal(params);
+    });
+  });
+
+  describe('query', () => {
+    it('should call the query method of the DynamoDB client', async() => {
+      const params = { TableName: 'testTable', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': '1' } };
+
+      await dynamoDbInstance.query(params);
+
+      expect(mockClient.send.calledOnce).to.be.true;
+      const [queryCommand] = mockClient.send.firstCall.args;
+      expect(queryCommand.input).to.deep.equal(params);
+    });
+  });
+
+  describe('getAllResultsRecursive', () => {
+    it('should recursively fetch all items', async() => {
+      const params = { TableName: 'testTable', KeyConditionExpression: 'id = :id', ExpressionAttributeValues: { ':id': '1' } };
+      const itemsPage1 = Array(10).fill(null).map((_, index) => ({ id: `1-${index}` }));
+      const itemsPage2 = Array(5).fill(null).map((_, index) => ({ id: `2-${index}` }));
+
+      // Setup stub to simulate paginated response
+      mockClient.send.onFirstCall().resolves({
+        Items: itemsPage1,
+        LastEvaluatedKey: { id: '1-9' },
+      }).onSecondCall().resolves({
+        Items: itemsPage2,
+        LastEvaluatedKey: null, // Indicate no more pages
+      });
+
+      const results = await dynamoDbInstance.getAllResultsRecursive(params, [], undefined, 0, 0);
+
+      expect(results.length).to.equal(15);
+      expect(results).to.deep.include.members(itemsPage1);
+      expect(results).to.deep.include.members(itemsPage2);
+    });
+  });
+});

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

@@ -0,0 +1,146 @@
+// Import the necessary libraries
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+
+import { SecretsManager } from '../../src/aws/secrets-manager.js';
+
+describe('SecretsManager', () => {
+  let secretsManager;
+  let stubSend;
+
+  beforeEach(() => {
+    // Initialize the SecretsManager instance
+    secretsManager = new SecretsManager();
+
+    // Stub the send method of SecretsManagerClient
+    stubSend = sinon.stub(SecretsManagerClient.prototype, 'send');
+  });
+
+  afterEach(() => {
+    // Restore the stubbed send method to its original state
+    sinon.restore();
+  });
+
+  it('should fetch and return the correct secret value', async() => {
+    const secretName = 'testSecret';
+    const secretValue = 'secretValue';
+    const secretString = JSON.stringify({ [secretValue]: 'TestValue' });
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    const result = await secretsManager.getSecret(secretName);
+    expect(result).to.equal('TestValue');
+  });
+
+  it('should throw an error if secretName is not provided', async() => {
+    try {
+      await secretsManager.getSecret();
+    } catch (error) {
+      expect(error.message).to.equal('Missing secret name to fetch secret');
+    }
+  });
+
+  it('should handle and rethrow AWS SDK errors', async() => {
+    const secretName = 'invalidSecret';
+    stubSend.rejects(new Error('The requested secret does not exist'));
+
+    try {
+      await secretsManager.getSecret(secretName);
+    } catch (error) {
+      expect(error.message).to.include('SecretsManager: The requested secret does not exist');
+    }
+  });
+
+  it('should return the entire secret object if keyId is "allKeys"', async() => {
+    const secretName = 'complexSecret';
+    const secretObject = { key1: 'value1', key2: 'value2', key3: 'value3' };
+    const secretString = JSON.stringify(secretObject);
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    const result = await secretsManager.getSecret(secretName, 'allKeys');
+    expect(result).to.deep.equal(secretObject);
+  });
+
+  it('should return a specific key-value pair from the secret', async() => {
+    const secretName = 'specificKeySecret';
+    const secretObject = { specificKey: 'specificValue', otherKey: 'otherValue' };
+    const secretString = JSON.stringify(secretObject);
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    const result = await secretsManager.getSecret(secretName, 'specificKey');
+    expect(result).to.equal('specificValue');
+  });
+
+  it('should return the prod specific value if in production environment', async() => {
+    // Simulate production environment
+    secretsManager.isProdEnvironment = true;
+    const secretName = 'envSpecificSecret';
+    const secretObject = { dev: 'devValue', prod: 'prodValue' };
+    const secretString = JSON.stringify(secretObject);
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    const result = await secretsManager.getSecret(secretName);
+    expect(result).to.equal('prodValue');
+  });
+
+  it('should return the dev specific value if not in production environment', async() => {
+    // Ensure non-production environment
+    secretsManager.isProdEnvironment = false;
+    const secretName = 'envSpecificSecret';
+    const secretObject = { dev: 'devValue', unused: 'unusedValue' };
+    const secretString = JSON.stringify(secretObject);
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    const result = await secretsManager.getSecret(secretName);
+    expect(result).to.equal('devValue');
+  });
+
+  it('should throw an error if the specified keyId does not exist in the secret', async() => {
+    const secretName = 'missingKeySecret';
+    const secretObject = { existingKey: 'existingValue' };
+    const secretString = JSON.stringify(secretObject);
+
+    stubSend.resolves({
+      SecretString: secretString,
+    });
+
+    try {
+      await secretsManager.getSecret(secretName, 'nonExistingKey');
+    } catch (error) {
+      expect(error.message).to.equal('SecretsManager: nonExistingKey does not exist');
+    }
+  });
+
+  it('should log the error before rethrowing', async() => {
+    const secretName = 'erroredSecret';
+    const errorMessage = 'Simulated failure';
+    stubSend.rejects(new Error(errorMessage));
+
+    const logSpy = sinon.spy(console, 'log');
+
+    try {
+      await secretsManager.getSecret(secretName);
+    } catch (error) {
+      // The error should be logged before being rethrown
+      sinon.assert.calledWith(logSpy, sinon.match.instanceOf(Error));
+      expect(error.message).to.include(`SecretsManager: ${errorMessage}`);
+    } finally {
+      logSpy.restore();
+    }
+  });
+});