@beauraines/node-helpers 2.0.0

package/.eslintrc.js

@@ -0,0 +1,17 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true,
+        "jest/globals": true
+    },
+    "extends": "eslint:recommended",
+    "overrides": [
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest"
+    },
+    "plugins": ["jest"],
+    "rules": {
+    }
+}

package/.github/workflows/test.yaml

@@ -0,0 +1,26 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [16.x]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm run build --if-present
+      - run: npm test

package/README.md

@@ -0,0 +1,5 @@
+# Node Helpers
+
+This is a set of helpers for node. They're written for quick reuse rather than robust functions or efficiency. For instance, the database functions will create a new database connection every time. This is not efficient, but it makes making the function call simple.
+
+My use is primarily in quicker one off scripts that sometime morph into something long lasting...

package/index.js

@@ -0,0 +1,14 @@
+
+const azureStorage = require("./src/azure")
+const credentials = require("./src/credentials.js");
+const database = require("./src/database");
+const helpers = require("./src/helpers");
+const jira = require("./src/jira");
+
+module.exports = {
+    azureStorage,
+    credentials,
+    database,
+    helpers,
+    jira
+}

package/jest.config.js

@@ -0,0 +1,195 @@
+/*
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+module.exports = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/8s/3xlngh6x3734dvdvgk4235_r0000gp/T/jest_dy",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@beauraines/node-helpers",
+  "version": "2.0.0",
+  "description": "Collection of node helpers",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "author": "beau.raines@gmail.com",
+  "license": "ISC",
+  "dependencies": {
+    "@azure/storage-queue": "^12.11.0",
+    "azure-storage": "^2.10.7",
+    "node-fetch": "^2.6.7",
+    "sqlite": "^4.1.2",
+    "sqlite3": "^5.1.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.27.0",
+    "eslint-plugin-jest": "^27.2.1",
+    "jest": "^29.3.1"
+  }
+}

package/src/azure.js

@@ -0,0 +1,145 @@
+const azure = require('azure-storage');
+const { QueueClient, StorageSharedKeyCredential } = require("@azure/storage-queue");
+var path = require('path');
+
+/**
+ * Creates an AzureStorage class to interact with Azure Storage Blob Containers and Storage Queues.
+ * 
+ * @param {string} storageAccountName the name of the storage account
+ * @param {string} storageAccountKey the key for the storage account
+ * @param {Object} [options]
+ * @param {int} [options.tokenExpiry] expiration minutes for SAS tokens, defaults to 60 minutes
+ * @param {int} [options.queueMessageTTLSeconds] expiration in seconds for messages written to storage queues, defaults to 3600 (1 hour)
+ * @param {string} [options.cloudName] AzureCloud, AzureChinaCloud. AzureUSGovernment, AzureGermanCloud or Azurite for the emulator. Defaults to AzureCloud
+ */
+class AzureStorage {
+
+  constructor(storageAccountName,storageAccountKey,options) {
+    this.storageAccountName = storageAccountName
+    this.storageAccountKey = storageAccountKey
+    this.tokenExpiry = options?.tokenExpiry || 60 // defaults to 60 minute expiry
+    this.queueMessageTTLSeconds = options?.queueMessageTTLSeconds || 60 *60 // defaults to 60 minutes
+    this.cloudName = options?.cloudName || 'AzureCloud'
+    
+  }
+
+
+  /**
+   * Determines the Azure Storage service URL, accounting for the service type, government cloud or if
+   * the Azurite storage emulator is used. 
+   * @param {string} service The Azure Storage service, one of `blob`,`queue` or `table`
+   * @param {string} cloudName One of AzureCloud, AzureChinaCloud. AzureUSGovernment, AzureGermanCloud or Azurite for the emulator
+   * @returns 
+   */
+  host(service,cloudName) {
+      let port,url;
+      switch (service) {
+          case 'blob':
+              port = 10000
+              break;
+          case 'queue':
+              port = 10001
+              break;
+          case 'table':
+              port = 10002
+              break;
+          default:
+              break;
+      }
+      switch (cloudName) {
+        case 'Azurite':
+          url =  `http://127.0.0.1:${port}/${this.storageAccountName}`
+          break;
+        case 'AzureUSGovernment':
+          url = `https://${this.storageAccountName}.${service}.core.usgovcloudapi.net`
+          break;
+        case 'AzureChinaCloud':
+          url = `https://${this.storageAccountName}.${service}.core.chinacloudapi.cn`
+          break;
+        case 'AzureGermanCloud':
+          url = `https://${this.storageAccountName}.${service}.core.cloudapi.de`
+          break;
+        case 'AzureCloud':
+        default:
+          url = `https://${this.storageAccountName}.${service}.core.windows.net`
+          break;
+      }
+      return url
+  }
+
+
+  /**
+   * Sends a message to the specified storage queue. The messages are given a TTL based upon the
+   * class's `queueMessageTTLSeconds` value.
+   * @param {string} queueUrl The URL to the storage queue
+   * @param {string} messageContent The message to send to the queue
+   */
+  async sendMessageToQueue(queueUrl, messageContent,) {
+    try {
+      const queueClient = new QueueClient(
+        queueUrl,
+        new StorageSharedKeyCredential(this.storageAccountName, this.storageAccountKey)
+      );
+      let queueOptions = {
+        messageTimeToLive: this.queueMessageTTLSeconds
+      };
+      let sendMessageResponse = await queueClient.sendMessage(messageContent, queueOptions);
+      console.log(
+        "Sent message successfully, service assigned message Id:", sendMessageResponse.messageId,
+        "service assigned request Id:", sendMessageResponse.requestId
+      );
+    } catch (error) {
+      console.error(error.message)
+    }
+  }
+
+  /**
+   * Generates a signed URL for the specified blob in the specified container. The signed URL will expire
+   * after the class's `tokenExpiry` minutes, which defaults to 60 if not specified. 
+   * 
+   * @param {string} containerName The name of the parent container for the blob
+   * @param {string} blobName The name of the blob to generate the token
+   * @returns {string} the signed URL for the blob
+   */
+  generateBlobSignedUrl(containerName, blobName) {
+
+    const sharedAccessPolicy = {
+        AccessPolicy: {
+            Permissions: azure.BlobUtilities.SharedAccessPermissions.READ,
+            Start: new Date(),
+            Expiry: azure.date.minutesFromNow(this.tokenExpiry),
+        },
+    };
+
+    const blobService = azure.createBlobService(this.storageAccountName, this.storageAccountKey, this.host('blob',this.cloudName));
+    const sasToken = blobService.generateSharedAccessSignature(containerName, blobName, sharedAccessPolicy);
+    const blobUrl = blobService.getUrl(containerName, blobName, sasToken);
+
+    return blobUrl;
+  }
+
+  /**
+   * Uploads a local file to an Azure container as a blob. 
+   * 
+   * @param {string} containerName the container to which the file will be uploaded
+   * @param {string} file The path the the local file to upload to the container
+   */
+  uploadBlobFromFile(containerName,file) {
+    const blobService = azure.createBlobService(this.storageAccountName, this.storageAccountKey, this.host('blob',this.cloudName));
+    const options = {
+        access: 'container'
+    };
+    
+    let blobName = path.basename(file)
+    blobService.createBlockBlobFromLocalFile(containerName,blobName,file,options,function(error,response) {
+      if( error) {
+        console.error(error.message)
+      } else {
+        console.log(`${response.name} uploaded to ${response.container} container`)
+      }
+    });
+  }
+
+}
+
+module.exports = AzureStorage

