@bitblit/ratchet-epsilon-common 4.0.99-alpha → 4.0.102-alpha

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

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundHttpAdapterHandler = void 0;
-const ratchet_common_1 = require("@bitblit/ratchet-common");
-const ratchet_common_2 = require("@bitblit/ratchet-common");
-const background_process_handling_1 = require("./background-process-handling");
-const ratchet_common_3 = require("@bitblit/ratchet-common");
-const bad_request_error_1 = require("../http/error/bad-request-error");
-const not_found_error_1 = require("../http/error/not-found-error");
-const ratchet_common_4 = require("@bitblit/ratchet-common");
-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) {
-        ratchet_common_1.Logger.info('handleBackgroundStatusRequest called');
-        if (!this.backgroundConfig.transactionLogger) {
-            throw new bad_request_error_1.BadRequestError('Process logging not enabled');
-        }
-        else {
-            const guid = ratchet_common_3.StringRatchet.trimToNull(evt.pathParameters['guid']) || ratchet_common_3.StringRatchet.trimToNull(evt.queryStringParameters['guid']);
-            if (guid) {
-                const sw = new ratchet_common_1.StopWatch();
-                let log = null;
-                while (!log && sw.elapsedMS() < this.maxWaitInMsForBackgroundJobToStart) {
-                    log = await this.backgroundConfig.transactionLogger.readTransactionLog(guid);
-                    if (!log) {
-                        ratchet_common_1.Logger.debug('No log found yet, waiting 500 ms and retrying (%s of %d waited so far)', sw.dump(), this.maxWaitInMsForBackgroundJobToStart);
-                        await ratchet_common_4.PromiseRatchet.wait(500);
-                    }
-                }
-                if (!log) {
-                    throw new not_found_error_1.NotFoundError().withFormattedErrorMessage('No background result found for guid %s', guid);
-                }
-                return log;
-            }
-            else {
-                throw new bad_request_error_1.BadRequestError('No guid specified');
-            }
-        }
-    }
-    async handleBackgroundMetaRequest(evt, context) {
-        ratchet_common_1.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) {
-        ratchet_common_1.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 (ratchet_common_3.StringRatchet.trimToNull(pathSuppliedBackgroundType)) {
-            if (ratchet_common_3.StringRatchet.trimToNull(entry === null || entry === void 0 ? void 0 : entry.type) && entry.type.toLocaleLowerCase() !== pathSuppliedBackgroundType.toLocaleLowerCase()) {
-                throw new bad_request_error_1.BadRequestError('Background submission has type but does not match path supplied type');
-            }
-            else {
-                entry.type = pathSuppliedBackgroundType;
-            }
-        }
-        else {
-            if (!ratchet_common_3.StringRatchet.trimToNull(entry === null || entry === void 0 ? void 0 : entry.type)) {
-                throw new bad_request_error_1.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 = ratchet_common_2.BooleanRatchet.parseBool(evt.queryStringParameters['immediate']);
-        const startProcessor = ratchet_common_2.BooleanRatchet.parseBool(evt.queryStringParameters['startProcessor']);
-        if (foundProc) {
-            if (ratchet_common_3.StringRatchet.trimToNull(foundProc.dataSchemaName)) {
-                const errors = this.modelValidator.validate(foundProc.dataSchemaName, entry.data, false, false);
-                if (errors.length > 0) {
-                    throw new bad_request_error_1.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 ? background_process_handling_1.BackgroundProcessHandling.Immediate : background_process_handling_1.BackgroundProcessHandling.Queued,
-                startProcessorRequested: startProcessor,
-                success: true,
-                resultId: result,
-                error: null,
-            };
-        }
-        else {
-            throw new bad_request_error_1.BadRequestError().withFormattedErrorMessage('Could not find target background processor : %s', entry.type);
-        }
-        return rval;
-    }
-}
-exports.BackgroundHttpAdapterHandler = BackgroundHttpAdapterHandler;

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundProcessHandling = void 0;
-var BackgroundProcessHandling;
-(function (BackgroundProcessHandling) {
-    BackgroundProcessHandling["Queued"] = "Queued";
-    BackgroundProcessHandling["Immediate"] = "Immediate";
-})(BackgroundProcessHandling = exports.BackgroundProcessHandling || (exports.BackgroundProcessHandling = {}));

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundValidator = void 0;
-const ratchet_common_1 = require("@bitblit/ratchet-common");
-const ratchet_common_2 = require("@bitblit/ratchet-common");
-const ratchet_common_3 = require("@bitblit/ratchet-common");
-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 (!ratchet_common_3.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) {
-            ratchet_common_1.Logger.warn('Invalid entry %j : errors : %j', entry, errors);
-            ratchet_common_2.ErrorRatchet.throwFormattedErr('Invalid entry %j : errors : %j', entry, errors);
-        }
-    }
-    static validateAndMapProcessors(processorInput, modelValidator) {
-        const rval = new Map();
-        processorInput.forEach((p, idx) => {
-            if (!p) {
-                ratchet_common_2.ErrorRatchet.throwFormattedErr('Null processor provided at index %d', idx);
-            }
-            if (!ratchet_common_3.StringRatchet.trimToNull(p.typeName)) {
-                ratchet_common_2.ErrorRatchet.throwFormattedErr('Processor at index %d defines no name', idx);
-            }
-            if (rval.has(p.typeName)) {
-                ratchet_common_2.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;
-    }
-}
-exports.BackgroundValidator = BackgroundValidator;

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

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EpsilonBackgroundProcessError = void 0;
-const tslib_1 = require("tslib");
-const util_1 = tslib_1.__importDefault(require("util"));
-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_1.default.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;
-    }
-}
-exports.EpsilonBackgroundProcessError = EpsilonBackgroundProcessError;
-EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY = '__epsilonBackgroundProcessErrorFlag';

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractBackgroundManager = void 0;
-const ratchet_common_1 = require("@bitblit/ratchet-common");
-const ratchet_common_2 = require("@bitblit/ratchet-common");
-const luxon_1 = require("luxon");
-const ratchet_common_3 = require("@bitblit/ratchet-common");
-const context_util_1 = require("../../util/context-util");
-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 || context_util_1.ContextUtil.currentTraceId(),
-            traceDepth: overrideTraceDepth || context_util_1.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) {
-                ratchet_common_1.Logger.error('Error processing %j : %s', entries[i], err);
-                rval.push(err['message']);
-            }
-            if (fireStartMessage) {
-                const fireResult = await this.fireStartProcessingRequest();
-                ratchet_common_1.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 = luxon_1.DateTime.fromMillis(targetEpochMS);
-        return dt.toFormat('yyyy-MM-dd-HH-mm-ss-') + ratchet_common_2.StringRatchet.createType4Guid();
-    }
-    static backgroundGuidToPath(prefix, guid) {
-        let path = ratchet_common_2.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) {
-        ratchet_common_3.RequireRatchet.notNullOrUndefined(path, 'path');
-        let start = 0;
-        if (!path.endsWith('.json')) {
-            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot extract guid, does not end with .json : %s : %s', path, prefix);
-        }
-        if (ratchet_common_2.StringRatchet.trimToNull(prefix)) {
-            if (!path.startsWith(prefix)) {
-                ratchet_common_1.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);
-    }
-}
-exports.AbstractBackgroundManager = AbstractBackgroundManager;

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

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AwsSqsSnsBackgroundManager = void 0;
-const ratchet_common_1 = require("@bitblit/ratchet-common");
-const client_sqs_1 = require("@aws-sdk/client-sqs");
-const epsilon_constants_1 = require("../../epsilon-constants");
-const abstract_background_manager_1 = require("./abstract-background-manager");
-const background_validator_1 = require("../background-validator");
-const ratchet_common_2 = require("@bitblit/ratchet-common");
-const client_sns_1 = require("@aws-sdk/client-sns");
-class AwsSqsSnsBackgroundManager extends abstract_background_manager_1.AbstractBackgroundManager {
-    constructor(_awsConfig, _sqs, _sns) {
-        super();
-        this._awsConfig = _awsConfig;
-        this._sqs = _sqs;
-        this._sns = _sns;
-        const cfgErrors = background_validator_1.BackgroundValidator.validateAwsConfig(_awsConfig);
-        if (cfgErrors.length) {
-            ratchet_common_2.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,
-            };
-            ratchet_common_1.Logger.info('Add entry to queue (remote) : %j : Start : %s', params, fireStartMessage);
-            const result = await this.sqs.send(new client_sqs_1.SendMessageCommand(params));
-            if (fireStartMessage) {
-                const fireResult = await this.fireStartProcessingRequest();
-                ratchet_common_1.Logger.silly('FireResult : %s', fireResult);
-            }
-            ratchet_common_1.Logger.info('Background process %s using message id %s', rval, result.MessageId);
-            return rval;
-        }
-        catch (error) {
-            ratchet_common_1.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 {
-            ratchet_common_1.Logger.info('Fire immediately (remote) : %j ', entry);
-            const toWrite = {
-                type: epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG,
-                backgroundEntry: wrapped,
-            };
-            const msg = JSON.stringify(toWrite);
-            const snsId = await this.writeMessageToSnsTopic(msg);
-            ratchet_common_1.Logger.debug('Background guid %s Wrote message : %s to SNS : %s', rval, msg, snsId);
-        }
-        catch (err) {
-            ratchet_common_1.Logger.error('Failed to fireImmediateProcessRequest : %s', err, err);
-        }
-        return rval;
-    }
-    async fireStartProcessingRequest() {
-        let rval = null;
-        try {
-            ratchet_common_1.Logger.info('Fire start processing request (remote)');
-            rval = await this.writeMessageToSnsTopic(epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_START_MARKER);
-        }
-        catch (err) {
-            ratchet_common_1.Logger.error('Failed to fireStartProcessingRequest : %s', err, err);
-        }
-        return rval;
-    }
-    async fetchApproximateNumberOfQueueEntries() {
-        let rval = null;
-        const all = await this.fetchCurrentQueueAttributes();
-        rval = ratchet_common_1.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 client_sqs_1.GetQueueAttributesCommand(req));
-        return rval;
-    }
-    async writeMessageToSnsTopic(message) {
-        let rval = null;
-        const params = {
-            Message: message,
-            TopicArn: this.awsConfig.notificationArn,
-        };
-        ratchet_common_1.Logger.debug('Writing message to SNS topic : j', params);
-        const result = await this.sns.send(new client_sns_1.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 client_sqs_1.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) {
-                        ratchet_common_1.Logger.warn('Dropping invalid background entry : %j', parsedBody);
-                    }
-                    else {
-                        rval.push(parsedBody);
-                    }
-                    ratchet_common_1.Logger.debug('Removing message from queue');
-                    const delParams = {
-                        QueueUrl: this.awsConfig.queueUrl,
-                        ReceiptHandle: m.ReceiptHandle,
-                    };
-                    const delResult = await this.sqs.send(new client_sqs_1.DeleteMessageCommand(delParams));
-                    ratchet_common_1.Logger.silly('Delete result : %j', delResult);
-                }
-                catch (err) {
-                    ratchet_common_1.Logger.warn('Error parsing message, dropping : %j', m);
-                }
-            }
-        }
-        else {
-            ratchet_common_1.Logger.debug('No messages found (likely end of recursion)');
-        }
-        return rval;
-    }
-}
-exports.AwsSqsSnsBackgroundManager = AwsSqsSnsBackgroundManager;

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleThreadLocalBackgroundManager = void 0;
-const rxjs_1 = require("rxjs");
-const ratchet_common_1 = require("@bitblit/ratchet-common");
-const abstract_background_manager_1 = require("./abstract-background-manager");
-class SingleThreadLocalBackgroundManager extends abstract_background_manager_1.AbstractBackgroundManager {
-    constructor() {
-        super();
-        this._localBus = new rxjs_1.Subject();
-    }
-    get backgroundManagerName() {
-        return 'SingleThreadLocalBackgroundManager';
-    }
-    immediateProcessQueue() {
-        return this._localBus;
-    }
-    async addEntryToQueue(entry, fireStartMessage) {
-        const wrapped = this.wrapEntryForInternal(entry);
-        const rval = wrapped.guid;
-        ratchet_common_1.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;
-        ratchet_common_1.Logger.info('Fire immediately (local) : %j ', entry);
-        this._localBus.next(wrapped);
-        return rval;
-    }
-    async fireStartProcessingRequest() {
-        let rval = null;
-        ratchet_common_1.Logger.info('Fire start processing request (local, ignored)');
-        rval = 'NO-OP';
-        return rval;
-    }
-    async fetchApproximateNumberOfQueueEntries() {
-        let rval = null;
-        rval = 0;
-        return rval;
-    }
-    async takeEntryFromBackgroundQueue() {
-        ratchet_common_1.Logger.info('Called takeEntryFromBackgroundQueue on SingleThreadedLocal - returning empty');
-        return [];
-    }
-}
-exports.SingleThreadLocalBackgroundManager = SingleThreadLocalBackgroundManager;