@bitblit/ratchet-epsilon-common 4.0.115-alpha → 4.0.119-alpha

package/lib/background/epsilon-background-process-error.js

@@ -1,93 +0,0 @@
-import util from 'util';
-export class EpsilonBackgroundProcessError extends Error {
-    static EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY = '__epsilonBackgroundProcessErrorFlag';
-    _errors;
-    _detailErrorCode;
-    _details;
-    _requestId;
-    _wrappedError;
-    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;
-    }
-}

package/lib/background/internal-background-entry.js

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

package/lib/background/manager/abstract-background-manager.js

@@ -1,89 +0,0 @@
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { DateTime } from 'luxon';
-import { ContextUtil } from '../../util/context-util.js';
-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/lib/background/manager/aws-sqs-sns-background-manager.js

@@ -1,153 +0,0 @@
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
-import { DeleteMessageCommand, GetQueueAttributesCommand, ReceiveMessageCommand, SendMessageCommand, } from '@aws-sdk/client-sqs';
-import { EpsilonConstants } from '../../epsilon-constants.js';
-import { AbstractBackgroundManager } from './abstract-background-manager.js';
-import { BackgroundValidator } from '../background-validator.js';
-import { PublishCommand } from '@aws-sdk/client-sns';
-export class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
-    _awsConfig;
-    _sqs;
-    _sns;
-    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/lib/background/manager/background-manager-like.js

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

package/lib/background/manager/background-manager.spec.js

@@ -1,73 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { GetQueueAttributesCommand, SQSClient } from '@aws-sdk/client-sqs';
-import { ModelValidator } from '@bitblit/ratchet-misc/lib/model-validator/model-validator.js';
-import { AwsSqsSnsBackgroundManager } from './aws-sqs-sns-background-manager.js';
-import { EchoProcessor } from '../../built-in/background/echo-processor.js';
-import { NoOpProcessor } from '../../built-in/background/no-op-processor.js';
-import { SNSClient } from '@aws-sdk/client-sns';
-import { mockClient } from 'aws-sdk-client-mock';
-let mockSqs;
-let mockSns;
-describe('#createEntry', function () {
-    mockSns = mockClient(SNSClient);
-    mockSqs = mockClient(SQSClient);
-    let backgroundMgr;
-    const fakeAccountNumber = '123456789012';
-    let backgroundConfig;
-    let backgroundAwsConfig;
-    const fakeModelValidator = new ModelValidator({ BackgroundBuiltInSampleInputValidatedProcessor: {} });
-    const echoProcessor = new EchoProcessor();
-    const 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);
-    });
-    it('Should return queue attributes', async () => {
-        mockSqs.on(GetQueueAttributesCommand).resolves({
-            Attributes: {
-                ApproximateNumberOfMessages: 1,
-            },
-        });
-        const queueAttr = await backgroundMgr.fetchCurrentQueueAttributes();
-        const msgCount = await backgroundMgr.fetchApproximateNumberOfQueueEntries();
-        Logger.info('Got : %j', queueAttr);
-        Logger.info('Msg: %d', msgCount);
-        expect(queueAttr).toBeTruthy();
-        expect(msgCount).toEqual(1);
-    });
-    it('Should round-trip guids with prefix no slash', async () => {
-        const prefix = 'test';
-        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
-        expect(guid).toBeTruthy();
-        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
-        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
-        expect(outGuid).toEqual(guid);
-    });
-    it('Should round-trip guids with prefix with slash', async () => {
-        const prefix = 'test/';
-        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
-        expect(guid).toBeTruthy();
-        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
-        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
-        expect(outGuid).toEqual(guid);
-    });
-    it('Should round-trip guids with no prefix', async () => {
-        const prefix = null;
-        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
-        expect(guid).toBeTruthy();
-        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
-        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
-        expect(outGuid).toEqual(guid);
-    });
-});

package/lib/background/manager/single-thread-local-background-manager.js

@@ -1,45 +0,0 @@
-import { Subject } from 'rxjs';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AbstractBackgroundManager } from './abstract-background-manager.js';
-export class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
-    _localBus = new Subject();
-    get backgroundManagerName() {
-        return 'SingleThreadLocalBackgroundManager';
-    }
-    constructor() {
-        super();
-    }
-    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/lib/background/s3-background-transaction-logger.js

