@bitblit/ratchet-node-only 6.0.146-alpha → 6.0.147-alpha

package/src/export-builder/export-map-builder.ts

@@ -0,0 +1,157 @@
+import fs, { Stats } from 'fs';
+import path from 'path';
+import { CliRatchet } from '../cli/cli-ratchet.js';
+import { ExportMapBuilderConfig } from './export-map-builder-config.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class ExportMapBuilder {
+  public static process(cfg: ExportMapBuilderConfig): Record<string, any> {
+    Logger.info('Building export map : %j', cfg);
+
+    cfg.targetPackageJsonFile = cfg.targetPackageJsonFile ?? path.join(EsmRatchet.fetchDirName(import.meta.url), 'package.json');
+    cfg.includes = cfg.includes ?? [new RegExp('.*')];
+    cfg.excludes = cfg.excludes ?? [];
+
+    if (!fs.statSync(cfg.targetPackageJsonFile).isFile()) {
+      throw ErrorRatchet.fErr('targetPackageJsonFile: %s does not exist or is not a file', cfg.targetPackageJsonFile);
+    }
+
+    cfg.sourceRoot = cfg.sourceRoot ?? path.join(path.dirname(cfg.targetPackageJsonFile), 'src');
+    if (!fs.statSync(cfg.sourceRoot).isDirectory()) {
+      throw ErrorRatchet.fErr('sourceRoot: %s does not exist or is not a folder', cfg.sourceRoot);
+    }
+    cfg.targets = cfg.targets ?? [
+      {
+        type: 'import',
+        prefix: './lib',
+        suffix: '.js',
+      },
+      {
+        type: 'types',
+        prefix: './lib',
+        suffix: '.d.ts',
+      },
+    ];
+
+    Logger.info('Using sourceRoot %s and targets %j', cfg.sourceRoot, cfg.targets);
+    const exports: Record<string, any> = {};
+    // TODO: This cant be right can it?  need to actually use this
+    for (const _f of cfg.includes) {
+      ExportMapBuilder.processSingleFile(cfg.sourceRoot, cfg, exports);
+    }
+
+    // Parse package.json
+    const parsedPackage: any = JSON.parse(fs.readFileSync(cfg.targetPackageJsonFile).toString());
+    parsedPackage['exports'] = exports;
+
+    if (cfg.dryRun) {
+      Logger.info('DryRun : Would have updated package json to : \n%j', parsedPackage);
+    } else {
+      // Update here
+      fs.writeFileSync(cfg.targetPackageJsonFile, JSON.stringify(parsedPackage, null, 2));
+    }
+
+    return exports;
+  }
+
+  private static pathMatchesOneOfRegExp(fileName: string, reg: RegExp[]): boolean {
+    let rval: boolean = false;
+    if (StringRatchet.trimToNull(fileName) && reg.length > 0) {
+      rval = true;
+    }
+    return rval;
+  }
+
+  private static findExports(fileName: string): string[] {
+    const text: string = StringRatchet.trimToEmpty(fs.readFileSync(fileName).toString());
+    const words: string[] = text.split(/[ \t\n]+/);
+    const exports: string[] = [];
+    for (let i = 0; i < words.length - 2; i++) {
+      if (words[i] === 'export') {
+        if (words[i + 1] === 'class' || words[i + 1] === 'interface') {
+          let next: string = words[i + 2];
+          if (next.endsWith('{')) {
+            next = next.substring(0, next.length - 1); // String trailing
+          }
+          if (next.indexOf('<') !== -1) {
+            // Strip generics
+            next = next.substring(0, next.indexOf('<'));
+          }
+          exports.push(next);
+        } else if (words[i + 1] === 'default') {
+          // TODO: handle default
+        }
+      }
+    }
+
+    return exports;
+  }
+
+  private static processSingleFile(fileName: string, cfg: ExportMapBuilderConfig, inRecord: Record<string, any>): Record<string, any> {
+    const rval: Record<string, any> = Object.assign({}, inRecord ?? {});
+    if (fs.existsSync(fileName)) {
+      if (ExportMapBuilder.pathMatchesOneOfRegExp(fileName, cfg.includes)) {
+        if (!ExportMapBuilder.pathMatchesOneOfRegExp(fileName, cfg.excludes)) {
+          const stats: Stats = fs.statSync(fileName);
+          if (stats.isDirectory()) {
+            const contFiles: string[] = fs.readdirSync(fileName);
+            Logger.info('Found %d files in %s to process', contFiles.length, fileName);
+            contFiles.forEach((f) => ExportMapBuilder.processSingleFile(path.join(fileName, f), cfg, inRecord));
+          } else if (stats.isFile()) {
+            const exports: string[] = ExportMapBuilder.findExports(fileName);
+            exports.forEach((s) => {
+              if (inRecord[s]) {
+                throw ErrorRatchet.fErr('Collision on name %s : %s vs %s', fileName, inRecord[s], s);
+              } else {
+                let subPath: string = fileName.substring(cfg.sourceRoot.length);
+                subPath = subPath.split('\\').join('/'); // Package.json uses unix separators even on windows
+                if (subPath.endsWith('.ts')) {
+                  subPath = subPath.substring(0, subPath.length - 3);
+                }
+                cfg.targets.forEach((tgt) => {
+                  inRecord[s] = inRecord[s] || {};
+                  const targetFileName: string = StringRatchet.trimToEmpty(tgt.prefix) + subPath + StringRatchet.trimToEmpty(tgt.suffix);
+                  inRecord[s][tgt.type] = targetFileName;
+                });
+              }
+            });
+          } else {
+            Logger.error('Skipping - neither file nor directory : %s', fileName);
+          }
+        } else {
+          Logger.error('Skipping - fails exclude check : %s', fileName);
+        }
+      } else {
+        Logger.error('Skipping - fails include check : %s', fileName);
+      }
+    } else {
+      Logger.warn('Could not find file %s', fileName);
+    }
+    return rval;
+  }
+
+  /**
+   And, in case you are running this command line...
+   TODO: should use switches to allow setting the various non-filename params
+   **/
+  public static async runFromCliArgs(args: string[]): Promise<Record<string, any>> {
+    if (args.length < 3) {
+      Logger.infoP('Usage: ratchet-export-builder'); // {packageJsonFile}');
+      return null;
+    } else {
+      const _idx: number = CliRatchet.indexOfCommandArgument('export-builder');
+      //const jsonFile: string = process.argv[idx + 1];
+
+      const cfg: ExportMapBuilderConfig = {
+        //targetPackageJsonFile: jsonFile
+      };
+
+      Logger.info('Running ExportMapBuilder from command line arguments');
+
+      return ExportMapBuilder.process(cfg);
+    }
+  }
+}

