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

package/{dist/es → lib}/util/cron-util.js

@@ -1,7 +1,7 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
 import { DateTime } from 'luxon';
-import { StringRatchet } from '@bitblit/ratchet-common';
 export class CronUtil {
     static everyNMinuteFilter(n) {
         return CronUtil.everyNElementFilter(n, 60);

package/lib/util/cron-util.spec.d.ts

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

package/lib/util/cron-util.spec.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import path from 'path';
+import { CronUtil } from './cron-util.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/lib/lang/esm-ratchet.js';
+describe('#cronUtil', function () {
+    it('should test matching event to entry', async () => {
+        const sEvent = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'))
+            .toString());
+        const cfg = {
+            context: 'prod',
+            timezone: 'America/Los_Angeles',
+            entries: [],
+        };
+        const cron1 = {
+            contextMatchFilter: new RegExp('prod'),
+        };
+        const match1 = CronUtil.eventMatchesEntry(sEvent, cron1, cfg);
+        expect(match1).toBeTruthy();
+        const cron2 = {
+            contextMatchFilter: new RegExp('dev'),
+        };
+        const match2 = CronUtil.eventMatchesEntry(sEvent, cron2, cfg);
+        expect(match2).toBeFalsy();
+        const cron3 = {
+            eventFilter: new RegExp('.*MyScheduledRule.*'),
+        };
+        const match3 = CronUtil.eventMatchesEntry(sEvent, cron3, cfg);
+        expect(match3).toBeTruthy();
+        const cron4 = {
+            eventFilter: new RegExp('.*NotMyRule.*'),
+        };
+        const match4 = CronUtil.eventMatchesEntry(sEvent, cron4, cfg);
+        expect(match4).toBeFalsy();
+    });
+    it('should match times', async () => {
+        const sEvent = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'))
+            .toString());
+        const cfg = {
+            context: 'prod',
+            timezone: 'America/Los_Angeles',
+            entries: [],
+        };
+        const entry1 = {};
+        const cron1 = {
+            contextMatchFilter: new RegExp('prod'),
+        };
+        const match1 = CronUtil.eventMatchesEntry(sEvent, cron1, cfg);
+        expect(match1).toBeTruthy();
+        const cron2 = {
+            contextMatchFilter: new RegExp('dev'),
+        };
+        const match2 = CronUtil.eventMatchesEntry(sEvent, cron2, cfg);
+        expect(match2).toBeFalsy();
+        const cron3 = {
+            eventFilter: new RegExp('.*MyScheduledRule.*'),
+        };
+        const match3 = CronUtil.eventMatchesEntry(sEvent, cron3, cfg);
+        expect(match3).toBeTruthy();
+        const cron4 = {
+            eventFilter: new RegExp('.*NotMyRule.*'),
+        };
+        const match4 = CronUtil.eventMatchesEntry(sEvent, cron4, cfg);
+        expect(match4).toBeFalsy();
+    });
+    it('should match time with override', async () => {
+        const sEvent = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'))
+            .toString());
+        const cfg = {
+            context: 'prod',
+            timezone: 'America/Los_Angeles',
+            entries: [],
+        };
+        const entry1 = {};
+        const cron1 = {
+            hourFilter: [3],
+        };
+        const cron2 = {
+            overrideTimezone: 'etc/utc',
+            hourFilter: [3],
+        };
+        const testTimestampEpochMS = 1652931000000;
+        const match1 = CronUtil.eventMatchesEntry(sEvent, cron1, cfg, testTimestampEpochMS);
+        const match2 = CronUtil.eventMatchesEntry(sEvent, cron2, cfg, testTimestampEpochMS);
+        expect(match1).toBeFalsy();
+        expect(match2).toBeTruthy();
+    });
+    it('should match day of month filters', async () => {
+        const sEvent = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'))
+            .toString());
+        const cfg = {
+            context: 'prod',
+            timezone: 'etc/utc',
+            entries: [],
+        };
+        const entry1 = {};
+        const testTimestampEpochMS = 1652931000000;
+        const dayOfMonth = {
+            dayOfMonthFilter: [19],
+        };
+        const matchDay = CronUtil.eventMatchesEntry(sEvent, dayOfMonth, cfg, testTimestampEpochMS);
+        expect(matchDay).toBeTruthy();
+    });
+    it('should match month of year filter', async () => {
+        const sEvent = JSON.parse(fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'))
+            .toString());
+        const cfg = {
+            context: 'prod',
+            timezone: 'etc/utc',
+            entries: [],
+        };
+        const entry1 = {};
+        const testTimestampEpochMS = 1652931000000;
+        const monthOfYear = {
+            monthOfYearFilter: [5],
+        };
+        const matchMonth = CronUtil.eventMatchesEntry(sEvent, monthOfYear, cfg, testTimestampEpochMS);
+        expect(matchMonth).toBeTruthy();
+    });
+});