@@ -1,52 +0,0 @@
-import { S3CacheRatchet } from '@bitblit/ratchet-aws/lib/s3/s3-cache-ratchet.js';
-import { AbstractBackgroundManager } from './manager/abstract-background-manager.js';
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-export class S3BackgroundTransactionLogger {
-    cfg;
-    s3TransactionLogCacheRatchet;
-    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/lib/build/ratchet-epsilon-common-info.js

@@ -1,14 +0,0 @@
-export class RatchetEpsilonCommonInfo {
-    constructor() { }
-    static buildInformation() {
-        const val = {
-            version: 'LOCAL-SNAPSHOT',
-            hash: 'LOCAL-HASH',
-            branch: 'LOCAL-BRANCH',
-            tag: 'LOCAL-TAG',
-            timeBuiltISO: 'LOCAL-TIME-ISO',
-            notes: 'LOCAL-NOTES',
-        };
-        return val;
-    }
-}

package/lib/built-in/background/echo-processor.js

@@ -1,15 +0,0 @@
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-export class EchoProcessor {
-    static TYPE_NAME = 'EpsilonEcho';
-    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']);
-        }
-    }
-}

package/lib/built-in/background/log-and-enqueue-echo-processor.js

@@ -1,12 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { EchoProcessor } from './echo-processor.js';
-export class LogAndEnqueueEchoProcessor {
-    get typeName() {
-        return 'EpsilonLogAndEnqueueEcho';
-    }
-    async handleEvent(data, cfg) {
-        Logger.info('LogAndEnqueueEchoProcessor : %j', data);
-        await cfg.fireImmediateProcessRequestByParts(EchoProcessor.TYPE_NAME, { upstream: data });
-        Logger.info('Completed : LogAndEnqueueEchoProcessor');
-    }
-}

package/lib/built-in/background/log-message-background-error-processor.js

@@ -1,6 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-export class LogMessageBackgroundErrorProcessor {
-    async handleError(submission, error) {
-        Logger.error('-------- ERROR PROCESSED : %j : %s----', submission, error);
-    }
-}

package/lib/built-in/background/no-op-processor.js

@@ -1,9 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-export class NoOpProcessor {
-    get typeName() {
-        return 'EpsilonNoOp';
-    }
-    async handleEvent(data, mgr) {
-        Logger.silly('Hit the no-op proc');
-    }
-}

package/lib/built-in/background/retry-processor.js

@@ -1,40 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { DurationRatchet } from '@bitblit/ratchet-common/lib/lang/duration-ratchet.js';
-import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-export class RetryProcessor {
-    delegate;
-    opts;
-    static RETRY_FIELD_NAME = '___RetryProcessorTryNumber';
-    constructor(delegate, opts) {
-        this.delegate = delegate;
-        this.opts = opts;
-    }
-    get typeName() {
-        return StringRatchet.trimToEmpty(this.opts?.typePrefix) + this.delegate.typeName + StringRatchet.trimToEmpty(this.opts?.typeSuffix);
-    }
-    async handleEvent(data, mgr) {
-        const tryNumber = data && data[RetryProcessor.RETRY_FIELD_NAME] ? NumberRatchet.safeNumber(data[RetryProcessor.RETRY_FIELD_NAME]) : 1;
-        const dataCopy = data ? Object.assign({}, data) : null;
-        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 = tryNumber * this.opts.baseDelayMS;
-                Logger.info('Firing automatic retry after a wait of %s', DurationRatchet.formatMsDuration(waitTimeMS));
-                await PromiseRatchet.wait(waitTimeMS);
-                const wrapped = dataCopy || {};
-                wrapped[RetryProcessor.RETRY_FIELD_NAME] = tryNumber + 1;
-                await mgr.fireImmediateProcessRequestByParts(this.typeName, wrapped);
-            }
-            else {
-                Logger.error('That was the last try - giving up');
-            }
-        }
-    }
-}

package/lib/built-in/background/sample-delay-processor.js

@@ -1,13 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-export class SampleDelayProcessor {
-    get typeName() {
-        return 'EpsilonSampleDelay';
-    }
-    async handleEvent(data, mgr) {
-        const delayMS = Math.floor(Math.random() * 5000);
-        Logger.info('Running sample processor for %d', delayMS);
-        await PromiseRatchet.wait(delayMS);
-        Logger.info('Sample processor complete');
-    }
-}

package/lib/built-in/background/sample-input-validated-processor-data.js

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

package/lib/built-in/background/sample-input-validated-processor.js

@@ -1,12 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-export class SampleInputValidatedProcessor {
-    get typeName() {
-        return 'EpsilonSampleInputValidated';
-    }
-    async handleEvent(data, mgr) {
-        Logger.info('Running SampleInputValidatedProcessor, data was : %j', data);
-    }
-    get dataSchemaName() {
-        return 'BackgroundSampleInputValidatedProcessorData';
-    }
-}

package/lib/built-in/built-in-trace-id-generators.js

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