@skillswaveca/nova-shared-libraries 1.12.2

package/packages/nova-utils/index.js

@@ -0,0 +1,3 @@
+export * from './src/tenant-utils.js';
+export * from './src/logger.js';
+export * from './src/config.js';

package/packages/nova-utils/package.json

@@ -0,0 +1,19 @@
+{
+  "type": "module",
+  "name": "@skillswaveca/nova-utils",
+  "description": "A collection of random utils used in nova repos",
+  "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": {
+  },
+  "dependencies": {
+  }
+}

package/packages/nova-utils/src/config.js

@@ -0,0 +1,228 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import yn from 'yn';
+import { log } from './logger.js';
+
+/**
+ * Recursively merges two objects deeply, combining nested objects from both objects.
+ * It overrides the values from the first object with those from the second object.
+ * @param {Object} obj1 - The first object to merge.
+ * @param {Object} obj2 - The second object to merge, whose properties will override those of the first.
+ * @returns {Object} - The resulting merged object.
+ */
+export const deepMerge = (obj1, obj2) => {
+  const output = Object.assign({}, obj1);
+  for (const key in obj2) {
+    if (obj2[key]) {
+      if (typeof obj2[key] === 'object' && obj2[key] !== null && obj1[key]) {
+        output[key] = deepMerge(obj1[key], obj2[key]);
+      } else {
+        output[key] = obj2[key];
+      }
+    }
+  }
+  return output;
+};
+
+/**
+ * Flattens a nested object into a single-level object with underscore-separated keys.
+ *
+ *
+ * @param {Object} data - The nested object to flatten.
+ * @param {string} prefix - The prefix to prepend to each key in the flattened object.
+ * @returns {Object} - The flattened object with concatenated keys separated by underscores.
+ */
+export const flattenConfig = (data, prefix = '') => {
+  return Object.keys(data).reduce((acc, key) => {
+    const fullPath = prefix.length ? `${prefix}_${key}` : key;
+    if (typeof data[key] === 'object' && data[key] !== null && !Array.isArray(data[key])) {
+      Object.assign(acc, flattenConfig(data[key], fullPath));
+    } else {
+      acc[fullPath] = `${data[key]}`;
+    }
+    return acc;
+  }, {});
+};
+
+/**
+ * Converts a string value to a number or boolean if applicable. It is intentionally very naive, only checking for 'true' 'false' and numbers.
+ * It is only used for converting environment variables, so it is not expected to be used for general purpose type conversion.
+ *
+ * @param value
+ * @returns {*|number|boolean}
+ */
+const convertToType = value => {
+  if (!isNaN(parseFloat(value)) && isFinite(value)) {
+    return parseFloat(value);
+  }
+  if (value.toLowerCase() === 'true') {
+    return true;
+  }
+  if (value.toLowerCase() === 'false') {
+    return false;
+  }
+  return value;
+};
+
+/**
+ * Unflattens a configuration object whose keys are paths (using underscores as separators),
+ * ignoring specific top-level attributes.
+ * @param {Object} flatConfig - The flat configuration object, defaulting to process.env.
+ * @param {Array} ignoreList - List of top-level attribute keys to ignore.
+ * @returns {Object} - The reconstructed nested configuration object.
+ */
+export const unflattenConfig = (flatConfig = process.env, ignoreList = ['LAMBDA', 'LD', 'PATH', 'PWD', 'NODE', '', 'SHLVL']) => {
+  const result = {};
+  for (const [key, value] of Object.entries(flatConfig)) {
+    try {
+      const parts = key.split('_'); // Split the key into parts based on underscore
+      let current = result;
+
+      // Check if the first part is in the ignore list, skip if it is
+      if (ignoreList.includes(parts[0])) {
+        continue; // Skip the rest of the loop and do not add this key-value pair
+      }
+
+      // Iterate over the parts to build the nested structure
+      parts.forEach((part, i) => {
+        if (i === parts.length - 1) {
+          // If it's the last part, set the value
+          current[part] = convertToType(value);
+        } else {
+          // If not, update current point in the structure, initializing if necessary
+          current[part] = current[part] || {};
+          current = current[part];
+        }
+      });
+    } catch (err) {
+      // we are going to ignore errors here
+    }
+  }
+  return result;
+};
+
+/**
+ * Retrieves and validates the OAuth configuration for a specified driver from environment variables.
+ * Throws an error if any required configuration is missing.
+ *
+ * @param {string} driverName - The name of the driver for which the configuration is requested.
+ * @returns {Object} The complete and validated configuration object for the specified driver.
+ * @throws {Error} If the required configuration is missing.
+ */
+export const getOauthDriverConfig = driverName => {
+  const unflattenedConfig = unflattenConfig();
+  const driverConfig = unflattenedConfig.drivers?.[driverName];
+  const authConfig = unflattenedConfig.auth;
+  const disabledConfig = {
+    name: driverName,
+    enabled: false,
+  };
+
+  if (!driverConfig || !authConfig) {
+    log.warn({ driverConfig, authConfig }, `Missing configuration for ${driverName}`);
+    return disabledConfig;
+  }
+  // Check for essential configuration components
+  const requiredFields = ['enabled', 'baseUrl', 'audience', 'clientId', 'clientSecretName', 'tokenHost', 'tokenPath'];
+  const missingFields = requiredFields.filter(field => typeof driverConfig[field] === 'undefined' && typeof authConfig[field] === 'undefined');
+
+  if (missingFields.length > 0) {
+    log.warn({ missingFields, driverName }, 'Missing configuration fields for');
+    return disabledConfig;
+  }
+
+  return {
+    name: driverName,
+    enabled: yn(driverConfig.enabled, { default: false }),
+    baseUrl: driverConfig.baseUrl,
+    tokenConfig: {
+      audience: driverConfig.audience,
+    },
+    oauth: {
+      client: {
+        id: authConfig.clientId,
+        secret: authConfig.clientSecretName,
+      },
+      auth: {
+        tokenHost: authConfig.tokenHost,
+        tokenPath: authConfig.tokenPath,
+      },
+    },
+  };
+};
+
+/**
+ * Retrieves and validates the standard configuration for a specified driver from environment variables.
+ *
+ * @param driverName
+ * @returns {{[p: string]: *}}
+ */
+export const getStandardDriverConfig = driverName => {
+  const driverConfig = unflattenConfig().drivers?.[driverName];
+
+  if (!driverConfig) {
+    return {
+      name: driverName,
+      enabled: false,
+    };
+  }
+  return {
+    name: driverName,
+    ...driverConfig,
+    enabled: yn(driverConfig.enabled, { default: false }),
+  };
+};
+
+/**
+ * Reads all JSON files in a directory and returns an object with the file names as keys and the parsed JSON content as values.
+ *
+ * @param dir - The directory to read JSON files from.
+ * @returns {{}}  - An object with the file names as keys and the parsed JSON content as values.
+ */
+const readJsonFiles = dir => {
+  return fs.readdirSync(dir)
+    .filter(file => path.extname(file) === '.json')
+    .reduce((acc, file) => {
+      acc[path.basename(file, '.json')] = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+      return acc;
+    }, {});
+};
+
+/**
+ * The nova stage configurator class
+ */
+export class NovaStageConfig {
+
+  /**
+   *  Creates a new NovaStageConfig instance with the specified base configuration and stage overrides.
+   *
+   * @param {Object} baseConfig - The default configuration object that will be used as the base.
+   * @param stageConfig - The stage configuration object or the path to the directory containing stage-specific JSON files.
+   */
+  constructor(baseConfig, stageConfig) {
+    this.baseConfig = baseConfig;
+    this.stages = typeof stageConfig === 'string' ? readJsonFiles(stageConfig) : stageConfig;
+    if (!this.baseConfig) {
+      throw new Error('NovaConfig requires a base configuration object to be provided.');
+    }
+    if (!this.stages) {
+      throw new Error('NovaConfig requires a stages configuration object to be provided.');
+    }
+  }
+
+  /**
+   * Creates a configuration object for a specific stage by merging the default configuration
+   * with any overrides defined for that stage. If no specific configuration is found for the stage,
+   * it falls back to the 'dev' stage configuration.
+   *
+   * @param {string} stage - The stage for which the configuration is needed, typically corresponds
+   *                         to different deployment environments (e.g., 'prod', 'dev').
+   * @returns {Object} - The merged configuration object that combines the default settings with
+   *                     any stage-specific overrides.
+   */
+  createConfigForStage(stage) {
+    const stageConfig = this.stages[stage] || this.stages.dev;
+    return deepMerge(this.baseConfig(stage), stageConfig);
+  }
+}

