@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/es/background/background-http-adapter-handler.js

@@ -0,0 +1,123 @@
+import { Logger, StopWatch } from '@bitblit/ratchet-common';
+import { BooleanRatchet } from '@bitblit/ratchet-common';
+import { BackgroundProcessHandling } from './background-process-handling';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { BadRequestError } from '../http/error/bad-request-error';
+import { NotFoundError } from '../http/error/not-found-error';
+import { PromiseRatchet } from '@bitblit/ratchet-common';
+export class BackgroundHttpAdapterHandler {
+    constructor(backgroundConfig, modelValidator, backgroundManager, maxWaitInMsForBackgroundJobToStart = 10000) {
+        this.backgroundConfig = backgroundConfig;
+        this.modelValidator = modelValidator;
+        this.backgroundManager = backgroundManager;
+        this.maxWaitInMsForBackgroundJobToStart = maxWaitInMsForBackgroundJobToStart;
+    }
+    get httpMetaEndpoint() {
+        return this.backgroundConfig.httpMetaEndpoint;
+    }
+    get httpSubmissionPath() {
+        return this.backgroundConfig.httpSubmissionPath;
+    }
+    get httpStatusPath() {
+        return this.backgroundConfig.httpStatusEndpoint;
+    }
+    get implyTypeFromPathSuffix() {
+        return this.backgroundConfig.implyTypeFromPathSuffix;
+    }
+    async handleBackgroundStatusRequest(evt, context) {
+        Logger.info('handleBackgroundStatusRequest called');
+        if (!this.backgroundConfig.transactionLogger) {
+            throw new BadRequestError('Process logging not enabled');
+        }
+        else {
+            const guid = StringRatchet.trimToNull(evt.pathParameters['guid']) || StringRatchet.trimToNull(evt.queryStringParameters['guid']);
+            if (guid) {
+                const sw = new StopWatch();
+                let log = null;
+                while (!log && sw.elapsedMS() < this.maxWaitInMsForBackgroundJobToStart) {
+                    log = await this.backgroundConfig.transactionLogger.readTransactionLog(guid);
+                    if (!log) {
+                        Logger.debug('No log found yet, waiting 500 ms and retrying (%s of %d waited so far)', sw.dump(), this.maxWaitInMsForBackgroundJobToStart);
+                        await PromiseRatchet.wait(500);
+                    }
+                }
+                if (!log) {
+                    throw new NotFoundError().withFormattedErrorMessage('No background result found for guid %s', guid);
+                }
+                return log;
+            }
+            else {
+                throw new BadRequestError('No guid specified');
+            }
+        }
+    }
+    async handleBackgroundMetaRequest(evt, context) {
+        Logger.info('handleBackgroundMetaRequest called');
+        const currentCount = await this.backgroundManager.fetchApproximateNumberOfQueueEntries();
+        const valid = this.backgroundConfig.processors.map((b) => b.typeName).filter((a) => !!a);
+        valid.sort((a, b) => a.localeCompare(b));
+        const rval = {
+            currentQueueLength: currentCount,
+            validTypes: valid,
+            backgroundManagerName: this.backgroundManager.backgroundManagerName,
+        };
+        return rval;
+    }
+    async handleBackgroundSubmission(evt, context) {
+        Logger.info('handleBackgroundSubmission : %j (mgr:%s)', evt.parsedBody, this.backgroundManager.backgroundManagerName);
+        let rval = null;
+        const startIdx = evt.path.indexOf(this.httpSubmissionPath) + this.httpSubmissionPath.length;
+        let pathSuppliedBackgroundType = this.backgroundConfig.implyTypeFromPathSuffix
+            ? evt.path.substring(startIdx).split('-').join('').toLowerCase()
+            : '';
+        if (pathSuppliedBackgroundType.includes('?')) {
+            pathSuppliedBackgroundType = pathSuppliedBackgroundType.substring(0, pathSuppliedBackgroundType.indexOf('?'));
+        }
+        if (pathSuppliedBackgroundType.includes('#')) {
+            pathSuppliedBackgroundType = pathSuppliedBackgroundType.substring(0, pathSuppliedBackgroundType.indexOf('#'));
+        }
+        const entry = evt.parsedBody || {};
+        if (StringRatchet.trimToNull(pathSuppliedBackgroundType)) {
+            if (StringRatchet.trimToNull(entry?.type) && entry.type.toLocaleLowerCase() !== pathSuppliedBackgroundType.toLocaleLowerCase()) {
+                throw new BadRequestError('Background submission has type but does not match path supplied type');
+            }
+            else {
+                entry.type = pathSuppliedBackgroundType;
+            }
+        }
+        else {
+            if (!StringRatchet.trimToNull(entry?.type)) {
+                throw new BadRequestError('Background submission missing type and not configured in pathed mode');
+            }
+        }
+        const foundProc = this.backgroundConfig.processors.find((s) => s.typeName.toLowerCase() === entry.type.toLowerCase());
+        const immediate = BooleanRatchet.parseBool(evt.queryStringParameters['immediate']);
+        const startProcessor = BooleanRatchet.parseBool(evt.queryStringParameters['startProcessor']);
+        if (foundProc) {
+            if (StringRatchet.trimToNull(foundProc.dataSchemaName)) {
+                const errors = this.modelValidator.validate(foundProc.dataSchemaName, entry.data, false, false);
+                if (errors.length > 0) {
+                    throw new BadRequestError().withErrors(errors);
+                }
+            }
+            let result = null;
+            if (immediate) {
+                result = await this.backgroundManager.fireImmediateProcessRequest(entry);
+            }
+            else {
+                result = await this.backgroundManager.addEntryToQueue(entry, startProcessor);
+            }
+            rval = {
+                processHandling: immediate ? BackgroundProcessHandling.Immediate : BackgroundProcessHandling.Queued,
+                startProcessorRequested: startProcessor,
+                success: true,
+                resultId: result,
+                error: null,
+            };
+        }
+        else {
+            throw new BadRequestError().withFormattedErrorMessage('Could not find target background processor : %s', entry.type);
+        }
+        return rval;
+    }
+}