package/src/files/files-to-static-class.spec.ts

@@ -0,0 +1,26 @@
+import path from 'path';
+import { FilesToStaticClass } from './files-to-static-class.js';
+//import { fileURLToPath, URL } from 'url';
+//import { Logger } from '../../common/logger';
+import { describe, expect, test } from 'vitest';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+
+const testDirname: string = EsmRatchet.fetchDirName(import.meta.url);
+
+describe('#filesToStaticClass', function () {
+  test('should convert files to a static class', async () => {
+    const out: string = await FilesToStaticClass.process(
+      [
+        path.join(testDirname, 'files-to-static-class.ts'),
+        path.join(testDirname, '../cli/cli-ratchet.ts'),
+        path.join(testDirname, '../third-party/git'),
+      ],
+      'Test',
+    );
+    //Logger.info('xx: %s', out);
+
+    expect(out).not.toBeNull();
+    expect(out.length).toBeGreaterThan(0);
+    console.info('\n\n' + out);
+  });
+});

package/src/files/files-to-static-class.ts

@@ -0,0 +1,101 @@
+/*
+    Takes in a list of static files, and a class name, and generates a static
+    class containing each of the files in a map.  This is to allow static
+    content to be passed through webpack safely
+ */
+
+import fs, { Stats } from 'fs';
+import path from 'path';
+import { CliRatchet } from '../cli/cli-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+
+export class FilesToStaticClass {
+  public static async process(inFileNames: string[], outClassName: string, outFileName: string = null): Promise<string> {
+    if (!inFileNames) {
+      throw new Error('fileNames must be defined');
+    }
+    if (!outClassName) {
+      throw new Error('outClassName must be defined');
+    }
+    if (inFileNames.length === 0) {
+      Logger.warn('Warning - no files supplied to process');
+    }
+
+    // Preprocess to remove non-existent files and convert folders to files
+    const fileNames: string[] = [];
+    inFileNames.forEach((f) => FilesToStaticClass.processFilename(f, fileNames));
+
+    Logger.info('Generating class %s from files %j (output file: %s)', outClassName, fileNames, outFileName);
+
+    let rval = '/** \n';
+    rval += '* Holder for the constants to be used by consumers \n';
+    rval += '* Moves it into code so that it can survive a trip through WebPack \n';
+    rval += '*/ \n\n';
+    rval += 'export class ' + outClassName + ' { \n';
+    rval += '  public static readonly VALUES:Record<string, string> = { \n';
+
+    // If we reached here we can assume all the files exist and are files
+    for (let i = 0; i < fileNames.length; i++) {
+      // Remove both forward and back slashes...
+      let trimmed: string = fileNames[i].substring(fileNames[i].lastIndexOf('/') + 1);
+      trimmed = trimmed.substring(trimmed.lastIndexOf('\\') + 1);
+      const contents: string = fs.readFileSync(fileNames[i]).toString();
+      rval += i > 0 ? ',' : '';
+      rval += '"' + trimmed + '":' + JSON.stringify(contents) + '\n';
+    }
+
+    rval += '}; \n';
+    rval += '}';
+
+    if (outFileName) {
+      Logger.info('Writing to %s', outFileName);
+      fs.writeFileSync(outFileName, rval);
+    }
+
+    return rval;
+  }
+
+  private static processFilename(fileName: string, targetArrayInPlace: string[]): void {
+    RequireRatchet.notNullOrUndefined(targetArrayInPlace, 'targetArrayInPlace');
+    if (fs.existsSync(fileName)) {
+      const stats: Stats = fs.statSync(fileName);
+      if (stats.isDirectory()) {
+        const contFiles: string[] = fs.readdirSync(fileName);
+        Logger.info('Found %d files in %s to process', contFiles.length, fileName);
+        contFiles.forEach((f) => FilesToStaticClass.processFilename(path.join(fileName, f), targetArrayInPlace));
+      } else if (stats.isFile()) {
+        targetArrayInPlace.push(fileName);
+      } else {
+        Logger.error('Skipping - neither file nor directory : %s', fileName);
+      }
+    } else {
+      Logger.warn('Could not find file %s', fileName);
+    }
+  }
+
+  /**
+   And, in case you are running this command line...
+   TODO: should use switches to allow setting the various non-filename params
+   **/
+  public static async runFromCliArgs(args: string[]): Promise<string> {
+    if (args.length < 3) {
+      Logger.infoP('Usage: ratchet-files-to-static-class {outFileName} {outClassName} {file0} ... {fileN}');
+      return null;
+    } else {
+      const idx: number = CliRatchet.indexOfCommandArgument('files-to-static-class');
+      const outFileName: string = process.argv[idx + 1];
+      const outClassName: string = process.argv[idx + 2];
+      const files: string[] = process.argv.slice(idx + 3);
+
+      Logger.info(
+        'Running FilesToStaticClass from command line arguments Target: %s TargetClass: %s InFiles: %j',
+        outFileName,
+        outClassName,
+        files,
+      );
+
+      return FilesToStaticClass.process(files, outClassName, outFileName);
+    }
+  }
+}

