@bitblit/ratchet-epsilon-common 6.0.146-alpha → 6.0.148-alpha

package/src/background/manager/background-manager-like.ts

@@ -0,0 +1,44 @@
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { Subject } from 'rxjs';
+
+/**
+ * Classes implementing this interface handle all submission of work to the background processing system.
+ *
+ * Note that these do NOT validate the input, they just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export interface BackgroundManagerLike {
+  // Used in info dumps and logging
+  backgroundManagerName: string;
+  // If the class defines this, other classes can register to be notified the instant anything arrives in the queue
+  immediateProcessQueue?(): Subject<InternalBackgroundEntry<any>>;
+  // Wraps up an entry
+  createEntry<T>(type: string, data?: T): BackgroundEntry<T>;
+  // Wraps up an entry and adds internal control structures
+  wrapEntryForInternal<T>(
+    entry: BackgroundEntry<T>,
+    overrideTraceId?: string,
+    overrideTraceDepth?: number,
+  ): Promise<InternalBackgroundEntry<T>>;
+  // Helper method to simplify building a request and add it to the queue
+  addEntryToQueueByParts<T>(type: string, data?: T, fireStartMessage?: boolean): Promise<string>;
+  // Add an entry to the queue for background processing, and optionally fire a start message after it is added
+  addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+  // Helper method to add more than one entry, and optionally fire a start message after all are added
+  addEntriesToQueue(entries: BackgroundEntry<any>[], fireStartMessage?: boolean): Promise<string[]>;
+  // Helper method to simplify building a request and then immediately run it in the background processor
+  fireImmediateProcessRequestByParts<T>(type: string, data?: T): Promise<string>;
+  // Immediately run a request in the background processor
+  fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+  // Tell the processor to try reading the queue and start processing if anything is found
+  fireStartProcessingRequest(): Promise<string>;
+  // Check approximately how many entries are currently waiting in the queue
+  fetchApproximateNumberOfQueueEntries(): Promise<number>;
+  // Read a single entry from the background queue
+  takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+  // If defined, allows the entry to be modified immediately prior to submission to the processors
+  // Allows global behavior like reading a large body from S3 for example
+  modifyPayloadPreProcess?<T>(entry: InternalBackgroundEntry<T>): Promise<InternalBackgroundEntry<T>>;
+}

package/src/background/manager/background-manager.spec.ts

@@ -0,0 +1,89 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { GetQueueAttributesCommand, GetQueueAttributesResult, SQSClient } from '@aws-sdk/client-sqs';
+//import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { AwsSqsSnsBackgroundManager } from './aws-sqs-sns-background-manager.js';
+import { BackgroundConfig } from '../../config/background/background-config.js';
+import { EchoProcessor } from '../../built-in/background/echo-processor.js';
+import { NoOpProcessor } from '../../built-in/background/no-op-processor.js';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config.js';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { mockClient } from 'aws-sdk-client-mock';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+let mockSqs;
+let mockSns;
+
+describe('#createEntry', function () {
+  mockSns = mockClient(SNSClient);
+  mockSqs = mockClient(SQSClient);
+
+  let backgroundMgr: AwsSqsSnsBackgroundManager;
+  const fakeAccountNumber: string = '123456789012';
+  let _backgroundConfig: BackgroundConfig;
+  let backgroundAwsConfig: BackgroundAwsConfig;
+  //const fakeModelValidator: ModelValidator = new ModelValidator({ BackgroundBuiltInSampleInputValidatedProcessor: {} });
+
+  const echoProcessor: EchoProcessor = new EchoProcessor();
+  const noOpProcessor: NoOpProcessor = new NoOpProcessor();
+
+  beforeEach(() => {
+    mockSqs.reset();
+    mockSns.reset();
+
+    _backgroundConfig = {
+      processors: [echoProcessor, noOpProcessor],
+      httpSubmissionPath: '/background/',
+      implyTypeFromPathSuffix: true,
+      httpMetaEndpoint: '/background-meta',
+    };
+
+    backgroundAwsConfig = {
+      queueUrl: 'https://fake-sqs.fake-availability-zone.test.com/' + fakeAccountNumber + '/fakeQueue.fifo',
+      notificationArn: 'arn:aws:sns:fake-availability-zone:' + fakeAccountNumber + ':fakeSnsTopicName',
+    };
+
+    backgroundMgr = new AwsSqsSnsBackgroundManager(backgroundAwsConfig, mockSqs, mockSns);
+  });
+
+  test('Should return queue attributes', async () => {
+    mockSqs.on(GetQueueAttributesCommand).resolves({
+      Attributes: {
+        ApproximateNumberOfMessages: 1,
+      },
+    });
+
+    const queueAttr: GetQueueAttributesResult = await backgroundMgr.fetchCurrentQueueAttributes();
+    const msgCount: number = await backgroundMgr.fetchApproximateNumberOfQueueEntries();
+    Logger.info('Got : %j', queueAttr);
+    Logger.info('Msg: %d', msgCount);
+    expect(queueAttr).toBeTruthy();
+    expect(msgCount).toEqual(1);
+  });
+
+  test('Should round-trip guids with prefix no slash', async () => {
+    const prefix: string = 'test';
+    const guid: string = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+    expect(guid).toBeTruthy();
+    const path: string = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+    const outGuid: string = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+    expect(outGuid).toEqual(guid);
+  });
+
+  test('Should round-trip guids with prefix with slash', async () => {
+    const prefix: string = 'test/';
+    const guid: string = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+    expect(guid).toBeTruthy();
+    const path: string = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+    const outGuid: string = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+    expect(outGuid).toEqual(guid);
+  });
+
+  test('Should round-trip guids with no prefix', async () => {
+    const prefix: string = null;
+    const guid: string = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+    expect(guid).toBeTruthy();
+    const path: string = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+    const outGuid: string = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+    expect(outGuid).toEqual(guid);
+  });
+});

package/src/background/manager/single-thread-local-background-manager.ts

@@ -0,0 +1,58 @@
+import { Subject } from 'rxjs';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
+
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
+  private _localBus: Subject<InternalBackgroundEntry<any>> = new Subject<InternalBackgroundEntry<any>>();
+
+  public readonly backgroundManagerName: string = 'SingleThreadLocalBackgroundManager';
+
+  // Super constructor automatically called
+  public immediateProcessQueue?(): Subject<InternalBackgroundEntry<any>> {
+    return this._localBus;
+  }
+
+  public async addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string> {
+    const wrapped: InternalBackgroundEntry<T> = await this.wrapEntryForInternal(entry);
+    const rval: string = wrapped.guid;
+    Logger.info('Add entry to queue (local) : %j : Start : %s', entry, fireStartMessage);
+    this._localBus.next(wrapped);
+    return rval;
+  }
+
+  public async fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string> {
+    let rval: string = null;
+    const wrapped: InternalBackgroundEntry<T> = await this.wrapEntryForInternal(entry);
+    rval = wrapped.guid;
+    Logger.info('Fire immediately (local) : %j ', entry);
+    this._localBus.next(wrapped);
+    return rval;
+  }
+
+  public async fireStartProcessingRequest(): Promise<string> {
+    let rval: string = null;
+    Logger.info('Fire start processing request (local, ignored)');
+    rval = 'NO-OP';
+    return rval;
+  }
+
+  public async fetchApproximateNumberOfQueueEntries(): Promise<number> {
+    let rval: number = null;
+    rval = 0; // No queue when running locally
+    return rval;
+  }
+
+  public async takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]> {
+    Logger.info('Called takeEntryFromBackgroundQueue on SingleThreadedLocal - returning empty');
+    return [];
+  }
+}

package/src/background/s3-background-transaction-logger.ts

@@ -0,0 +1,65 @@
+import { BackgroundTransactionLogger } from '../config/background/background-transaction-logger.js';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log.js';
+import { AbstractBackgroundManager } from './manager/abstract-background-manager.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { S3Client } from '@aws-sdk/client-s3';
+import { S3CacheRatchet } from '@bitblit/ratchet-aws/s3/s3-cache-ratchet';
+
+export class S3BackgroundTransactionLogger implements BackgroundTransactionLogger {
+  private s3TransactionLogCacheRatchet: S3CacheRatchet;
+
+  constructor(private cfg: BackgroundS3TransactionLoggingConfig) {
+    const err: string[] = S3BackgroundTransactionLogger.validateConfig(cfg);
+    if (err.length) {
+      ErrorRatchet.throwFormattedErr('Invalid S3BackgroundTransactionLogger config : %j', err);
+    }
+    this.s3TransactionLogCacheRatchet = new S3CacheRatchet(this.cfg.s3, this.cfg.bucket);
+  }
+
+  public async logTransaction(txLog: BackgroundTransactionLog): Promise<void> {
+    if (txLog) {
+      if (txLog.request?.guid) {
+        await this.s3TransactionLogCacheRatchet.writeObjectToCacheFile(
+          AbstractBackgroundManager.backgroundGuidToPath(this.cfg.prefix, txLog.request.guid),
+          txLog,
+        );
+      } else {
+        Logger.warn('Could not write transaction record - no guid defined : %j', txLog);
+      }
+    } else {
+      Logger.silly('Skipping write of null log');
+    }
+  }
+
+  public async readTransactionLog(txGuid: string): Promise<BackgroundTransactionLog> {
+    const path: string = AbstractBackgroundManager.backgroundGuidToPath(this.cfg.prefix, txGuid);
+    const log = await this.s3TransactionLogCacheRatchet.fetchCacheFileAsObject<BackgroundTransactionLog>(path);
+    return log;
+  }
+
+  public static validateConfig(cfg: BackgroundS3TransactionLoggingConfig): string[] {
+    const rval: string[] = [];
+    if (cfg) {
+      if (!cfg.s3) {
+        rval.push('You must supply an S3 object');
+      }
+      if (!cfg.bucket) {
+        rval.push('You must supply a bucket');
+      }
+      if (!cfg.timeToLiveDays) {
+        rval.push('You must supply a timeToLiveDays');
+      }
+    } else {
+      rval.push('No config defined');
+    }
+    return rval;
+  }
+}
+
+export interface BackgroundS3TransactionLoggingConfig {
+  s3: S3Client;
+  bucket: string;
+  timeToLiveDays: number;
+  prefix?: string;
+}

package/src/build/ratchet-epsilon-common-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetEpsilonCommonInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/built-in/background/echo-processor.ts

@@ -0,0 +1,17 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export class EchoProcessor implements BackgroundProcessor<any> {
+  public static readonly ECHO_PROCESSOR_TYPE_NAME: string = 'EpsilonEcho';
+  public readonly typeName: string = EchoProcessor.ECHO_PROCESSOR_TYPE_NAME;
+
+  public async handleEvent(data: any, _mgr?: BackgroundManagerLike): Promise<void> {
+    Logger.info('Echo processing : %j', data);
+    if (data && StringRatchet.trimToNull(data['error'])) {
+      ErrorRatchet.throwFormattedErr('Forced error : %s', data['error']);
+    }
+  }
+}

package/src/built-in/background/log-and-enqueue-echo-processor.ts

@@ -0,0 +1,14 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { EchoProcessor } from './echo-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export class LogAndEnqueueEchoProcessor implements BackgroundProcessor<any> {
+  public readonly typeName: string = 'EpsilonLogAndEnqueueEcho';
+
+  public async handleEvent(data: any, cfg: BackgroundManagerLike): Promise<void> {
+    Logger.info('LogAndEnqueueEchoProcessor : %j', data);
+    await cfg.fireImmediateProcessRequestByParts(EchoProcessor.ECHO_PROCESSOR_TYPE_NAME, { upstream: data });
+    Logger.info('Completed : LogAndEnqueueEchoProcessor');
+  }
+}

package/src/built-in/background/log-message-background-error-processor.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundErrorProcessor } from '../../config/background/background-error-processor.js';
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
+
+// This is just here to test error processor logic (errors are logged anyway)
+export class LogMessageBackgroundErrorProcessor implements BackgroundErrorProcessor {
+  public async handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void> {
+    Logger.error('-------- ERROR PROCESSED : %j : %s----', submission, error);
+  }
+}

package/src/built-in/background/no-op-processor.ts

@@ -0,0 +1,12 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export class NoOpProcessor implements BackgroundProcessor<any> {
+  public readonly typeName: string = 'EpsilonNoOp';
+
+  public async handleEvent(_data: any, _mgr?: BackgroundManagerLike): Promise<void> {
+    // Does nothing
+    Logger.silly('Hit the no-op proc');
+  }
+}

package/src/built-in/background/retry-processor.ts

@@ -0,0 +1,51 @@
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
+import { DurationRatchet } from '@bitblit/ratchet-common/lang/duration-ratchet';
+
+export class RetryProcessor implements BackgroundProcessor<any> {
+  private static readonly RETRY_FIELD_NAME: string = '___RetryProcessorTryNumber';
+
+  constructor(
+    private delegate: BackgroundProcessor<any>,
+    private opts: RetryProcessorOptions,
+  ) {}
+
+  public get typeName(): string {
+    return StringRatchet.trimToEmpty(this.opts?.typePrefix) + this.delegate.typeName + StringRatchet.trimToEmpty(this.opts?.typeSuffix);
+  }
+
+  public async handleEvent(data: any, mgr: BackgroundManagerLike): Promise<void> {
+    const tryNumber: number =
+      data && data[RetryProcessor.RETRY_FIELD_NAME] ? NumberRatchet.safeNumber(data[RetryProcessor.RETRY_FIELD_NAME]) : 1;
+    const dataCopy: any = data ? Object.assign({}, data) : null;
+    //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete dataCopy[RetryProcessor.RETRY_FIELD_NAME];
+    Logger.info('RetryProcessor : %s : Try %d of %d', this.delegate.typeName, tryNumber, this.opts.retryCount);
+    try {
+      await this.delegate.handleEvent(dataCopy, mgr);
+    } catch (err) {
+      Logger.error('Failed to process : %s', err, err);
+      if (tryNumber < this.opts.retryCount) {
+        const waitTimeMS: number = tryNumber * this.opts.baseDelayMS;
+        Logger.info('Firing automatic retry after a wait of %s', DurationRatchet.formatMsDuration(waitTimeMS));
+        await PromiseRatchet.wait(waitTimeMS);
+        const wrapped: any = dataCopy || {};
+        wrapped[RetryProcessor.RETRY_FIELD_NAME] = tryNumber + 1;
+        await mgr.fireImmediateProcessRequestByParts(this.typeName, wrapped);
+      } else {
+        Logger.error('That was the last try - giving up');
+      }
+    }
+  }
+}
+
+export interface RetryProcessorOptions {
+  retryCount?: number;
+  baseDelayMS?: number;
+  typePrefix?: string;
+  typeSuffix?: string;
+}

package/src/built-in/background/sample-delay-processor.ts

@@ -0,0 +1,15 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export class SampleDelayProcessor implements BackgroundProcessor<any> {
+  public readonly typeName: string = 'EpsilonSampleDelay';
+
+  public async handleEvent(_data: any, _mgr?: BackgroundManagerLike): Promise<void> {
+    const delayMS: number = Math.floor(Math.random() * 5000);
+    Logger.info('Running sample processor for %d', delayMS);
+    await PromiseRatchet.wait(delayMS);
+    Logger.info('Sample processor complete');
+  }
+}

package/src/built-in/background/sample-input-validated-processor-data.ts

@@ -0,0 +1,4 @@
+export interface SampleInputValidatedProcessorData {
+  nameParam: string;
+  numberParam: number;
+}

package/src/built-in/background/sample-input-validated-processor.ts

@@ -0,0 +1,14 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { SampleInputValidatedProcessorData } from './sample-input-validated-processor-data.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
+
+export class SampleInputValidatedProcessor implements BackgroundProcessor<SampleInputValidatedProcessorData> {
+  public readonly typeName: string = 'EpsilonSampleInputValidated';
+
+  public async handleEvent(data: SampleInputValidatedProcessorData, _mgr?: BackgroundManagerLike): Promise<void> {
+    Logger.info('Running SampleInputValidatedProcessor, data was : %j', data);
+  }
+
+  public readonly dataSchemaName: string = 'BackgroundSampleInputValidatedProcessorData';
+}

package/src/built-in/built-in-trace-id-generators.ts

@@ -0,0 +1,22 @@
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { ContextUtil } from '../util/context-util.js';
+
+export class BuiltInTraceIdGenerators {
+  public static fullAwsRequestId(): string {
+    return ContextUtil.defaultedCurrentRequestId();
+  }
+
+  public static shortAwsRequestId(): string {
+    let rval: string = BuiltInTraceIdGenerators.fullAwsRequestId();
+    if (rval.length > 10) {
+      let idx: number = rval.lastIndexOf('-');
+      idx = idx === -1 ? rval.length - 10 : idx;
+      rval = rval.substring(idx);
+    }
+    return rval;
+  }
+
+  public static fixedLengthHex(length: number = 10): string {
+    return StringRatchet.createRandomHexString(length);
+  }
+}

package/src/built-in/daemon/daemon-authorizer-function.ts

@@ -0,0 +1,4 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws-node-only/daemon/daemon-process-state';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+
+export type DaemonAuthorizerFunction = (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState) => Promise<boolean>;

package/src/built-in/daemon/daemon-config.ts

@@ -0,0 +1,9 @@
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { DaemonGroupSelectionFunction } from './daemon-group-selection-function.js';
+
+export interface DaemonConfig {
+  authorizer?: DaemonAuthorizerFunction;
+  groupSelector?: DaemonGroupSelectionFunction;
+  fetchDaemonStatusPathParameter?: string;
+  fetchDaemonStatusByPublicTokenPathParameter?: string;
+}

package/src/built-in/daemon/daemon-group-selection-function.ts

@@ -0,0 +1,3 @@
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+
+export type DaemonGroupSelectionFunction = (evt: ExtendedAPIGatewayEvent) => Promise<string>;

package/src/built-in/daemon/daemon-handler.ts

@@ -0,0 +1,87 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { DaemonProcessState } from '@bitblit/ratchet-aws-node-only/daemon/daemon-process-state';
+import { DaemonLike } from '@bitblit/ratchet-aws-node-only/daemon/daemon-like';
+import { DaemonAuthorizerFunction } from './daemon-authorizer-function.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
+import { NotFoundError } from '../../http/error/not-found-error.js';
+import { DaemonProcessStateList } from './daemon-process-state-list.js';
+import { DaemonConfig } from './daemon-config.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+/**
+ * A helper class to simplify adding Ratchet "Daemon" handling to your application
+ */
+export class DaemonHandler {
+  public static readonly ALLOW_EVERYTHING_AUTHORIZER: DaemonAuthorizerFunction = async (
+    _evt: ExtendedAPIGatewayEvent,
+    _proc: DaemonProcessState,
+  ) => {
+    return true;
+  };
+  private config: DaemonConfig;
+  //private groupSelectionFunction: DaemonGroupSelectionFunction;
+  //private authorizer: DaemonAuthorizerFunction;
+
+  /**
+   * Initialize the Router
+   */
+  constructor(
+    private daemon: DaemonLike,
+    private inConfig?: DaemonConfig,
+  ) {
+    this.config = inConfig || {};
+    this.config.authorizer = this.config.authorizer || DaemonHandler.ALLOW_EVERYTHING_AUTHORIZER;
+    this.config.groupSelector = this.config.groupSelector || ((_evt: ExtendedAPIGatewayEvent) => Promise.resolve(daemon.defaultGroup));
+    this.config.fetchDaemonStatusByPublicTokenPathParameter =
+      StringRatchet.trimToNull(this.config.fetchDaemonStatusByPublicTokenPathParameter) || 'publicToken';
+    this.config.fetchDaemonStatusPathParameter = StringRatchet.trimToNull(this.config.fetchDaemonStatusPathParameter) || 'key';
+  }
+
+  // If you are going to map this function, be sure that your Daemon is setup with a JwtRatchet...
+  public async fetchDaemonStatusByPublicToken(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState> {
+    // TODO: verify has access to this key
+    const publicToken: string = evt.pathParameters[this.config.fetchDaemonStatusByPublicTokenPathParameter];
+    Logger.info('Fetching daemon status for token: %s', publicToken);
+
+    let rval: DaemonProcessState = await this.daemon.statFromPublicToken(publicToken);
+    const canRead: boolean = rval ? await this.config.authorizer(evt, rval) : false;
+    rval = canRead ? rval : null;
+    if (rval === null) {
+      throw new NotFoundError('No such token : ' + publicToken);
+    }
+    return rval;
+  }
+
+  public async fetchDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessState> {
+    // TODO: verify has access to this key
+    const daemonKey: string = evt.pathParameters[this.config.fetchDaemonStatusPathParameter];
+    Logger.info('Fetching daemon status for : %s', daemonKey);
+
+    let rval: DaemonProcessState = await this.daemon.stat(daemonKey);
+    const canRead: boolean = rval ? await this.config.authorizer(evt, rval) : false;
+    rval = canRead ? rval : null;
+    if (rval === null) {
+      throw new NotFoundError('No such key : ' + daemonKey);
+    }
+    return rval;
+  }
+
+  public async listDaemonStatus(evt: ExtendedAPIGatewayEvent): Promise<DaemonProcessStateList> {
+    const group: string = await this.config.groupSelector(evt);
+    const keys: DaemonProcessState[] = await this.daemon.list(group);
+    const allowed: DaemonProcessState[] = [];
+    for (const kVal of keys) {
+      //for (let i = 0; i < keys.length; i++) {
+      const canRead: boolean = await this.config.authorizer(evt, kVal);
+      if (canRead) {
+        allowed.push(kVal);
+      }
+    }
+    // Token here for future expansion into pagination, not implemented yet
+    const rval: DaemonProcessStateList = {
+      results: allowed,
+      nextToken: null,
+    };
+    return rval;
+  }
+}

package/src/built-in/daemon/daemon-process-state-list.ts

@@ -0,0 +1,9 @@
+import { DaemonProcessState } from '@bitblit/ratchet-aws-node-only/daemon/daemon-process-state';
+
+/**
+ * Wrapper for future pagination capability
+ */
+export interface DaemonProcessStateList {
+  results: DaemonProcessState[];
+  nextToken: string;
+}

package/src/built-in/http/apollo/apollo-util.ts

@@ -0,0 +1,43 @@
+import { BaseContext } from '@apollo/server';
+import { EpsilonLambdaApolloContextFunctionArgument } from './epsilon-lambda-apollo-context-function-argument.js';
+import { EventUtil } from '../../../http/event-util.js';
+import { DefaultEpsilonApolloContext } from './default-epsilon-apollo-context.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { JwtTokenBase } from '@bitblit/ratchet-common/jwt/jwt-token-base';
+import { ExpiredJwtHandling } from '@bitblit/ratchet-common/jwt/expired-jwt-handling';
+import { EpsilonApolloContextBuilderOptions } from './epsilon-apollo-context-builder-options';
+
+export class ApolloUtil {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  //const defaultContextFn: ContextFunction<[EpsilonLambdaApolloContextFunctionArgument], any> = async () => ({});
+
+  public static async emptyContext<T extends BaseContext>(): Promise<T> {
+    return {} as T;
+  }
+
+  public static async defaultEpsilonApolloContext(
+    args: EpsilonLambdaApolloContextFunctionArgument,
+    opts?: EpsilonApolloContextBuilderOptions,
+  ): Promise<DefaultEpsilonApolloContext<any>> {
+    const authTokenSt: string = EventUtil.extractBearerTokenFromEvent(args.lambdaEvent);
+    let token: JwtTokenBase = null;
+    if (StringRatchet.trimToNull(authTokenSt) && opts?.jwtRatchet) {
+      Logger.debug('Proc token : %s', StringRatchet.obscure(authTokenSt));
+      token = await opts.jwtRatchet.decodeToken(authTokenSt, ExpiredJwtHandling.RETURN_NULL);
+    }
+
+    const rval: DefaultEpsilonApolloContext<any> = {
+      user: token,
+      bearerTokenString: authTokenSt,
+      headers: args.lambdaEvent.headers,
+      functionName: args.lambdaContext.functionName,
+      lambdaEvent: args.lambdaEvent,
+      lambdaContext: args.lambdaContext,
+    };
+    return rval;
+  }
+}

package/src/built-in/http/apollo/default-epsilon-apollo-context.ts

@@ -0,0 +1,11 @@
+import { APIGatewayEvent, Context } from 'aws-lambda';
+import { JwtTokenBase } from '@bitblit/ratchet-common/jwt/jwt-token-base';
+
+export interface DefaultEpsilonApolloContext<T extends JwtTokenBase> {
+  user?: T;
+  bearerTokenString?: string;
+  headers: Record<string, string>;
+  functionName: string;
+  lambdaEvent: APIGatewayEvent;
+  lambdaContext: Context;
+}

package/src/built-in/http/apollo/epsilon-apollo-context-builder-options.ts

@@ -0,0 +1,5 @@
+import { JwtRatchetLike } from '@bitblit/ratchet-node-only/jwt/jwt-ratchet-like';
+
+export interface EpsilonApolloContextBuilderOptions {
+  jwtRatchet?: JwtRatchetLike;
+}

package/src/built-in/http/apollo/epsilon-lambda-apollo-context-function-argument.ts

@@ -0,0 +1,6 @@
+import { APIGatewayEvent, Context } from 'aws-lambda';
+
+export interface EpsilonLambdaApolloContextFunctionArgument {
+  lambdaEvent: APIGatewayEvent;
+  lambdaContext: Context;
+}