package/src/azure.test.js

@@ -0,0 +1,49 @@
+const AzureStorage  = require('./azure.js')
+
+describe('Azure Storage module', () => {
+
+    it('should be created with default values', () => {
+        let azure = new AzureStorage('account','key')
+        expect(azure.cloudName).toBe('AzureCloud')
+        expect(azure.tokenExpiry).toBe(60)
+        expect(azure.queueMessageTTLSeconds).toBe(3600)
+    })
+
+    it('defaults can be overidden', () => {
+        let options = {
+            tokenExpiry: 30,
+            queueMessageTTLSeconds: 500,
+            cloudName: 'AzureUSGovernment'
+        }
+
+        let azure = new AzureStorage('account','key', options)
+        expect(azure.cloudName).toBe('AzureUSGovernment')
+        expect(azure.tokenExpiry).toBe(30)
+        expect(azure.queueMessageTTLSeconds).toBe(500)
+    })
+
+    it('should generate host URLs', () => {
+
+        let azure = new AzureStorage('account','key')
+
+        const azuriteBlobUrl = azure.host('blob','Azurite')
+        const governmentQueueUrl = azure.host('queue','AzureUSGovernment')
+        const chinaTableUrl = azure.host('table','AzureChinaCloud')
+        const germanCloudBlobUrl = azure.host('blob','AzureGermanCloud')
+        const azureCloudBlobUrl = azure.host('blob','AzureCloud')
+        const defaultQueueUrl = azure.host('queue')
+
+        expect(azuriteBlobUrl).toBe('http://127.0.0.1:10000/account')
+        expect(governmentQueueUrl).toBe('https://account.queue.core.usgovcloudapi.net')
+        expect(chinaTableUrl).toBe('https://account.table.core.chinacloudapi.cn')
+        expect(germanCloudBlobUrl).toBe('https://account.blob.core.cloudapi.de')
+        expect(azureCloudBlobUrl).toBe('https://account.blob.core.windows.net')
+        expect(defaultQueueUrl).toBe('https://account.queue.core.windows.net')
+
+    })
+
+    it.todo('should generate a signed URL for a blob')
+    it.todo('should upload a blob from a file')
+    it.todo('should send a message to the storage queue')
+
+})

