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

package/lib/local-container-server.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
 export declare class LocalContainerServer {
     private port;

package/lib/local-server.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { APIGatewayEvent, Context, ProxyResult } from 'aws-lambda';
 import { IncomingMessage, ServerResponse } from 'http';
 import { EpsilonGlobalHandler } from './epsilon-global-handler.js';

package/lib/sample/test-error-server.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
 export declare class TestErrorServer {
     private port;

package/lib/util/epsilon-config-parser.d.ts

@@ -1,4 +1,4 @@
-import { ModelValidator } from '@bitblit/ratchet-misc/lib/model-validator/model-validator.js';
+import { ModelValidator } from '@bitblit/ratchet-misc';
 import { OpenApiDocument } from '../config/open-api/open-api-document.js';
 import { EpsilonConfig } from '../config/epsilon-config.js';
 import { EpsilonInstance } from '../epsilon-instance.js';

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@bitblit/ratchet-epsilon-common",
-  "version": "4.0.115-alpha",
+  "version": "4.0.119-alpha",
   "description": "Tiny adapter to simplify building API gateway Lambda APIS",
   "sideEffects": false,
   "bin": {
     "epsilon-cli": "./bin/cli.js"
   },
   "type": "module",
-  "module": "index.js",
   "files": [
     "lib/*",
     "bin/*"
   ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs"
+    }
+  },
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
     "Benn Linger <benn@bennlinger.com>",
@@ -35,9 +40,9 @@
     "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 && tsc",
-    "build": "tsc",
+    "generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts && sed -i 's/\\x27;/.js\\x27;/' src/index.ts",
+    "build": "yarn clean && yarn generate-barrels && rollup -c rollup.config.js",
+    "force-build": "tsc --build --force",
     "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",
@@ -62,13 +67,13 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/client-s3": "3.328.0",
-    "@aws-sdk/client-sns": "3.328.0",
-    "@aws-sdk/client-sqs": "3.328.0",
-    "@bitblit/ratchet-aws": "4.0.115-alpha",
-    "@bitblit/ratchet-common": "4.0.115-alpha",
-    "@bitblit/ratchet-misc": "4.0.115-alpha",
-    "@bitblit/ratchet-node-only": "4.0.115-alpha",
+    "@aws-sdk/client-s3": "3.332.0",
+    "@aws-sdk/client-sns": "3.332.0",
+    "@aws-sdk/client-sqs": "3.332.0",
+    "@bitblit/ratchet-aws": "4.0.119-alpha",
+    "@bitblit/ratchet-common": "4.0.119-alpha",
+    "@bitblit/ratchet-misc": "4.0.119-alpha",
+    "@bitblit/ratchet-node-only": "4.0.119-alpha",
     "clear": "0.1.0",
     "commander": "10.0.1",
     "cross-fetch": "3.1.5",
@@ -108,12 +113,6 @@
     "y18n": "^5.0.8"
   },
   "peerDependencies": {
-    "@aws-sdk/client-sns": "^3.328.0",
-    "@aws-sdk/client-sqs": "3.328.0",
-    "@bitblit/ratchet-aws": "4.0.115-alpha",
-    "@bitblit/ratchet-common": "4.0.115-alpha",
-    "@types/aws-lambda": "^8.10.115",
-    "graphql": "^16.6.0"
   },
   "peerDependenciesMeta": {
     "graphql": {
@@ -121,7 +120,7 @@
     }
   },
   "devDependencies": {
-    "@bitblit/ratchet-jest": "4.0.115-alpha",
+    "@bitblit/ratchet-jest": "4.0.119-alpha",
     "@types/aws-lambda": "8.10.115",
     "apollo-server-lambda": "3.12.0",
     "aws-sdk-client-mock": "2.1.1",

package/lib/background/background-dynamo-log-table-handler.js

@@ -1,37 +0,0 @@
-import { BackgroundExecutionEventType } from './background-execution-event-type.js';
-import { ContextUtil } from '../util/context-util.js';
-export class BackgroundDynamoLogTableHandler {
-    dynamo;
-    tableName;
-    env;
-    backgroundQueueName;
-    constructor(dynamo, tableName, env, backgroundQueueName) {
-        this.dynamo = dynamo;
-        this.tableName = tableName;
-        this.env = env;
-        this.backgroundQueueName = backgroundQueueName;
-    }
-    async onEvent(event) {
-        const entry = {
-            env: this.env,
-            backgroundQueueName: this.backgroundQueueName,
-            requestId: ContextUtil.currentRequestId(),
-            guid: event.guid,
-            processTypeName: event.processorType,
-            state: event.type.toString(),
-            timestampEpochMs: new Date().getTime(),
-        };
-        if (event.type == BackgroundExecutionEventType.DataValidationError) {
-            const errors = event?.errors?.length ? event.errors : ['No-Error'];
-            entry.errors = errors;
-        }
-        else if (event.type == BackgroundExecutionEventType.ProcessStarting) {
-            entry.params = event.data;
-        }
-        else if (event.type == BackgroundExecutionEventType.ExecutionFailedError) {
-            const errors = event?.errors?.length ? event.errors : ['No-Error'];
-            entry.errors = errors;
-        }
-        await this.dynamo.simplePut(this.tableName, entry);
-    }
-}

package/lib/background/background-entry.js

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

package/lib/background/background-execution-event-type.js

@@ -1,8 +0,0 @@
-export var BackgroundExecutionEventType;
-(function (BackgroundExecutionEventType) {
-    BackgroundExecutionEventType["ProcessStarting"] = "ProcessStarting";
-    BackgroundExecutionEventType["DataValidationError"] = "DataValidationError";
-    BackgroundExecutionEventType["ExecutionSuccessfullyComplete"] = "ExecutionSuccessfullyComplete";
-    BackgroundExecutionEventType["ExecutionFailedError"] = "ExecutionRuntimeError";
-    BackgroundExecutionEventType["NoMatchProcessorName"] = "NoMatchProcessorName";
-})(BackgroundExecutionEventType || (BackgroundExecutionEventType = {}));

package/lib/background/background-execution-event.js

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

package/lib/background/background-execution-listener.js

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

package/lib/background/background-handler.js

@@ -1,273 +0,0 @@
-import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-import { EpsilonConstants } from '../epsilon-constants.js';
-import { BackgroundValidator } from './background-validator.js';
-import { BackgroundExecutionEventType } from './background-execution-event-type.js';
-import { ContextUtil } from '../util/context-util.js';
-import { AbstractBackgroundManager } from './manager/abstract-background-manager.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { StopWatch } from '@bitblit/ratchet-common/lib/lang/stop-watch.js';
-export class BackgroundHandler {
-    cfg;
-    mgr;
-    modelValidator;
-    processors;
-    validator;
-    constructor(cfg, mgr, modelValidator) {
-        this.cfg = cfg;
-        this.mgr = mgr;
-        this.modelValidator = modelValidator;
-        const cfgErrors = BackgroundValidator.validateConfig(cfg);
-        if (cfgErrors.length > 0) {
-            ErrorRatchet.throwFormattedErr('Invalid background config : %j', cfgErrors);
-        }
-        Logger.silly('Starting Background processor, %d processors', cfg.processors.length);
-        this.validator = new BackgroundValidator(cfg, modelValidator);
-        this.processors = BackgroundValidator.validateAndMapProcessors(cfg.processors, modelValidator);
-        if (mgr?.immediateProcessQueue && mgr.immediateProcessQueue()) {
-            Logger.info('Attaching to immediate processing queue');
-            mgr.immediateProcessQueue().subscribe(async (evt) => {
-                Logger.debug('Processing local background entry : %j', evt);
-                const rval = await this.processSingleBackgroundEntry(evt);
-                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 LambdaEventDetector.isValidSnsEvent(evt) && this.isBackgroundSNSEvent(evt);
-    }
-    isBackgroundSNSEvent(event) {
-        return this.isBackgroundStartSnsEvent(event) || this.isBackgroundImmediateFireEvent(event);
-    }
-    isBackgroundStartSnsEvent(event) {
-        let rval = false;
-        if (event) {
-            if (LambdaEventDetector.isSingleSnsEvent(event)) {
-                const cast = event;
-                rval = cast.Records[0].Sns.Message === EpsilonConstants.BACKGROUND_SNS_START_MARKER;
-            }
-        }
-        return rval;
-    }
-    isBackgroundImmediateFireEvent(event) {
-        let rval = false;
-        if (!!event) {
-            if (LambdaEventDetector.isSingleSnsEvent(event)) {
-                const cast = event;
-                const msg = cast.Records[0].Sns.Message;
-                if (!!StringRatchet.trimToNull(msg)) {
-                    const parsed = JSON.parse(msg);
-                    rval = !!parsed && parsed['type'] === EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG;
-                }
-            }
-        }
-        return rval;
-    }
-    parseImmediateFireBackgroundEntry(event) {
-        let rval = null;
-        try {
-            if (!!event) {
-                if (LambdaEventDetector.isSingleSnsEvent(event)) {
-                    const cast = event;
-                    const msg = cast.Records[0].Sns.Message;
-                    if (!!StringRatchet.trimToNull(msg)) {
-                        const parsed = JSON.parse(msg);
-                        if (!!parsed && parsed['type'] === EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG) {
-                            rval = parsed['backgroundEntry'];
-                        }
-                    }
-                }
-            }
-        }
-        catch (err) {
-            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) {
-                Logger.silly('Processing immediate fire event : %j', backgroundEntry);
-                const result = await this.processSingleBackgroundEntry(backgroundEntry);
-                procd = 1;
-            }
-            else {
-                Logger.warn('Tried to process non-background start / immediate event : %j returning false', event);
-            }
-        }
-        else {
-            Logger.info('Reading task from background queue');
-            procd = await this.takeAndProcessSingleBackgroundQueueEntry();
-            if (procd > 0) {
-                Logger.info('Processed %d elements from background queue, refiring', procd);
-                const refire = await this.mgr.fireStartProcessingRequest();
-                Logger.info('Refire returned %s', refire);
-            }
-            else {
-                Logger.info('No items processed - stopping');
-            }
-        }
-        const rval = {
-            statusCode: 200,
-            body: StringRatchet.safeString(procd),
-            isBase64Encoded: false,
-        };
-        return rval;
-    }
-    async takeAndProcessSingleBackgroundQueueEntry() {
-        let rval = null;
-        const entries = await this.mgr.takeEntryFromBackgroundQueue();
-        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;
-        }
-        Logger.debug('Returning %d', rval);
-        return rval;
-    }
-    async safeWriteToLogger(entry) {
-        if (this.cfg.transactionLogger) {
-            try {
-                await this.cfg.transactionLogger.logTransaction(entry);
-            }
-            catch (err) {
-                Logger.error('Failed to write to transaction logger : %j : %s', entry, err, err);
-            }
-        }
-        else {
-            Logger.silly('Skipping - no logger defined');
-        }
-    }
-    async conditionallyStartTransactionLog(e) {
-        if (!StringRatchet.trimToNull(e.guid)) {
-            Logger.warn('No guid found - creating');
-            e.guid = AbstractBackgroundManager.generateBackgroundGuid();
-            const log = {
-                request: e,
-                running: true,
-            };
-            await this.safeWriteToLogger(log);
-        }
-        Logger.debug('Starting transaction log');
-    }
-    async conditionallyCompleteTransactionLog(e, result, error, runtimeMS) {
-        Logger.debug('Completing transaction log');
-        const log = {
-            request: e,
-            result: result,
-            error: error ? ErrorRatchet.safeStringifyErr(error) : null,
-            running: false,
-            runtimeMS: runtimeMS,
-        };
-        await this.safeWriteToLogger(log);
-    }
-    async conditionallyRunErrorProcessor(e, error) {
-        try {
-            if (this.cfg.errorProcessor) {
-                Logger.info('Running error processor');
-                await this.cfg.errorProcessor.handleError(e, error);
-            }
-        }
-        catch (err) {
-            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) {
-                Logger.error('Failure triggering handler %s : %s', StringRatchet.trimToNull(listener?.label) || 'No-name', err);
-            }
-        }
-    }
-    async processSingleBackgroundEntry(e) {
-        ContextUtil.setOverrideTraceFromInternalBackgroundEntry(e);
-        Logger.info('Background Process Start: %j', e);
-        const sw = new StopWatch();
-        await this.conditionallyStartTransactionLog(e);
-        let rval = false;
-        try {
-            await this.fireListenerEvent({
-                type: BackgroundExecutionEventType.ProcessStarting,
-                processorType: e.type,
-                data: e.data,
-                guid: e.guid,
-            });
-            const processorInput = this.processors.get(e.type);
-            if (!processorInput) {
-                ErrorRatchet.throwFormattedErr('Found no processor for background entry : %j (returning false)', e);
-                await this.fireListenerEvent({
-                    type: BackgroundExecutionEventType.NoMatchProcessorName,
-                    processorType: e.type,
-                    data: e.data,
-                    guid: e.guid,
-                });
-            }
-            let dataValidationErrors = [];
-            if (StringRatchet.trimToNull(processorInput.dataSchemaName)) {
-                dataValidationErrors = this.modelValidator.validate(processorInput.dataSchemaName, e.data, false, false);
-            }
-            if (dataValidationErrors.length > 0) {
-                await this.fireListenerEvent({
-                    type: BackgroundExecutionEventType.DataValidationError,
-                    processorType: e.type,
-                    data: e.data,
-                    errors: dataValidationErrors,
-                    guid: e.guid,
-                });
-                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: BackgroundExecutionEventType.ExecutionSuccessfullyComplete,
-                    processorType: e.type,
-                    data: result,
-                    guid: e.guid,
-                });
-                rval = true;
-            }
-        }
-        catch (err) {
-            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: BackgroundExecutionEventType.ExecutionFailedError,
-                processorType: e.type,
-                data: e.data,
-                errors: [ErrorRatchet.safeStringifyErr(err)],
-                guid: e.guid,
-            });
-        }
-        Logger.info('Background Process Stop: %j : %s', e, sw.dump());
-        return rval;
-    }
-    getConfig() {
-        const rval = Object.assign({}, this.cfg);
-        return rval;
-    }
-}

package/lib/background/background-http-adapter-handler.js

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

package/lib/background/background-meta-response-internal.js

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

package/lib/background/background-process-handling.js

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

package/lib/background/background-process-log-table-entry.js

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

package/lib/background/background-queue-response-internal.js

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

package/lib/background/background-validator.js

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