package/packages/nova-utils/src/logger.js

@@ -0,0 +1,26 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import pino from 'pino';
+
+const base = null;
+const level = process.env.LOG_LEVEL || 'info';
+const redact = {
+  paths: [
+    'context.log',
+    'context.drivers',
+    'context.config',
+    'event.Records[*].dynamodb',
+  ],
+  remove: true,
+};
+const serializers = pino.stdSerializers;
+const logger = pino({ base, level, redact, serializers });
+
+export const asyncLocalStorage = new AsyncLocalStorage();
+
+const getAsyncData = () => {
+  return asyncLocalStorage.getStore() || {};
+};
+
+export default logger;
+
+export const log = logger.child(getAsyncData());

package/packages/nova-utils/src/tenant-utils.js

@@ -0,0 +1,27 @@
+/**
+ * Takes an array of users and splits them into a map of tenantId to users
+ *
+ * @param {array} users An array of fuss users
+ */
+export const mapUsersByTenant = users => {
+  const usersByTenantId = {};
+  users.forEach(user => {
+    if (!usersByTenantId[user.tenantId]) {
+      usersByTenantId[user.tenantId] = [];
+    }
+    usersByTenantId[user.tenantId].push(user);
+  });
+
+  return usersByTenantId;
+};
+
+/**
+ * Takes an array of users and returns true if they all belong to the same tenant
+ *
+ * @param users
+ * @returns {boolean}
+ */
+export const usersBelongToSameTenant = users => {
+  const tenantIds = [...new Set(users.map(user => user.tenantId))];
+  return tenantIds.length <= 1;
+};