package/dist/es/background/background-meta-response-internal.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-process-handling.js

@@ -0,0 +1,5 @@
+export var BackgroundProcessHandling;
+(function (BackgroundProcessHandling) {
+    BackgroundProcessHandling["Queued"] = "Queued";
+    BackgroundProcessHandling["Immediate"] = "Immediate";
+})(BackgroundProcessHandling || (BackgroundProcessHandling = {}));

package/dist/es/background/background-process-log-table-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-queue-response-internal.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-validator.js

@@ -0,0 +1,84 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class BackgroundValidator {
+    constructor(cfg, modelValidator) {
+        this.cfg = cfg;
+        this.modelValidator = modelValidator;
+    }
+    findProcessor(typeName) {
+        const rval = this.cfg.processors.find((s) => s.typeName === typeName);
+        return rval;
+    }
+    validType(type) {
+        return !!this.findProcessor(type);
+    }
+    validateEntry(entry) {
+        const rval = [];
+        if (!entry) {
+            rval.push('Entry is null');
+        }
+        else if (!StringRatchet.trimToNull(entry.type)) {
+            rval.push('Entry type is null or empty');
+            const proc = this.findProcessor(entry.type);
+            if (!proc) {
+                rval.push('Entry type is invalid');
+            }
+        }
+        return rval;
+    }
+    validateEntryAndThrowException(entry) {
+        const errors = this.validateEntry(entry);
+        if (errors.length > 0) {
+            Logger.warn('Invalid entry %j : errors : %j', entry, errors);
+            ErrorRatchet.throwFormattedErr('Invalid entry %j : errors : %j', entry, errors);
+        }
+    }
+    static validateAndMapProcessors(processorInput, modelValidator) {
+        const rval = new Map();
+        processorInput.forEach((p, idx) => {
+            if (!p) {
+                ErrorRatchet.throwFormattedErr('Null processor provided at index %d', idx);
+            }
+            if (!StringRatchet.trimToNull(p.typeName)) {
+                ErrorRatchet.throwFormattedErr('Processor at index %d defines no name', idx);
+            }
+            if (rval.has(p.typeName)) {
+                ErrorRatchet.throwFormattedErr('More than one processor defined for type %s', p.typeName);
+            }
+            rval.set(p.typeName, p);
+        });
+        return rval;
+    }
+    static validateAwsConfig(cfg) {
+        const rval = [];
+        if (!cfg) {
+            rval.push('Null config');
+        }
+        else {
+            if (!cfg.notificationArn) {
+                rval.push('AWS config missing notificationArn');
+            }
+            if (!cfg.queueUrl) {
+                rval.push('AWS config missing queueUrl');
+            }
+            if ((cfg.sendNotificationOnBackgroundError || cfg.sendNotificationOnBackgroundValidationFailure) &&
+                !cfg.backgroundProcessFailureSnsArn) {
+                rval.push('At least one send notification flag set to true but no sns arn set');
+            }
+        }
+        return rval;
+    }
+    static validateConfig(cfg) {
+        const rval = [];
+        if (!cfg) {
+            rval.push('Null config');
+        }
+        else {
+            if (!cfg.processors || cfg.processors.length === 0) {
+                rval.push('No processes specified');
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/background/epsilon-background-process-error.js

@@ -0,0 +1,88 @@
+import util from 'util';
+export class EpsilonBackgroundProcessError extends Error {
+    constructor(...errors) {
+        super(EpsilonBackgroundProcessError.combineErrorStringsWithDefault(errors));
+        Object.setPrototypeOf(this, EpsilonBackgroundProcessError.prototype);
+        this._errors = errors;
+        this[EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY] = true;
+    }
+    static combineErrorStringsWithDefault(errors, defMessage = 'Internal Server Error') {
+        return errors && errors.length > 0 ? errors.join(',') : defMessage;
+    }
+    setFormattedErrorMessage(format, ...input) {
+        const msg = util.format(format, ...input);
+        this.errors = [msg];
+    }
+    withFormattedErrorMessage(format, ...input) {
+        this.setFormattedErrorMessage(format, ...input);
+        return this;
+    }
+    withErrors(errors) {
+        this.errors = errors;
+        return this;
+    }
+    withDetailErrorCode(detailErrorCode) {
+        this._detailErrorCode = detailErrorCode;
+        return this;
+    }
+    withDetails(details) {
+        this._details = details;
+        return this;
+    }
+    withRequestId(requestId) {
+        this._requestId = requestId;
+        return this;
+    }
+    withWrappedError(err) {
+        this._wrappedError = err;
+        return this;
+    }
+    isWrappedError() {
+        return !!this._wrappedError;
+    }
+    static wrapError(err) {
+        let rval = null;
+        if (EpsilonBackgroundProcessError.objectIsEpsilonBackgroundProcessError(err)) {
+            rval = err;
+        }
+        else {
+            rval = new EpsilonBackgroundProcessError(err.message).withWrappedError(err);
+        }
+        return rval;
+    }
+    static objectIsEpsilonBackgroundProcessError(obj) {
+        return obj && obj['__epsilonHttpErrorFlag'] === true;
+    }
+    set errors(value) {
+        this._errors = value || ['Internal Server Error'];
+        this.message = EpsilonBackgroundProcessError.combineErrorStringsWithDefault(this._errors);
+    }
+    get errors() {
+        return this._errors;
+    }
+    set detailErrorCode(value) {
+        this._detailErrorCode = value;
+    }
+    get detailErrorCode() {
+        return this._detailErrorCode;
+    }
+    set details(value) {
+        this._details = value;
+    }
+    get details() {
+        return this._details;
+    }
+    set requestId(value) {
+        this._requestId = value || 'MISSING';
+    }
+    get requestId() {
+        return this._requestId;
+    }
+    set wrappedError(value) {
+        this._wrappedError = value;
+    }
+    get wrappedError() {
+        return this._wrappedError;
+    }
+}
+EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY = '__epsilonBackgroundProcessErrorFlag';

package/dist/es/background/internal-background-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/manager/abstract-background-manager.js

@@ -0,0 +1,88 @@
+import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { DateTime } from 'luxon';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ContextUtil } from '../../util/context-util';
+export class AbstractBackgroundManager {
+    createEntry(type, data) {
+        const rval = {
+            type: type,
+            data: data,
+        };
+        return rval;
+    }
+    wrapEntryForInternal(entry, overrideTraceId, overrideTraceDepth) {
+        const rval = Object.assign({}, entry, {
+            createdEpochMS: new Date().getTime(),
+            guid: AbstractBackgroundManager.generateBackgroundGuid(),
+            traceId: overrideTraceId || ContextUtil.currentTraceId(),
+            traceDepth: overrideTraceDepth || ContextUtil.currentTraceDepth() + 1,
+        });
+        return rval;
+    }
+    async addEntryToQueueByParts(type, data, fireStartMessage) {
+        let rval = null;
+        const entry = this.createEntry(type, data);
+        if (entry) {
+            rval = await this.addEntryToQueue(entry, fireStartMessage);
+        }
+        return rval;
+    }
+    async addEntriesToQueue(entries, fireStartMessage) {
+        const rval = [];
+        for (let i = 0; i < entries.length; i++) {
+            try {
+                const tmp = await this.addEntryToQueue(entries[i], false);
+                rval.push(tmp);
+            }
+            catch (err) {
+                Logger.error('Error processing %j : %s', entries[i], err);
+                rval.push(err['message']);
+            }
+            if (fireStartMessage) {
+                const fireResult = await this.fireStartProcessingRequest();
+                Logger.silly('FireResult : %s', fireResult);
+            }
+        }
+        return rval;
+    }
+    async fireImmediateProcessRequestByParts(type, data) {
+        let rval = null;
+        const entry = this.createEntry(type, data);
+        if (entry) {
+            rval = await this.fireImmediateProcessRequest(entry);
+        }
+        return rval;
+    }
+    static generateBackgroundGuid(targetEpochMS = new Date().getTime()) {
+        const dt = DateTime.fromMillis(targetEpochMS);
+        return dt.toFormat('yyyy-MM-dd-HH-mm-ss-') + StringRatchet.createType4Guid();
+    }
+    static backgroundGuidToPath(prefix, guid) {
+        let path = StringRatchet.trimToEmpty(prefix);
+        if (path.length && !path.endsWith('/')) {
+            path += '/';
+        }
+        path += guid.substring(0, 4) + '/' + guid.substring(5, 7) + '/' + guid.substring(8, 10) + '/';
+        path += guid + '.json';
+        return path;
+    }
+    static pathToBackgroundGuid(prefix, path) {
+        RequireRatchet.notNullOrUndefined(path, 'path');
+        let start = 0;
+        if (!path.endsWith('.json')) {
+            ErrorRatchet.throwFormattedErr('Cannot extract guid, does not end with .json : %s : %s', path, prefix);
+        }
+        if (StringRatchet.trimToNull(prefix)) {
+            if (!path.startsWith(prefix)) {
+                ErrorRatchet.throwFormattedErr('Cannot extract guid, does not start with prefix : %s : %s', path, prefix);
+            }
+            start = prefix.length;
+            if (!prefix.endsWith('/')) {
+                start++;
+            }
+        }
+        start += 11;
+        return path.substring(start, path.length - 5);
+    }
+}

package/dist/es/background/manager/aws-sqs-sns-background-manager.js

@@ -0,0 +1,149 @@
+import { Logger, NumberRatchet } from '@bitblit/ratchet-common';
+import { DeleteMessageCommand, GetQueueAttributesCommand, ReceiveMessageCommand, SendMessageCommand, } from '@aws-sdk/client-sqs';
+import { EpsilonConstants } from '../../epsilon-constants';
+import { AbstractBackgroundManager } from './abstract-background-manager';
+import { BackgroundValidator } from '../background-validator';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { PublishCommand } from '@aws-sdk/client-sns';
+export class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
+    constructor(_awsConfig, _sqs, _sns) {
+        super();
+        this._awsConfig = _awsConfig;
+        this._sqs = _sqs;
+        this._sns = _sns;
+        const cfgErrors = BackgroundValidator.validateAwsConfig(_awsConfig);
+        if (cfgErrors.length) {
+            ErrorRatchet.throwFormattedErr('Cannot start - invalid AWS config : %j', cfgErrors);
+        }
+    }
+    get backgroundManagerName() {
+        return 'AwsSqsSnsBackgroundManager';
+    }
+    get awsConfig() {
+        return this._awsConfig;
+    }
+    get sqs() {
+        return this._sqs;
+    }
+    get sns() {
+        return this._sns;
+    }
+    async addEntryToQueue(entry, fireStartMessage) {
+        try {
+            const wrapped = this.wrapEntryForInternal(entry);
+            const rval = wrapped.guid;
+            const params = {
+                DelaySeconds: 0,
+                MessageBody: JSON.stringify(wrapped),
+                MessageGroupId: entry.type,
+                QueueUrl: this.awsConfig.queueUrl,
+            };
+            Logger.info('Add entry to queue (remote) : %j : Start : %s', params, fireStartMessage);
+            const result = await this.sqs.send(new SendMessageCommand(params));
+            if (fireStartMessage) {
+                const fireResult = await this.fireStartProcessingRequest();
+                Logger.silly('FireResult : %s', fireResult);
+            }
+            Logger.info('Background process %s using message id %s', rval, result.MessageId);
+            return rval;
+        }
+        catch (error) {
+            Logger.error('Error inserting background entry into SQS queue : %j', error);
+            throw new Error('Error inserting background entry into SQS queue : ' + error['code'] + ' : ' + error['name']);
+        }
+    }
+    async fireImmediateProcessRequest(entry) {
+        let rval = null;
+        const wrapped = this.wrapEntryForInternal(entry);
+        rval = wrapped.guid;
+        try {
+            Logger.info('Fire immediately (remote) : %j ', entry);
+            const toWrite = {
+                type: EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG,
+                backgroundEntry: wrapped,
+            };
+            const msg = JSON.stringify(toWrite);
+            const snsId = await this.writeMessageToSnsTopic(msg);
+            Logger.debug('Background guid %s Wrote message : %s to SNS : %s', rval, msg, snsId);
+        }
+        catch (err) {
+            Logger.error('Failed to fireImmediateProcessRequest : %s', err, err);
+        }
+        return rval;
+    }
+    async fireStartProcessingRequest() {
+        let rval = null;
+        try {
+            Logger.info('Fire start processing request (remote)');
+            rval = await this.writeMessageToSnsTopic(EpsilonConstants.BACKGROUND_SNS_START_MARKER);
+        }
+        catch (err) {
+            Logger.error('Failed to fireStartProcessingRequest : %s', err, err);
+        }
+        return rval;
+    }
+    async fetchApproximateNumberOfQueueEntries() {
+        let rval = null;
+        const all = await this.fetchCurrentQueueAttributes();
+        rval = NumberRatchet.safeNumber(all.Attributes['ApproximateNumberOfMessages']);
+        return rval;
+    }
+    async fetchCurrentQueueAttributes() {
+        let rval = null;
+        const req = {
+            AttributeNames: ['All'],
+            QueueUrl: this.awsConfig.queueUrl,
+        };
+        rval = await this.sqs.send(new GetQueueAttributesCommand(req));
+        return rval;
+    }
+    async writeMessageToSnsTopic(message) {
+        let rval = null;
+        const params = {
+            Message: message,
+            TopicArn: this.awsConfig.notificationArn,
+        };
+        Logger.debug('Writing message to SNS topic : j', params);
+        const result = await this.sns.send(new PublishCommand(params));
+        rval = result.MessageId;
+        return rval;
+    }
+    async takeEntryFromBackgroundQueue() {
+        const rval = [];
+        const params = {
+            MaxNumberOfMessages: 1,
+            QueueUrl: this.awsConfig.queueUrl,
+            VisibilityTimeout: 300,
+            WaitTimeSeconds: 0,
+        };
+        const message = await this.sqs.send(new ReceiveMessageCommand(params));
+        if (message && message.Messages && message.Messages.length > 0) {
+            for (let i = 0; i < message.Messages.length; i++) {
+                const m = message.Messages[i];
+                try {
+                    const parsedBody = JSON.parse(m.Body);
+                    if (!parsedBody.type) {
+                        Logger.warn('Dropping invalid background entry : %j', parsedBody);
+                    }
+                    else {
+                        rval.push(parsedBody);
+                    }
+                    Logger.debug('Removing message from queue');
+                    const delParams = {
+                        QueueUrl: this.awsConfig.queueUrl,
+                        ReceiptHandle: m.ReceiptHandle,
+                    };
+                    const delResult = await this.sqs.send(new DeleteMessageCommand(delParams));
+                    Logger.silly('Delete result : %j', delResult);
+                }
+                catch (err) {
+                    Logger.warn('Error parsing message, dropping : %j', m);
+                }
+            }
+        }
+        else {
+            Logger.debug('No messages found (likely end of recursion)');
+        }
+        return rval;
+    }
+}

package/dist/es/background/manager/background-manager-like.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/manager/single-thread-local-background-manager.js

@@ -0,0 +1,45 @@
+import { Subject } from 'rxjs';
+import { Logger } from '@bitblit/ratchet-common';
+import { AbstractBackgroundManager } from './abstract-background-manager';
+export class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
+    get backgroundManagerName() {
+        return 'SingleThreadLocalBackgroundManager';
+    }
+    constructor() {
+        super();
+        this._localBus = new Subject();
+    }
+    immediateProcessQueue() {
+        return this._localBus;
+    }
+    async addEntryToQueue(entry, fireStartMessage) {
+        const wrapped = this.wrapEntryForInternal(entry);
+        const rval = wrapped.guid;
+        Logger.info('Add entry to queue (local) : %j : Start : %s', entry, fireStartMessage);
+        this._localBus.next(wrapped);
+        return rval;
+    }
+    async fireImmediateProcessRequest(entry) {
+        let rval = null;
+        const wrapped = this.wrapEntryForInternal(entry);
+        rval = wrapped.guid;
+        Logger.info('Fire immediately (local) : %j ', entry);
+        this._localBus.next(wrapped);
+        return rval;
+    }
+    async fireStartProcessingRequest() {
+        let rval = null;
+        Logger.info('Fire start processing request (local, ignored)');
+        rval = 'NO-OP';
+        return rval;
+    }
+    async fetchApproximateNumberOfQueueEntries() {
+        let rval = null;
+        rval = 0;
+        return rval;
+    }
+    async takeEntryFromBackgroundQueue() {
+        Logger.info('Called takeEntryFromBackgroundQueue on SingleThreadedLocal - returning empty');
+        return [];
+    }
+}

package/dist/es/background/s3-background-transaction-logger.js

@@ -0,0 +1,49 @@
+import { S3CacheRatchet } from '@bitblit/ratchet-aws';
+import { AbstractBackgroundManager } from './manager/abstract-background-manager';
+import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
+export class S3BackgroundTransactionLogger {
+    constructor(cfg) {
+        this.cfg = cfg;
+        const err = S3BackgroundTransactionLogger.validateConfig(cfg);
+        if (err.length) {
+            ErrorRatchet.throwFormattedErr('Invalid S3BackgroundTransactionLogger config : %j', err);
+        }
+        this.s3TransactionLogCacheRatchet = new S3CacheRatchet(this.cfg.s3, this.cfg.bucket);
+    }
+    async logTransaction(txLog) {
+        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');
+        }
+    }
+    async readTransactionLog(txGuid) {
+        const path = AbstractBackgroundManager.backgroundGuidToPath(this.cfg.prefix, txGuid);
+        const log = await this.s3TransactionLogCacheRatchet.fetchCacheFileAsObject(path);
+        return log;
+    }
+    static validateConfig(cfg) {
+        const rval = [];
+        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;
+    }
+}

package/dist/es/build/ratchet-epsilon-common-info.js

@@ -0,0 +1,14 @@
+export class RatchetEpsilonCommonInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '85',
+            hash: '7b2bd151314408f02450300b0d5fb0e008d38deb',
+            branch: 'alpha-2023-03-14-1',
+            tag: 'alpha-2023-03-14-1',
+            timeBuiltISO: '2023-03-14T20:58:46-0700',
+            notes: '',
+        };
+        return val;
+    }
+}

package/dist/es/built-in/background/echo-processor.js

@@ -0,0 +1,14 @@
+import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class EchoProcessor {
+    get typeName() {
+        return EchoProcessor.TYPE_NAME;
+    }
+    async handleEvent(data, mgr) {
+        Logger.info('Echo processing : %j', data);
+        if (data && StringRatchet.trimToNull(data['error'])) {
+            ErrorRatchet.throwFormattedErr('Forced error : %s', data['error']);
+        }
+    }
+}
+EchoProcessor.TYPE_NAME = 'EpsilonEcho';