package/src/files/unique-file-rename.ts

@@ -0,0 +1,80 @@
+/*
+    Given a folder name, it renames all the files within it to a roughly
+    globally unique name (basically just timestamps) while retaining the
+    extensions.  Mainly used to merge multiple folders that have files with the
+    same names
+ */
+
+import fs, { Stats } from 'fs';
+import path from 'path';
+import { CliRatchet } from '../cli/cli-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BooleanRatchet } from '@bitblit/ratchet-common/lang/boolean-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class UniqueFileRename {
+  public static async process(inFolder: string, recursive: boolean = false, dryRun: boolean = false): Promise<number> {
+    let rval: number = 0;
+    if (!inFolder || inFolder.trim().length === 0) {
+      throw new Error('folder must be defined');
+    }
+    if (!fs.existsSync(inFolder)) {
+      throw new Error(inFolder + ' does not exist');
+    }
+    const stats: Stats = fs.statSync(inFolder);
+    if (!stats.isDirectory()) {
+      throw new Error(inFolder + ' is not a folder');
+    }
+
+    const contFiles: string[] = fs.readdirSync(inFolder);
+    for (const cFile of contFiles) {
+      //for (let i = 0; i < contFiles.length; i++) {
+      const full: string = path.join(inFolder, cFile);
+      const s2: Stats = fs.statSync(full);
+      if (s2.isFile()) {
+        const newNamePart: string = Date.now() + '_' + rval;
+        const idx: number = cFile.lastIndexOf('.');
+        const newName: string = idx > -1 ? newNamePart + cFile.substring(idx) : newNamePart;
+        const newFull: string = path.join(inFolder, newName);
+        if (dryRun) {
+          Logger.info('Would have renamed %s to %s', full, newFull);
+        } else {
+          Logger.info('Renaming %s to %s', full, newFull);
+          fs.renameSync(full, newFull);
+        }
+        rval++;
+      } else if (s2.isDirectory()) {
+        if (recursive) {
+          rval += await UniqueFileRename.process(full, recursive, dryRun);
+        } else {
+          Logger.info('Ignoring %s - folder, and recursive not specified', full);
+        }
+      } else {
+        Logger.info('Ignoring %s - neither file nor folder', full);
+      }
+    }
+
+    return rval;
+  }
+
+  /**
+   And, in case you are running this command line...
+   TODO: should use switches to allow setting the various non-filename params
+   **/
+  public static async runFromCliArgs(args: string[]): Promise<string> {
+    if (args.length !== 3) {
+      Logger.infoP('Usage: ratchet-unique-file-rename {folder} {recursive} {dryrun}');
+      Logger.infoP(args.length);
+      return null;
+    } else {
+      const idx: number = CliRatchet.indexOfCommandArgument('unique-file-rename');
+      const folder: string = process.argv[idx + 1];
+      const recursive: boolean = BooleanRatchet.parseBool(process.argv[idx + 2]);
+      const dryrun: boolean = BooleanRatchet.parseBool(process.argv[idx + 3]);
+
+      Logger.info('Running UniqueFileName from command line arguments Folder: %s Recursive: %s DryRun: %s', folder, recursive, dryrun);
+
+      return StringRatchet.safeString(UniqueFileRename.process(folder, recursive, dryrun));
+    }
+  }
+}