package/src/credentials.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const {fileExists} = require('./helpers');
+
+/**
+ * Reads a file for credentials and validates that the file has the required attributes. 
+ * It will throw an error and EXIT if the file is not found or the file does not pass validation.
+ * @param {string} file the fully qualified path and file to the credentials file
+ * @returns Object containing the validated credentials
+ */
+async function getCredentials(file) {
+    const filePath = `${file}`
+    if (! await fileExists(filePath))  {
+        console.error(`Credentials file not found: ${filePath}`);
+        process.exit(1);
+    } 
+    let credentials = fs.readFileSync(filePath,
+        { encoding: 'utf8', flag: 'r' });
+    credentials = JSON.parse(credentials);
+    if (! await validateCredentials(credentials))  {
+        console.error(`Invalid credentials file ${filePath}`);
+        process.exit(1);
+    } 
+
+    return credentials;
+}
+
+/**
+ * Validates that the credentials include the token property
+ * @param {Object} credentials The credentials object
+ * @returns Boolean
+ */
+async function validateCredentials(credentials){
+    // TODO include the properties array as a parameter
+    let properties = ['token'];
+    let credentialKeys =  Object.keys(credentials);
+    let validCredentials = true;
+    properties.forEach(property=>{
+        let found = credentialKeys.find(x=>(x==property));
+        if (!found) {
+            validCredentials = false;
+        }
+        });
+    return validCredentials;
+}
+
+module.exports = {
+    getCredentials
+}

package/src/credentials.test.js

@@ -0,0 +1,4 @@
+
+describe('credentials module', () => {
+    it.todo('placeholder')
+})

package/src/database.js

