@bitblit/ratchet-epsilon-common 4.0.85-alpha

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

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundHandler = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_aws_1 = require("@bitblit/ratchet-aws");
+const epsilon_constants_1 = require("../epsilon-constants");
+const background_validator_1 = require("./background-validator");
+const background_execution_event_type_1 = require("./background-execution-event-type");
+const context_util_1 = require("../util/context-util");
+const abstract_background_manager_1 = require("./manager/abstract-background-manager");
+class BackgroundHandler {
+    constructor(cfg, mgr, modelValidator) {
+        this.cfg = cfg;
+        this.mgr = mgr;
+        this.modelValidator = modelValidator;
+        const cfgErrors = background_validator_1.BackgroundValidator.validateConfig(cfg);
+        if (cfgErrors.length > 0) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Invalid background config : %j', cfgErrors);
+        }
+        ratchet_common_1.Logger.silly('Starting Background processor, %d processors', cfg.processors.length);
+        this.validator = new background_validator_1.BackgroundValidator(cfg, modelValidator);
+        this.processors = background_validator_1.BackgroundValidator.validateAndMapProcessors(cfg.processors, modelValidator);
+        if ((mgr === null || mgr === void 0 ? void 0 : mgr.immediateProcessQueue) && mgr.immediateProcessQueue()) {
+            ratchet_common_1.Logger.info('Attaching to immediate processing queue');
+            mgr.immediateProcessQueue().subscribe(async (evt) => {
+                ratchet_common_1.Logger.debug('Processing local background entry : %j', evt);
+                const rval = await this.processSingleBackgroundEntry(evt);
+                ratchet_common_1.Logger.info('Processor returned %s', rval);
+            });
+        }
+    }
+    extractLabel(evt, context) {
+        let rval = null;
+        if (this.isBackgroundStartSnsEvent(evt)) {
+            rval = 'BG:START-EVT';
+        }
+        else if (this.isBackgroundImmediateFireEvent(evt)) {
+            const pEvt = this.parseImmediateFireBackgroundEntry(evt);
+            rval = 'BG:' + pEvt.type + ':' + pEvt.guid;
+        }
+        else {
+            rval = 'BG:UNKNOWN';
+        }
+        return rval;
+    }
+    handlesEvent(evt) {
+        return ratchet_aws_1.LambdaEventDetector.isValidSnsEvent(evt) && this.isBackgroundSNSEvent(evt);
+    }
+    isBackgroundSNSEvent(event) {
+        return this.isBackgroundStartSnsEvent(event) || this.isBackgroundImmediateFireEvent(event);
+    }
+    isBackgroundStartSnsEvent(event) {
+        let rval = false;
+        if (event) {
+            if (ratchet_aws_1.LambdaEventDetector.isSingleSnsEvent(event)) {
+                const cast = event;
+                rval = cast.Records[0].Sns.Message === epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_START_MARKER;
+            }
+        }
+        return rval;
+    }
+    isBackgroundImmediateFireEvent(event) {
+        let rval = false;
+        if (!!event) {
+            if (ratchet_aws_1.LambdaEventDetector.isSingleSnsEvent(event)) {
+                const cast = event;
+                const msg = cast.Records[0].Sns.Message;
+                if (!!ratchet_common_1.StringRatchet.trimToNull(msg)) {
+                    const parsed = JSON.parse(msg);
+                    rval = !!parsed && parsed['type'] === epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG;
+                }
+            }
+        }
+        return rval;
+    }
+    parseImmediateFireBackgroundEntry(event) {
+        let rval = null;
+        try {
+            if (!!event) {
+                if (ratchet_aws_1.LambdaEventDetector.isSingleSnsEvent(event)) {
+                    const cast = event;
+                    const msg = cast.Records[0].Sns.Message;
+                    if (!!ratchet_common_1.StringRatchet.trimToNull(msg)) {
+                        const parsed = JSON.parse(msg);
+                        if (!!parsed && parsed['type'] === epsilon_constants_1.EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG) {
+                            rval = parsed['backgroundEntry'];
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Could not parse %j as an immediate run event : %s', event, err, err);
+        }
+        return rval;
+    }
+    async processEvent(event, context) {
+        let procd = null;
+        if (!this.isBackgroundStartSnsEvent(event)) {
+            const backgroundEntry = this.parseImmediateFireBackgroundEntry(event);
+            if (!!backgroundEntry) {
+                ratchet_common_1.Logger.silly('Processing immediate fire event : %j', backgroundEntry);
+                const result = await this.processSingleBackgroundEntry(backgroundEntry);
+                procd = 1;
+            }
+            else {
+                ratchet_common_1.Logger.warn('Tried to process non-background start / immediate event : %j returning false', event);
+            }
+        }
+        else {
+            ratchet_common_1.Logger.info('Reading task from background queue');
+            procd = await this.takeAndProcessSingleBackgroundQueueEntry();
+            if (procd > 0) {
+                ratchet_common_1.Logger.info('Processed %d elements from background queue, refiring', procd);
+                const refire = await this.mgr.fireStartProcessingRequest();
+                ratchet_common_1.Logger.info('Refire returned %s', refire);
+            }
+            else {
+                ratchet_common_1.Logger.info('No items processed - stopping');
+            }
+        }
+        const rval = {
+            statusCode: 200,
+            body: ratchet_common_1.StringRatchet.safeString(procd),
+            isBase64Encoded: false,
+        };
+        return rval;
+    }
+    async takeAndProcessSingleBackgroundQueueEntry() {
+        let rval = null;
+        const entries = await this.mgr.takeEntryFromBackgroundQueue();
+        ratchet_common_1.Logger.info('Found %d entries - processing', entries.length);
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            const result = await this.processSingleBackgroundEntry(e);
+            rval += result ? 1 : 0;
+        }
+        ratchet_common_1.Logger.debug('Returning %d', rval);
+        return rval;
+    }
+    async safeWriteToLogger(entry) {
+        if (this.cfg.transactionLogger) {
+            try {
+                await this.cfg.transactionLogger.logTransaction(entry);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Failed to write to transaction logger : %j : %s', entry, err, err);
+            }
+        }
+        else {
+            ratchet_common_1.Logger.silly('Skipping - no logger defined');
+        }
+    }
+    async conditionallyStartTransactionLog(e) {
+        if (!ratchet_common_1.StringRatchet.trimToNull(e.guid)) {
+            ratchet_common_1.Logger.warn('No guid found - creating');
+            e.guid = abstract_background_manager_1.AbstractBackgroundManager.generateBackgroundGuid();
+            const log = {
+                request: e,
+                running: true,
+            };
+            await this.safeWriteToLogger(log);
+        }
+        ratchet_common_1.Logger.debug('Starting transaction log');
+    }
+    async conditionallyCompleteTransactionLog(e, result, error, runtimeMS) {
+        ratchet_common_1.Logger.debug('Completing transaction log');
+        const log = {
+            request: e,
+            result: result,
+            error: error ? ratchet_common_1.ErrorRatchet.safeStringifyErr(error) : null,
+            running: false,
+            runtimeMS: runtimeMS,
+        };
+        await this.safeWriteToLogger(log);
+    }
+    async conditionallyRunErrorProcessor(e, error) {
+        try {
+            if (this.cfg.errorProcessor) {
+                ratchet_common_1.Logger.info('Running error processor');
+                await this.cfg.errorProcessor.handleError(e, error);
+            }
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Background : BAD - Failed to run error processor : %s', err, err);
+        }
+    }
+    async fireListenerEvent(event) {
+        const listeners = this.cfg.executionListeners || [];
+        for (const listener of listeners) {
+            try {
+                await listener.onEvent(event);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Failure triggering handler %s : %s', ratchet_common_1.StringRatchet.trimToNull(listener === null || listener === void 0 ? void 0 : listener.label) || 'No-name', err);
+            }
+        }
+    }
+    async processSingleBackgroundEntry(e) {
+        context_util_1.ContextUtil.setOverrideTraceFromInternalBackgroundEntry(e);
+        ratchet_common_1.Logger.info('Background Process Start: %j', e);
+        const sw = new ratchet_common_1.StopWatch();
+        await this.conditionallyStartTransactionLog(e);
+        let rval = false;
+        try {
+            await this.fireListenerEvent({
+                type: background_execution_event_type_1.BackgroundExecutionEventType.ProcessStarting,
+                processorType: e.type,
+                data: e.data,
+                guid: e.guid,
+            });
+            const processorInput = this.processors.get(e.type);
+            if (!processorInput) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Found no processor for background entry : %j (returning false)', e);
+                await this.fireListenerEvent({
+                    type: background_execution_event_type_1.BackgroundExecutionEventType.NoMatchProcessorName,
+                    processorType: e.type,
+                    data: e.data,
+                    guid: e.guid,
+                });
+            }
+            let dataValidationErrors = [];
+            if (ratchet_common_1.StringRatchet.trimToNull(processorInput.dataSchemaName)) {
+                dataValidationErrors = this.modelValidator.validate(processorInput.dataSchemaName, e.data, false, false);
+            }
+            if (dataValidationErrors.length > 0) {
+                await this.fireListenerEvent({
+                    type: background_execution_event_type_1.BackgroundExecutionEventType.DataValidationError,
+                    processorType: e.type,
+                    data: e.data,
+                    errors: dataValidationErrors,
+                    guid: e.guid,
+                });
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Not processing, data failed validation; entry was %j : errors : %j', e, dataValidationErrors);
+            }
+            else {
+                let result = await processorInput.handleEvent(e.data, this.mgr);
+                result = result || 'SUCCESSFUL COMPLETION : NO RESULT RETURNED';
+                await this.conditionallyCompleteTransactionLog(e, result, null, sw.elapsedMS());
+                await this.fireListenerEvent({
+                    type: background_execution_event_type_1.BackgroundExecutionEventType.ExecutionSuccessfullyComplete,
+                    processorType: e.type,
+                    data: result,
+                    guid: e.guid,
+                });
+                rval = true;
+            }
+        }
+        catch (err) {
+            ratchet_common_1.Logger.error('Background Process Error: %j : %s', e, err, err);
+            await this.conditionallyRunErrorProcessor(e, err);
+            await this.conditionallyCompleteTransactionLog(e, null, err, sw.elapsedMS());
+            await this.fireListenerEvent({
+                type: background_execution_event_type_1.BackgroundExecutionEventType.ExecutionFailedError,
+                processorType: e.type,
+                data: e.data,
+                errors: [ratchet_common_1.ErrorRatchet.safeStringifyErr(err)],
+                guid: e.guid,
+            });
+        }
+        ratchet_common_1.Logger.info('Background Process Stop: %j : %s', e, sw.dump());
+        return rval;
+    }
+    getConfig() {
+        const rval = Object.assign({}, this.cfg);
+        return rval;
+    }
+}
+exports.BackgroundHandler = BackgroundHandler;

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

@@ -0,0 +1,127 @@
+"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

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

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

@@ -0,0 +1,8 @@
+"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

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

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

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

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

@@ -0,0 +1,88 @@
+"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

@@ -0,0 +1,93 @@
+"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

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