package/src/http/local-file-server.ts

@@ -0,0 +1,129 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import http, { IncomingMessage, Server, ServerResponse } from 'http';
+import https from 'https';
+import { LocalServerCert } from './local-server-cert.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+import path from 'path';
+import fs from 'fs';
+import mime from 'mime-types';
+import { SimpleArgRatchet } from '@bitblit/ratchet-common/lang/simple-arg-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
+import { BooleanRatchet } from '@bitblit/ratchet-common/lang/boolean-ratchet';
+
+/**
+ * Very simple file server like 'serve', but can run https for things that
+ * need that (like most apis these days)
+ */
+export class LocalFileServer {
+  private server: Server;
+  private urlRoot: string;
+
+  constructor(
+    private port: number = 8888,
+    private https: boolean = false,
+    private fileRoot: string = EsmRatchet.fetchDirName(import.meta.url),
+  ) {
+    if (fs.existsSync(fileRoot)) {
+      if (!fs.statSync(fileRoot).isDirectory()) {
+        throw ErrorRatchet.fErr('Cannot start with %s - it is not a directory', fileRoot);
+      }
+    } else {
+      throw ErrorRatchet.fErr('Cannot start with %s - it does not exist', fileRoot);
+    }
+  }
+
+  async runServer(): Promise<boolean> {
+    return new Promise<boolean>((res, rej) => {
+      try {
+        Logger.info('Starting file server on port %d at root %s', this.port, this.fileRoot);
+
+        if (this.https) {
+          const options = {
+            key: LocalServerCert.CLIENT_KEY_PEM,
+            cert: LocalServerCert.CLIENT_CERT_PEM,
+          };
+          Logger.info(
+            'Starting https server - THIS SERVER IS NOT SECURE!  The KEYS are in the code!  Testing Server Only - Use at your own risk!',
+          );
+          this.server = https.createServer(options, this.requestHandler.bind(this)).listen(this.port);
+          this.urlRoot = 'https://localhost:' + this.port;
+        } else {
+          this.server = http.createServer(this.requestHandler.bind(this)).listen(this.port);
+          this.urlRoot = 'http://localhost:' + this.port;
+        }
+        Logger.info('File server is listening');
+
+        // Also listen for SIGINT
+        process.on('SIGINT', () => {
+          Logger.info('Caught SIGINT - shutting down test server...');
+          this.server.close();
+          res(true);
+        });
+      } catch (err) {
+        Logger.error('Local server failed : %s', err, err);
+        rej(err);
+      }
+    });
+  }
+
+  async requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any> {
+    const reqPath: string = request.url.includes('?') ? request.url.substring(0, request.url.indexOf('?')) : request.url;
+    const filePath: string = path.join(this.fileRoot, reqPath);
+    if (fs.existsSync(filePath)) {
+      const stats: fs.Stats = fs.statSync(filePath);
+      if (stats.isFile()) {
+        let mimetype: string = mime.contentType(filePath);
+        if (mimetype === 'video/mp2t') {
+          // Not very likely for me!
+          mimetype = 'text/x-typescript';
+        }
+        const buf: Buffer = fs.readFileSync(filePath);
+        response.setHeader('Content-Type', mimetype);
+        response.statusCode = 200;
+        response.end(buf);
+      } else if (stats.isDirectory()) {
+        this.writeFolderListToResponse(reqPath, filePath, response);
+      }
+    } else {
+      response.statusCode = 404;
+      response.setHeader('Content-Type', 'text/html');
+      response.end(`<html><body>No such file: ${reqPath}</body></html>`);
+    }
+  }
+
+  public writeFolderListToResponse(rootpth: string, pth: string, response: ServerResponse): void {
+    response.statusCode = 200;
+    response.setHeader('Content-Type', 'text/html');
+
+    let body: string = '<html><body><h1>Files in ' + pth + '</h1><ul>';
+
+    if (rootpth !== '/') {
+      let sub: string = rootpth.substring(0, rootpth.lastIndexOf('/'));
+      sub = sub.length === 0 ? '/' : sub;
+      body += '<li><a href="' + sub + '">..</a></li>';
+    }
+
+    fs.readdirSync(pth).forEach((file) => {
+      let fullUrl: string = this.urlRoot + rootpth;
+      fullUrl += fullUrl.endsWith('/') ? file : '/' + file;
+      body += `<li><a href="${fullUrl}">${file}</a></li>`;
+    });
+
+    body += '</ul></body></html>';
+
+    response.end(body);
+  }
+
+  public static async runLocalFileServerFromCliArgs(args: string[]): Promise<void> {
+    Logger.setLevel(LoggerLevelName.debug);
+    const pArgs: Record<string, string> = SimpleArgRatchet.parseSingleArgs(args, ['root', 'port', 'https']);
+    const port: number = pArgs['port'] ? NumberRatchet.safeNumber(pArgs['port']) : 8888;
+    const https: boolean = pArgs['https'] ? BooleanRatchet.parseBool(pArgs['https']) : false;
+    const root: string = pArgs['root'] ?? EsmRatchet.fetchDirName(import.meta.url);
+    const testServer: LocalFileServer = new LocalFileServer(port, https, root);
+    const res: boolean = await testServer.runServer();
+    Logger.info('Res was : %s', res);
+  }
+}