@@ -0,0 +1,112 @@
+const {homedir} = require('os');
+const sqlite = require('sqlite');
+const sqlite3 = require('sqlite3');
+const {fileExists} = require('./helpers');
+
+/**
+ * Opens the BurnDownStatus SQLite3 Database
+ * @param file file name of the SQLite3 DB. If not provided, defaults to ${homedir}/BurnDownStatus.db
+ * @returns SQLite database connection
+ */
+async function getDBConnection(file) {
+    const homeDir = homedir();
+    file = file ? file : `${homeDir}/BurnDownStatus.db`;
+    if (! await fileExists(file)){
+        console.error(`${file} not found`);
+        // ! Separation of concerns - this should probably not be doing the exiting, but it is.
+        // This should return something and the calling script will exit
+        process.exit(1)
+    }
+    const db = await sqlite.open({
+        filename: file,
+        driver: sqlite3.Database
+    });
+    return db;
+}
+
+/**
+ * 
+ * @param {Object} data The burndown data to be inserted into the Burndown database
+ * 
+ * @returns {Object} The result of the database running the provided query
+ * @deprecated Should be replaced with the insert function
+ */
+async function writeToDb(data) {
+    // TODO should take db, query and values as parameters
+    let db = await getDBConnection();
+    let query = `insert into qa_burndown (date, qa_review_count, qa_validated_count) values (?,?,?) on conflict do update set qa_review_count = excluded.qa_review_count, qa_validated_count = excluded.qa_validated_count`;
+
+    let values = [data.date, data.qa_review_count, data.qa_validated_count];
+    let result = await db.run(query, values);
+    await db.close();
+    return result;
+
+}
+
+/**
+ * 
+ * Inserts or upserts data into the specified table in the specified database
+ * 
+ * @param {string} database Path and filename to the SQLite3 DB
+ * @param {string} table 
+ * @param {array} data array of fields and values to be inserted
+ * @param {array} keys Optional array of record keys, if provided will perform an UPSERT
+ * @returns {array} A not very useful of responses from the individual insert statements
+ */
+async function insert(database,table,data,keys) {
+    let db = await getDBConnection(database);
+
+    let fields = Object.keys(data[0]).toString();
+    let fieldsCount = Object.keys(data[0]).length;
+    let valueSubstitution = Array(fieldsCount).fill('?').toString();
+
+    let query = `insert into ${table}  (${fields}) values (${valueSubstitution})`
+    if (keys) {
+        query = query + buildOnConflictStatement(fields,keys);
+    }
+    query = query.concat(';');
+    let result = []
+    data.forEach(async (row) => {
+        // TODO add try/catch for SQL error errno and code
+        // TODO switch to db.exec() for more meaningful response
+        let response = await db.run(query,Object.values(row));
+        result.push(response);
+    });
+    await db.close();
+    // TODO clean up result
+    return result;
+}
+
+/**
+ * 
+ * @param {string} fields Comma separated list of fields from the data
+ * @param {array} keys Array of key values for the record, these will be excluded form the UPSERT statement
+ * @returns {string} the on conflict statement for an UPSERT based on the fields and keys provide
+ */
+function buildOnConflictStatement(fields,keys) {
+    fields = fields.split(',');
+    let upsertFields = fields.filter( x => !keys.includes(x));
+    let conflictStatement = ` on conflict do update set`;
+    for (let i = 0; i < upsertFields.length; i++) {
+        const field = upsertFields[i];
+        conflictStatement = conflictStatement + ` ${field} = excluded.${field}`
+        i != upsertFields.length -1 ? conflictStatement = conflictStatement + `,` : null
+    }
+    return conflictStatement;
+
+}
+
+async function query(database,query) {
+    let db = await getDBConnection(database);
+    // TODO add try/catch for SQL error errno and code
+    let response = await db.all(query);
+    return response;
+}
+
+
+module.exports = {
+    getDBConnection,
+    writeToDb,
+    insert,
+    query
+}

package/src/database.test.js

@@ -0,0 +1,74 @@
+const os = require('os');
+const sqlite = require('sqlite');
+const sqlite3 = require('sqlite3');
+const helpers = require('./helpers');
+const { getDBConnection } = require('./database');
+
+jest.mock('sqlite');
+jest.mock('os');
+jest.mock('./helpers');
+
+
+describe('database module', () => {
+
+    it('should exit if the database does not exist', async () => {
+        helpers.fileExists.mockReturnValue(false);
+        console.error = jest.fn()
+        const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+
+
+        await getDBConnection('/home/database-does-not-exist.db')
+        expect(mockExit).toHaveBeenCalledWith(1)
+
+    })
+    
+    it('should open the default database if no file specified', async () => {
+        // mock sqlite.open()
+        // Need `${homedir}/BurnDownStatus.db` or do we mock it?
+        const expectedHomeDir = '/home';
+
+        os.homedir.mockReturnValue(expectedHomeDir);
+        // helpers.fileExists.mockResolvedValue(true);
+        helpers.fileExists.mockReturnValue(true);
+
+
+        const expectedDefaultFile = `${os.homedir()}/BurnDownStatus.db`
+        
+        const file = undefined;
+        // call function with null file
+        const db = await getDBConnection(file)
+
+        // In theory you should mock the open function and what it returns.
+
+        // expect that sqlite.open() is called with `${homedir}/BurnDownStatus.db`
+        expect(sqlite.open).toHaveBeenCalledWith({
+            filename: expectedDefaultFile,
+            driver: sqlite3.Database
+        })
+        
+    })
+    
+    it('should open the specified database if a file is specified', async () => {
+
+
+        const expectedHomeDir = '/home';
+        
+        os.homedir.mockReturnValue(expectedHomeDir);
+        helpers.fileExists.mockReturnValue(true);
+
+        const expectedDefaultFile = `${os.homedir()}/my_database.db`
+
+        const db = await getDBConnection(expectedDefaultFile)
+
+        expect(sqlite.open).toHaveBeenCalledWith({
+            filename: expectedDefaultFile,
+            driver: sqlite3.Database
+        })
+
+
+    })
+
+})
+
+
+