package/packages/nova-utils/test/config.test.js

@@ -0,0 +1,250 @@
+import { expect } from 'chai';
+
+import {
+  deepMerge,
+  flattenConfig,
+  getOauthDriverConfig, NovaStageConfig,
+  unflattenConfig
+} from '../src/config.js';
+
+describe('config', function() {
+  describe('flattenConfig', () => {
+    it('should flatten a nested object', () => {
+      const nested = { a: { b: { c: 1 } } };
+      const result = flattenConfig(nested);
+      expect(result).to.deep.equal({ 'a_b_c': '1' });
+    });
+
+    it('should handle arrays as values without flattening them', () => {
+      const data = { a: { b: [1, 2, 3] } };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a_b': '1,2,3' });
+    });
+
+    it('should handle multiple nested levels', () => {
+      const data = { a: { b: { c: { d: 1 } } } };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a_b_c_d': '1' });
+    });
+
+    it('should preserve simple key-value pairs', () => {
+      const data = { a: 1, b: 2 };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a': '1', 'b': '2' });
+    });
+
+    it('should correctly prepend a prefix if provided', () => {
+      const data = { a: 1 };
+      const result = flattenConfig(data, 'prefix');
+      expect(result).to.deep.equal({ 'prefix_a': '1' });
+    });
+  });
+
+  describe('deepMerge', () => {
+    it('should merge two simple objects', () => {
+      const obj1 = { a: 1 };
+      const obj2 = { b: 2 };
+      const result = deepMerge(obj1, obj2);
+      expect(result).to.deep.equal({ a: 1, b: 2 });
+    });
+
+    it('should override properties from the first object', () => {
+      const obj1 = { a: 1, b: 2 };
+      const obj2 = { b: 3 };
+      const result = deepMerge(obj1, obj2);
+      expect(result.b).to.equal(3);
+    });
+
+    it('should merge nested objects', () => {
+      const obj1 = { a: { x: 1 } };
+      const obj2 = { a: { y: 2 } };
+      const result = deepMerge(obj1, obj2);
+      expect(result).to.deep.equal({ a: { x: 1, y: 2 } });
+    });
+
+    it('should handle null values correctly', () => {
+      const obj1 = { a: null };
+      const obj2 = { a: { b: 1 } };
+      const result = deepMerge(obj1, obj2);
+      expect(result).to.deep.equal({ a: { b: 1 } });
+    });
+
+    it('should ignore undefined values', () => {
+      const obj1 = { a: 1 };
+      const obj2 = { b: undefined };
+      const result = deepMerge(obj1, obj2);
+      expect(result).to.have.property('a');
+      expect(result).to.not.have.property('b');
+    });
+  });
+
+  describe('flattenConfig', () => {
+    it('should flatten a nested object', () => {
+      const nested = { a: { b: { c: 1 } } };
+      const result = flattenConfig(nested);
+      expect(result).to.deep.equal({ 'a_b_c': '1' });
+    });
+
+    it('should handle arrays as values without flattening them', () => {
+      const data = { a: { b: [1, 2, 3] } };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a_b': '1,2,3' });
+    });
+
+    it('should handle multiple nested levels', () => {
+      const data = { a: { b: { c: { d: 1 } } } };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a_b_c_d': '1' });
+    });
+
+    it('should preserve simple key-value pairs', () => {
+      const data = { a: 1, b: 2 };
+      const result = flattenConfig(data);
+      expect(result).to.deep.equal({ 'a': '1', 'b': '2' });
+    });
+
+    it('should correctly prepend a prefix if provided', () => {
+      const data = { a: 1 };
+      const result = flattenConfig(data, 'prefix');
+      expect(result).to.deep.equal({ 'prefix_a': '1' });
+    });
+  });
+
+  describe('unflattenConfig', () => {
+    it('should correctly reconstruct a simple flattened object', () => {
+      const flat = { 'a_b_c': '1' };
+      const result = unflattenConfig(flat);
+      expect(result).to.deep.equal({ a: { b: { c: 1 } } });
+    });
+
+    it('should ignore specified top-level attributes', () => {
+      const flat = { 'AWS_key': 'value', 'config_version': '1.0' };
+      const result = unflattenConfig(flat, ['AWS']);
+      expect(result).to.deep.equal({ config: { version: 1.0 } });
+    });
+
+    it('should handle keys with multiple underscores correctly', () => {
+      const flat = { 'a_b_c_d': '1' };
+      const result = unflattenConfig(flat);
+      expect(result).to.deep.equal({ a: { b: { c: { d: 1 } } } });
+    });
+
+    it('should reconstruct an object without ignoring any keys when no ignore list is provided', () => {
+      const flat = { 'a_b': '1', 'c_d': '2' };
+      const result = unflattenConfig(flat);
+      expect(result).to.deep.equal({ a: { b: 1 }, c: { d: 2 } });
+    });
+
+    it('should handle empty values and keys correctly', () => {
+      const flat = { 'a_b': '', 'c_': '2' };
+      const result = unflattenConfig(flat);
+      expect(result).to.deep.equal({ a: { b: '' }, c: { '': 2 } });
+    });
+  });
+  describe('getOauthDriverConfig', () => {
+    beforeEach(() => {
+      process.env = flattenConfig({
+        auth: {
+          clientId: 'client-id',
+          clientSecretName: 'client-secret',
+          tokenHost: 'http://auth.example.com',
+          tokenPath: '/token',
+        },
+        drivers: {
+          wave: {
+            enabled: true,
+            baseUrl: 'http://example.com',
+            audience: 'http://api.example.com',
+          },
+        },
+      });
+    });
+
+    it('should return configuration for a specified driver', () => {
+      const config = getOauthDriverConfig('wave');
+      expect(config).to.deep.include({
+        name: 'wave',
+        enabled: true,
+        baseUrl: 'http://example.com',
+        tokenConfig: {
+          audience: 'http://api.example.com',
+        },
+      });
+    });
+
+    it('should handle non-existent drivers gracefully', () => {
+      const config = getOauthDriverConfig('nonexistent');
+
+      expect(config).to.deep.equal({ enabled: false, name: 'nonexistent' });
+    });
+
+    it('should include all necessary OAuth details', () => {
+      const config = getOauthDriverConfig('wave');
+      expect(config.oauth).to.deep.include({
+        client: {
+          id: 'client-id',
+          secret: 'client-secret',
+        },
+        auth: {
+          tokenHost: 'http://auth.example.com',
+          tokenPath: '/token',
+        },
+      });
+    });
+
+    it('should correctly handle missing parts of the configuration', () => {
+      process.env = flattenConfig({
+        drivers: {
+          wave: {
+            enabled: true,
+          },
+        },
+      });
+      const config = getOauthDriverConfig('wave');
+      expect(config).to.deep.equal({ enabled: false, name: 'wave' });
+    });
+  });
+
+  describe('createConfigForStage', () => {
+    const defaultConfig = { api: { url: 'http://default.com' }, featureToggle: { newFeature: false } };
+    const stages = {
+      dev: { featureToggle: { newFeature: true } },
+      prod: { api: { url: 'http://prod.com' } },
+    };
+    const stageConfig = new NovaStageConfig(() => defaultConfig, stages);
+
+    it('should merge stage specific configurations over default configurations', () => {
+      const config = stageConfig.createConfigForStage('prod');
+      expect(config).to.deep.equal({
+        api: { url: 'http://prod.com' },
+        featureToggle: { newFeature: false },
+      });
+    });
+
+    it('should fall back to dev stage if specified stage is not found', () => {
+      const config = stageConfig.createConfigForStage('test');
+      expect(config).to.deep.equal({
+        api: { url: 'http://default.com' },
+        featureToggle: { newFeature: true },
+      });
+    });
+
+    it('should return the default configuration if no stages are defined', () => {
+      const sc = new NovaStageConfig(() => defaultConfig, {});
+      const config = sc.createConfigForStage('dev');
+      expect(config).to.deep.equal(defaultConfig);
+    });
+
+    it('should handle empty default and stage configurations', () => {
+      const sc = new NovaStageConfig(() => {}, {});
+      const config = sc.createConfigForStage('empty');
+      expect(config).to.deep.equal({});
+    });
+
+    it('should not modify the original default configuration object', () => {
+      const originalDefaultConfig = { ...defaultConfig };
+      stageConfig.createConfigForStage('prod');
+      expect(defaultConfig).to.deep.equal(originalDefaultConfig);
+    });
+  });
+});