package/src/http/local-server-cert.ts

@@ -0,0 +1,72 @@
+export class LocalServerCert {
+  public static readonly CLIENT_CSR: string =
+    '-----BEGIN CERTIFICATE REQUEST-----\n' +
+    'MIICwjCCAaoCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAk5WMRIwEAYDVQQH\n' +
+    'DAlMYXMgVmVnYXMxDjAMBgNVBAoMBVBsdW1hMRkwFwYDVQQDDBB3d3cuaGV5cGx1\n' +
+    'bWEuY29tMSIwIAYJKoZIhvcNAQkBFhNjd2Vpc3NAaGV5cGx1bWEuY29tMIIBIjAN\n' +
+    'BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Gh1SD1VciosMgh3MHF7IyKgNTu2\n' +
+    'DjGMoORJV4VNKzrjp7UOdKnD3so0Xx3A6bUTYAL8Vtc+EG+8LZjUpBIOwuKzzbVo\n' +
+    't16+yt3YXBxzTZPU9g7sFsXx42RoNispIFq0enRtJrq/zq8izZxUZdGn9XD2DidL\n' +
+    'AedtRGjb8cmRuP6wmMRPBOZjct4ZjsSiTyhPa6kpt8V7Pa7vm0HGxcHiDAGp6zoy\n' +
+    'GHfBdsqeBdGbkGT1ZPfs9kpbtXPm82Sckd0p3oY3fJn0rZqpTAb8qcdGcnheYtqX\n' +
+    'FSjX7EoGsIXAK+oj25MvtfoZFMk4rjQ7FkHbgGk0iMHLN0kNjJzN0ysN/wIDAQAB\n' +
+    'oAAwDQYJKoZIhvcNAQELBQADggEBAMbpCdoqmY9crolsh5y9YtYDLRIwisTjTjU1\n' +
+    'Xzp1MurSzGIdHLokU+fdVWTIzn3uOu24yTQouTUUoYWHT4YgN4wELdDydfNxWvyl\n' +
+    'r34QV5B0FZbRV2sNz/3C1UX/Uor4af1Yv+QYlGHspgj+WIAEkNQ3xQIo9+I/miR+\n' +
+    '2VSlydtyGvmzipgv6CAwOsrQsIw7DkpVmnqIjgjPSXlGCgeKM9S1D/CwNwZnVA/e\n' +
+    'DF1SzDkJKl60/n+xZGYl/OtkH9vB8T6fHqk0iMxXuVUxI137fwEJwIQB5L6hFyJa\n' +
+    'L4hbjq7Cull4qOhXDby+fNJT9Ic7VCosJBXBHxHPsEnY2+TZAJo=\n' +
+    '-----END CERTIFICATE REQUEST-----\n';
+
+  public static readonly CLIENT_CERT_PEM: string =
+    '-----BEGIN CERTIFICATE-----\n' +
+    'MIIDgTCCAmkCFDKASki0c6HD75dCdIZZ3vXq4eQeMA0GCSqGSIb3DQEBCwUAMH0x\n' +
+    'CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOVjESMBAGA1UEBwwJTGFzIFZlZ2FzMQ4w\n' +
+    'DAYDVQQKDAVQbHVtYTEZMBcGA1UEAwwQd3d3LmhleXBsdW1hLmNvbTEiMCAGCSqG\n' +
+    'SIb3DQEJARYTY3dlaXNzQGhleXBsdW1hLmNvbTAeFw0yMzAxMjMxMDU2MDlaFw0y\n' +
+    'MzAyMjIxMDU2MDlaMH0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOVjESMBAGA1UE\n' +
+    'BwwJTGFzIFZlZ2FzMQ4wDAYDVQQKDAVQbHVtYTEZMBcGA1UEAwwQd3d3LmhleXBs\n' +
+    'dW1hLmNvbTEiMCAGCSqGSIb3DQEJARYTY3dlaXNzQGhleXBsdW1hLmNvbTCCASIw\n' +
+    'DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANhodUg9VXIqLDIIdzBxeyMioDU7\n' +
+    'tg4xjKDkSVeFTSs646e1DnSpw97KNF8dwOm1E2AC/FbXPhBvvC2Y1KQSDsLis821\n' +
+    'aLdevsrd2Fwcc02T1PYO7BbF8eNkaDYrKSBatHp0bSa6v86vIs2cVGXRp/Vw9g4n\n' +
+    'SwHnbURo2/HJkbj+sJjETwTmY3LeGY7Eok8oT2upKbfFez2u75tBxsXB4gwBqes6\n' +
+    'Mhh3wXbKngXRm5Bk9WT37PZKW7Vz5vNknJHdKd6GN3yZ9K2aqUwG/KnHRnJ4XmLa\n' +
+    'lxUo1+xKBrCFwCvqI9uTL7X6GRTJOK40OxZB24BpNIjByzdJDYyczdMrDf8CAwEA\n' +
+    'ATANBgkqhkiG9w0BAQsFAAOCAQEAWQG2tvWY+cyeeumD/7WKTBNaBjg4EAe+1mnZ\n' +
+    'KQsg0gGUL0kWsqCkg4xEqIojkKMjs62uS6ballEyWawygYd91OaJLFopNu+Dxk4N\n' +
+    '5GWKpriPr02vI6rMUZNtCmsooukEShr5ufFWb4WLnk4NXQlBCXTHbmIf7Z82UOMw\n' +
+    'ONZdZyKLqlA0Z6SWYBp2gO32puww6dUU0DAKkIIx1SN8i8UKvowRAy13bugPtyau\n' +
+    'NknlE3J1+Gab1hHCMRdKFZPKy8nc7LWUNZhgKdY82IC/k5FSW32Wibfog1TwWRJR\n' +
+    'ceTW4EN4P7ZmdHGMYkIplc7Qcx0mraY2HRqmjA33j3cNcY5UsQ==\n' +
+    '-----END CERTIFICATE-----\n';
+
+  public static readonly CLIENT_KEY_PEM: string =
+    '-----BEGIN RSA PRIVATE KEY-----\n' +
+    'MIIEogIBAAKCAQEA2Gh1SD1VciosMgh3MHF7IyKgNTu2DjGMoORJV4VNKzrjp7UO\n' +
+    'dKnD3so0Xx3A6bUTYAL8Vtc+EG+8LZjUpBIOwuKzzbVot16+yt3YXBxzTZPU9g7s\n' +
+    'FsXx42RoNispIFq0enRtJrq/zq8izZxUZdGn9XD2DidLAedtRGjb8cmRuP6wmMRP\n' +
+    'BOZjct4ZjsSiTyhPa6kpt8V7Pa7vm0HGxcHiDAGp6zoyGHfBdsqeBdGbkGT1ZPfs\n' +
+    '9kpbtXPm82Sckd0p3oY3fJn0rZqpTAb8qcdGcnheYtqXFSjX7EoGsIXAK+oj25Mv\n' +
+    'tfoZFMk4rjQ7FkHbgGk0iMHLN0kNjJzN0ysN/wIDAQABAoIBAHzZ9yAQUqWk8w6C\n' +
+    'l9EZB4PDzE4p/uS9bXa9fhrCSz0vonv1FzvzXY/BdOmTTuMGlwEDd/XaBHKTJCvi\n' +
+    'SnvF90I0bKu3h4yTWtvLlbG+sD8HlQvInCifVuhr2zu1Nur1qb4kQXzgrRxfKmMZ\n' +
+    'WA/OH2qZGzwbK0kT7ZRUMuCR/EKPjYw9KP6pMF8nxXUjSm+g3YwgIB8kiPeDCV6C\n' +
+    '0/Ecpv5qMqcoYTg9f9KyBNmY3U5ZgbYrdwTDSMrrTwZKSHhTktdF0SEfYrVGLLEU\n' +
+    'vfQQlQmfcc5Z3+cz99BH1BeTNaCPtEaXjgvQYwkWlSxnY6QUE0p1qq9Jy0xaVEx9\n' +
+    '8LReuHECgYEA/hhJ6b2XV1WLtszFO8MRMzlyMuvBc3Ot0dsuJ7r1W3WOF5X7poSU\n' +
+    'xG0xe+n6Kubmi3tGhzS7BN4TEO9/SSE2gIQTk9zwAMuf+mZJQcG0Qz1iftVp5nnM\n' +
+    'zi205vBLLq2Pmk7wbhTIBO8J190Dli1/fuvk/cmJrA60Ys8v3y4e820CgYEA2gfV\n' +
+    'Q3eHRxk3wl4On71mMovY7lMx6+S8K8hBGo26A5FIu6N6v2jxKnQ5YphwFgjtkxgs\n' +
+    'LspAXmxRwFMapZP3d/nFeBhlOzNly7tqIdDOeNqEcUzEx7pwGXpWGZEHOYs1fvU+\n' +
+    'gU/1N8q9DBvr0B+XGeYR3NNdljajo6pwWZ6ed5sCgYAGmkz5ZPLU0yVBR8rsRaJh\n' +
+    'yWFdT2EEhgIDTQXDBImxqblahYw3hIR1Ij1B8g+NI9jj0P1BMC6X7sliDEcreFB5\n' +
+    'QHVdx0T5UFFE6XmH2ue7Q5IWp6cL1ShsRyXHRoE9okb0BI8c3S9haXDBCj44ndAN\n' +
+    'VUXrDlykevFXC/k7fHBTdQKBgHjIshpoEycOD1e753oS4JTL6GdO6271DlFq5LYj\n' +
+    'IZNsXtCkJhH3vvJ35Hp8XEu4snQ0hfV90d79PuS+pRppOETct8pqKVp8hL4ymv8U\n' +
+    'v+0vkQN7NeA3pnZW0W/kag400nP8xJ26f+xiggw9Q4vOlFSioe6loUjgCBNZDlh3\n' +
+    'iO5VAoGASXkcv39B9/8FuWQ7rwhXHEubxOOwZZzSBU1wtLj2qHyPGoeU9ZpsmdrL\n' +
+    'XS9w1Jy0e49qmbBjzTqAEBw2nn/JVMFHyI/s//JVF7Q9GfBZAF5XF6mJ24yzTKgF\n' +
+    'kSoO5T+7s8NXi0eAIBe4CkWCBX7kWEZtu46GuVhsrC3oEazuLOs=\n' +
+    '-----END RSA PRIVATE KEY-----\n';
+}