package/src/helpers.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+
+/**
+ * Converts a string to Title Case, using whitespace as the delimiter
+ * @param {String} str String to convert
+ * @returns The string converted to title case
+ */
+function toTitleCase(str) {
+    return str.replace(
+      /\w\S*/g,
+      function(txt) {
+        return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+      }
+    );
+}
+
+/**
+ * Removes newline characters \r and/or \n from a string
+ * @param {string} string to remove newlines from
+ * @returns string
+ */
+function stripNewLines(string) {
+  return string.replace(/\r|\n/g, '');
+}
+
+/**
+ * Checks to see if the specified file exists
+ * @param {string} filePath fully qualified path and filename 
+ * @returns Boolean
+ */
+async function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+
+/**
+ * Asynchronously reads the entire file contents and returns it.
+ * @param {string} filePath fully qualified path and filename
+ * @returns any
+ */
+async function readFile(filePath) {
+  return fs.readFileSync(filePath,{ encoding: 'utf8', flag: 'r' });
+}
+
+/**
+ * Asynchronously reads the contents of a directory and returns the filenames as an array. Optionally, 
+ * filters by the extension
+ * @param {String} directory Path to the directory
+ * @param {String | null} extension optional file extension to filter for
+ * @returns { String[] } of file names
+ */
+async function listFiles(directory,extension) {
+  // TODO check for directory existence
+  return fs.readdirSync(directory,{withFileTypes: true})
+    .filter(item => !item.isDirectory() && item.name.includes(extension))
+    .map(item => item.name)
+}
+
+/**
+ * Groups an array by specified properties and sums other specified properties
+ * 
+ * https://stackoverflow.com/questions/46794232/group-objects-by-multiple-properties-in-array-then-sum-up-their-values
+ * 
+ * @param {Array} arr Array of Objects to aggregate
+ * @param {Array} groupKeys keys to group by
+ * @param {Array} sumKeys keys of properties to sum by
+ * @returns Array of Objects
+ */
+ function groupAndSum(arr, groupKeys, sumKeys){
+  return Object.values(
+    arr.reduce((acc,curr)=>{
+      const group = groupKeys.map(k => curr[k]).join('-');
+      acc[group] = acc[group] || Object.fromEntries(
+         groupKeys.map(k => [k, curr[k]]).concat(sumKeys.map(k => [k, 0])));
+      sumKeys.forEach(k => acc[group][k] += curr[k]);
+      return acc;
+    }, {})
+  );
+}
+
+/**
+ * Returns the current unix timestamp in seconds
+ * 
+ * @returns Number
+ */
+function unixTimestamp() {
+  return Math.floor(Date.now() / 1000)
+}
+
+/**
+ * Returns unix timestamp in milliseconds
+ * 
+ * @returns Number
+ */
+function getEpochMillis() {
+  return Date.now()
+}
+
+module.exports = {
+    getEpochMillis,
+    fileExists,
+    groupAndSum,
+    readFile,
+    listFiles,
+    stripNewLines,
+    toTitleCase,
+    unixTimestamp
+}

package/src/helpers.test.js

@@ -0,0 +1,9 @@
+const helper = require('./helpers');
+
+it('should return a title case string',() => {
+    const lowerString = 'a quick brown fox';
+    const titleString = 'A Quick Brown Fox';
+
+    expect(helper.toTitleCase(lowerString)).toBe(titleString);
+})
+

package/src/jira.js