package/{dist/types → lib}/util/epsilon-config-parser.d.ts

@@ -1,9 +1,9 @@
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { OpenApiDocument } from '../config/open-api/open-api-document';
-import { EpsilonConfig } from '../config/epsilon-config';
-import { EpsilonInstance } from '../epsilon-instance';
-import { EpsilonGlobalHandler } from '../epsilon-global-handler';
-import { BackgroundManagerLike } from '../background/manager/background-manager-like';
+import { ModelValidator } from '@bitblit/ratchet-misc/lib/model-validator/model-validator.js';
+import { OpenApiDocument } from '../config/open-api/open-api-document.js';
+import { EpsilonConfig } from '../config/epsilon-config.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
 export declare class EpsilonConfigParser {
     constructor();
     static epsilonConfigToEpsilonGlobalHandler(config: EpsilonConfig, backgroundManager?: BackgroundManagerLike): EpsilonGlobalHandler;

package/{dist/es → lib}/util/epsilon-config-parser.js

@@ -1,13 +1,13 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
 import yaml from 'js-yaml';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundHttpAdapterHandler } from '../background/background-http-adapter-handler';
-import { BackgroundHandler } from '../background/background-handler';
-import { RouterUtil } from '../http/route/router-util';
-import { WebHandler } from '../http/web-handler';
-import { MisconfiguredError } from '../http/error/misconfigured-error';
-import { EpsilonGlobalHandler } from '../epsilon-global-handler';
+import { ModelValidator } from '@bitblit/ratchet-misc/lib/model-validator/model-validator.js';
+import { BackgroundHttpAdapterHandler } from '../background/background-http-adapter-handler.js';
+import { BackgroundHandler } from '../background/background-handler.js';
+import { RouterUtil } from '../http/route/router-util.js';
+import { WebHandler } from '../http/web-handler.js';
+import { MisconfiguredError } from '../http/error/misconfigured-error.js';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
 export class EpsilonConfigParser {
     constructor() { }
     static epsilonConfigToEpsilonGlobalHandler(config, backgroundManager) {

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@bitblit/ratchet-epsilon-common",
-  "version": "4.0.99-alpha",
+  "version": "4.0.103-alpha",
   "description": "Tiny adapter to simplify building API gateway Lambda APIS",
   "sideEffects": false,
   "bin": {
-    "epsilon-cli": "./includes/cli.js"
+    "epsilon-cli": "./bin/cli.js"
   },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "module": "index.js",
   "files": [
-    "dist/*",
-    "includes/*"
+    "lib/*",
+    "bin/*"
   ],
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
@@ -32,20 +31,18 @@
   "config": {},
   "scripts": {
     "watch": "tsc-watch",
-    "clean": "shx rm -Rf dist",
-    "test": "jest",
+    "clean": "shx rm -Rf lib",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
     "lint": "eslint src/**/*.ts",
     "lint-fix": "eslint --fix src/**/*.ts",
-    "generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
-    "build": "yarn run generate-barrels && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:es": "tsc -p tsconfig.es.json",
-    "build:types": "tsc -p tsconfig.types.json",
-    "run-local-container-server": "yarn build:cjs && node includes/cli.js run-local-container-server",
-    "run-sample-server": "yarn build:cjs && node includes/cli.js run-sample-local-server",
-    "run-test-error-server": "yarn build:cjs && node includes/cli.js run-test-error-server",
-    "run-batch-sample-server": "yarn build:cjs && node includes/cli.js run-sample-local-batch-server",
-    "run-background-process-from-command-line-dry-run": "yarn build:cjs && node includes/cli.js run-background-process"
+    "__generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
+    "__build": "yarn run generate-barrels && tsc",
+    "build": "tsc",
+    "run-local-container-server": "yarn build && node bin/cli.js run-local-container-server",
+    "run-sample-server": "yarn build && node bin/cli.js run-sample-local-server",
+    "run-test-error-server": "yarn build && node bin/cli.js run-test-error-server",
+    "run-batch-sample-server": "yarn build && node bin/cli.js run-sample-local-batch-server",
+    "run-background-process-from-command-line-dry-run": "yarn build && node bin/cli.js run-background-process"
   },
   "repository": {
     "type": "git",

package/dist/cjs/background/background-dynamo-log-table-handler.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundDynamoLogTableHandler = void 0;
-const background_execution_event_type_1 = require("./background-execution-event-type");
-const context_util_1 = require("../util/context-util");
-class BackgroundDynamoLogTableHandler {
-    constructor(dynamo, tableName, env, backgroundQueueName) {
-        this.dynamo = dynamo;
-        this.tableName = tableName;
-        this.env = env;
-        this.backgroundQueueName = backgroundQueueName;
-    }
-    async onEvent(event) {
-        var _a, _b;
-        const entry = {
-            env: this.env,
-            backgroundQueueName: this.backgroundQueueName,
-            requestId: context_util_1.ContextUtil.currentRequestId(),
-            guid: event.guid,
-            processTypeName: event.processorType,
-            state: event.type.toString(),
-            timestampEpochMs: new Date().getTime(),
-        };
-        if (event.type == background_execution_event_type_1.BackgroundExecutionEventType.DataValidationError) {
-            const errors = ((_a = event === null || event === void 0 ? void 0 : event.errors) === null || _a === void 0 ? void 0 : _a.length) ? event.errors : ['No-Error'];
-            entry.errors = errors;
-        }
-        else if (event.type == background_execution_event_type_1.BackgroundExecutionEventType.ProcessStarting) {
-            entry.params = event.data;
-        }
-        else if (event.type == background_execution_event_type_1.BackgroundExecutionEventType.ExecutionFailedError) {
-            const errors = ((_b = event === null || event === void 0 ? void 0 : event.errors) === null || _b === void 0 ? void 0 : _b.length) ? event.errors : ['No-Error'];
-            entry.errors = errors;
-        }
-        await this.dynamo.simplePut(this.tableName, entry);
-    }
-}
-exports.BackgroundDynamoLogTableHandler = BackgroundDynamoLogTableHandler;

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

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

package/dist/cjs/background/background-execution-event-type.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackgroundExecutionEventType = void 0;
-var BackgroundExecutionEventType;
-(function (BackgroundExecutionEventType) {
-    BackgroundExecutionEventType["ProcessStarting"] = "ProcessStarting";
-    BackgroundExecutionEventType["DataValidationError"] = "DataValidationError";
-    BackgroundExecutionEventType["ExecutionSuccessfullyComplete"] = "ExecutionSuccessfullyComplete";
-    BackgroundExecutionEventType["ExecutionFailedError"] = "ExecutionRuntimeError";
-    BackgroundExecutionEventType["NoMatchProcessorName"] = "NoMatchProcessorName";
-})(BackgroundExecutionEventType = exports.BackgroundExecutionEventType || (exports.BackgroundExecutionEventType = {}));

package/dist/cjs/background/background-execution-event.js

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

package/dist/cjs/background/background-execution-listener.js

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

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

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