package/src/jwt/jwt-ratchet-config.ts

@@ -0,0 +1,18 @@
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+
+/**
+ * Functions to help with creating and decoding JWTs
+ *
+ * JWTRatchet accepts promises for its inputs for the simple reason that best practice dictates that the keys
+ * should never be in the code, which means it is likely somewhere else.  That MIGHT be somewhere synchronous
+ * like an environmental variable, but it could very likely be someplace remote like a secure key store.  By
+ * accepting promises here, we make it easy to do JwtRatchet construction in a place (like an IOT container)
+ * that itself must be synchronous
+ */
+export interface JwtRatchetConfig {
+  encryptionKeyPromise: Promise<string | string[]>;
+  decryptKeysPromise?: Promise<string[]>;
+  jtiGenerator?: () => string;
+  decryptOnlyKeyUseLogLevel?: LoggerLevelName;
+  parseFailureLogLevel?: LoggerLevelName;
+}

package/src/jwt/jwt-ratchet-like.ts

@@ -0,0 +1,19 @@
+import { LoggerLevelName } from '@bitblit/ratchet-common/logger/logger-level-name';
+import { JwtTokenBase } from '@bitblit/ratchet-common/jwt/jwt-token-base';
+import { ExpiredJwtHandling } from '@bitblit/ratchet-common/jwt/expired-jwt-handling';
+
+/**
+ * Classes implementing this interface have Functions to help with creating and decoding JWTs
+ */
+export interface JwtRatchetLike {
+  get encryptionKeyPromise(): Promise<string | string[]>;
+  get decryptKeysPromise(): Promise<string[]>;
+  get jtiGenerator(): () => string;
+  get decryptOnlyKeyUseLogLevel(): LoggerLevelName;
+  get parseFailureLogLevel(): LoggerLevelName;
+  decodeToken<T extends JwtTokenBase>(payloadString: string, expiredHandling?: ExpiredJwtHandling): Promise<T>;
+  encryptionKeyArray(): Promise<string[]>;
+  selectRandomEncryptionKey(): Promise<string>;
+  createTokenString(payload: any, expirationSeconds?: number, overrideEncryptionKey?: string): Promise<string>;
+  refreshJWTString(tokenString: string, allowExpired?: boolean, expirationSeconds?: number): Promise<string>;
+}