@@ -0,0 +1,163 @@
+const fetch = require('node-fetch');
+
+/**
+ * Converts an email and password to a base64 encoded string to be used as a Bearer token. 
+ * NB: This only converts the string and does not pre-pend Bearer
+ * @param {string} email email address
+ * @param {string} token access token or password
+ * @returns String
+ */
+function credentialsToToken(email,token) {
+    let bearerToken = Buffer.from(`${email}:${token}`).toString('base64');
+    return bearerToken
+}
+
+/**
+ * Gets up to 100 issues by JQL query, retuning the "key","summary","status","statusCategory",
+ * "labels","parent","project","customfield_10013" 
+ * @param {string} jql A valid JQL statement, NB: any quotation marks should be single quotes
+ * @param {object} credentials A object at least with the property `bearerToken`
+ * @returns Object
+ */
+async function getIssuesByJql(jql,credentials) {
+    let {domain } = credentials;
+    let headersList = {
+        "Accept": "*/*",
+        "User-Agent": "Thunder Client (https://www.thunderclient.com)",
+        "Authorization": `Basic ${credentials.bearerToken}`,
+        "Content-Type": "application/json"
+    }
+
+    // TODO make this an option parameter
+    let fields = [
+        "key","summary","status","statusCategory","labels","parent","project","customfield_10013"
+    ];
+
+    // TODO make the max results an option parameter and variable to be reused in the paginated data increments
+    let bodyContent = {
+        "startAt": 0,
+        "maxResults": 100,
+        "jql": jql,
+        "fields": fields
+    };
+    
+    let response = await fetch(`https://${domain}.atlassian.net/rest/api/3/search`, { 
+        method: "POST",
+        body: JSON.stringify(bodyContent),
+        headers: headersList
+    })
+
+    let body
+
+    if (response.ok) {
+        body = await response.json();
+        // console.log('total',body.total);
+        // console.log('maxResults',body.maxResults);
+        if (body.total < body.maxResults) {
+            return body;
+        } 
+    } else {
+        throw new Error(response.statusText);
+    }
+
+    console.log('There is more data to be pulled...');
+    let retrieveCount = 100;
+    let totalResults = body.total;
+
+    let requestBodies = []
+    // console.log(bodyContent);
+    while (retrieveCount < totalResults) {
+        bodyContent.startAt = retrieveCount;
+        requestBodies.push({...bodyContent}); 
+        retrieveCount = retrieveCount + 100;
+    }
+
+    // for of is a better practice than forEach
+
+    // TODO move this to function like
+    // const callApi = async (): Promise<ResponseModel> => { /* function code here */ } (edited) 
+    // Return an array of Promises and wait for all of them to resolve with  Promise.all()
+
+    for (const requestBody of requestBodies) {
+        console.log(`Making API call startAt ${requestBody.startAt}`);
+        let response = await fetch(`https://${domain}.atlassian.net/rest/api/3/search`, {
+            method: "POST",
+            body: JSON.stringify(requestBody),
+            headers: headersList
+        });
+
+        if (response.ok) {
+            let responseBody = await response.json();
+            body.issues = body.issues.concat(responseBody.issues);
+            console.log(`API call startAt ${requestBody.startAt} complete, found ${responseBody.issues.length}, body length is now ${body.issues.length}`);
+        } else {
+            throw new Error(response.statusText);
+        }
+    }
+
+    console.log("issues", body.issues.length)
+    return body;
+
+}
+
+/**
+ * Gets up to 100 Jira issues that belong to the specified Epic
+ * @param {string} epic Epic Key, e.g. CEC-3360
+ * @param {Object} credentials An object with at least the `bearerToken` property
+ * @returns Object
+ */
+async function getIssuesForEpic(epic,credentials) {
+    let {domain } = credentials;
+    let headersList = {
+        "Accept": "*/*",
+        "User-Agent": "Thunder Client (https://www.thunderclient.com)",
+        "Authorization": `Basic ${credentials.bearerToken}`
+    }
+       
+    // TODO make the max results an option parameter
+    let response = await fetch(`https://${domain}.atlassian.net/rest/agile/1.0/epic/${epic}/issue?maxResults=100`, { 
+        method: "GET",
+        headers: headersList
+    })
+
+    if (response.ok) {
+        return response.json();
+    } else {
+        throw new Error(response.statusText);
+    }
+}
+
+/**
+ * gets data from any Jira API end point
+ * @param {string} url Jira API Endpoint
+ * @param {object} credentials the credentials object, with email and token
+ * @returns Object
+ */
+async function getJiraData(url,credentials) {
+    let {domain, email, token} = credentials;
+    let response;
+    try {
+        response = await fetch(`https://${domain}.atlassian.net/${url}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Basic ${credentialsToToken(email,token)}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            }
+        });
+        if (response.ok) {
+            return response.json();
+        } else {
+            throw new Error(response.statusText);
+        }
+    } catch (error) {
+        console.error(error.message)
+    }
+}
+
+module.exports = { 
+    getIssuesByJql, 
+    getIssuesForEpic,
+    credentialsToToken,
+    getJiraData
+}