package/packages/nova-utils/test/tenant-utiils.test.js

@@ -0,0 +1,50 @@
+import { expect } from 'chai';
+import { mapUsersByTenant, usersBelongToSameTenant } from '../src/tenant-utils.js';
+
+describe('tenant-utils', function() {
+  describe('mapUsersByTenant', function() {
+    it('should return an empty object for an empty array', function() {
+      const result = mapUsersByTenant([]);
+      expect(result).to.deep.equal({});
+    });
+
+    it('should correctly map users by tenantId', function() {
+      const users = [
+        { tenantId: '1', name: 'User 1' },
+        { tenantId: '2', name: 'User 2' },
+        { tenantId: '1', name: 'User 3' },
+      ];
+      const expected = {
+        '1': [{ tenantId: '1', name: 'User 1' }, { tenantId: '1', name: 'User 3' }],
+        '2': [{ tenantId: '2', name: 'User 2' }],
+      };
+      const result = mapUsersByTenant(users);
+      expect(result).to.deep.equal(expected);
+    });
+  });
+
+  describe('usersBelongToSameTenant', function() {
+    it('should return true for an empty array', function() {
+      const result = usersBelongToSameTenant([]);
+      expect(result).to.be.true;
+    });
+
+    it('should return true for users belonging to the same tenant', function() {
+      const users = [
+        { tenantId: '1', name: 'User 1' },
+        { tenantId: '1', name: 'User 2' },
+      ];
+      const result = usersBelongToSameTenant(users);
+      expect(result).to.be.true;
+    });
+
+    it('should return false for users belonging to different tenants', function() {
+      const users = [
+        { tenantId: '1', name: 'User 1' },
+        { tenantId: '2', name: 'User 2' },
+      ];
+      const result = usersBelongToSameTenant(users);
+      expect(result).to.be.false;
+    });
+  });
+});

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - 'packages/*'

package/rollup.config.js

@@ -0,0 +1,13 @@
+import html from '@open-wc/rollup-plugin-html';
+import resolve from '@rollup/plugin-node-resolve';
+
+export default {
+  input: 'docs-base/index.html',
+  output: {
+    dir: 'docs',
+  },
+  plugins: [
+    html(),
+    resolve(), // Resolves node modules
+  ],
+};

package/scripts/.eslintrc.yaml

@@ -0,0 +1,25 @@
+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:
+        - "**/*.js"