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

package/dist/{types/background → background}/background-dynamo-log-table-handler.d.ts

@@ -1,6 +1,6 @@
-import { BackgroundExecutionListener } from './background-execution-listener';
-import { BackgroundExecutionEvent } from './background-execution-event';
-import { DynamoRatchetLike } from '@bitblit/ratchet-aws';
+import { BackgroundExecutionListener } from './background-execution-listener.js';
+import { BackgroundExecutionEvent } from './background-execution-event.js';
+import { DynamoRatchetLike } from '@bitblit/ratchet-aws/dist/dynamodb/dynamo-ratchet-like.js';
 export declare class BackgroundDynamoLogTableHandler<T> implements BackgroundExecutionListener<T> {
     private dynamo;
     private tableName;

package/dist/{es/background → background}/background-dynamo-log-table-handler.js

@@ -1,6 +1,10 @@
-import { BackgroundExecutionEventType } from './background-execution-event-type';
-import { ContextUtil } from '../util/context-util';
+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;

package/dist/{types/background → background}/background-execution-event.d.ts

@@ -1,4 +1,4 @@
-import { BackgroundExecutionEventType } from './background-execution-event-type';
+import { BackgroundExecutionEventType } from './background-execution-event-type.js';
 export interface BackgroundExecutionEvent<T> {
     type: BackgroundExecutionEventType;
     guid: string;

package/dist/{types/background → background}/background-execution-listener.d.ts

@@ -1,4 +1,4 @@
-import { BackgroundExecutionEvent } from './background-execution-event';
+import { BackgroundExecutionEvent } from './background-execution-event.js';
 export interface BackgroundExecutionListener<T> {
     label?: string;
     onEvent(event: BackgroundExecutionEvent<T>): Promise<void>;

package/dist/{types/background → background}/background-handler.d.ts

@@ -1,13 +1,9 @@
 import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundConfig } from '../config/background/background-config';
-import { InternalBackgroundEntry } from './internal-background-entry';
-import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler';
-import { BackgroundManagerLike } from './manager/background-manager-like';
-/**
- * We use a FIFO queue so that 2 different Lambdas don't both work on the same
- * thing at the same time.
- */
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { BackgroundConfig } from '../config/background/background-config.js';
+import { InternalBackgroundEntry } from './internal-background-entry.js';
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { BackgroundManagerLike } from './manager/background-manager-like.js';
 export declare class BackgroundHandler implements EpsilonLambdaEventHandler<SNSEvent> {
     private cfg;
     private mgr;

package/dist/{es/background → background}/background-handler.js

@@ -1,11 +1,19 @@
-import { ErrorRatchet, Logger, StopWatch, StringRatchet } from '@bitblit/ratchet-common';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws';
-import { EpsilonConstants } from '../epsilon-constants';
-import { BackgroundValidator } from './background-validator';
-import { BackgroundExecutionEventType } from './background-execution-event-type';
-import { ContextUtil } from '../util/context-util';
-import { AbstractBackgroundManager } from './manager/abstract-background-manager';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/dist/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/dist/lang/string-ratchet.js';
+import { StopWatch } from '@bitblit/ratchet-common/dist/lang/stop-watch.js';
 export class BackgroundHandler {
+    cfg;
+    mgr;
+    modelValidator;
+    processors;
+    validator;
     constructor(cfg, mgr, modelValidator) {
         this.cfg = cfg;
         this.mgr = mgr;

package/dist/{types/background → background}/background-http-adapter-handler.d.ts

@@ -1,15 +1,11 @@
 import { Context } from 'aws-lambda';
-import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event';
-import { BackgroundQueueResponseInternal } from './background-queue-response-internal';
-import { BackgroundConfig } from '../config/background/background-config';
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundMetaResponseInternal } from './background-meta-response-internal';
-import { BackgroundTransactionLog } from '../config/background/background-transaction-log';
-import { BackgroundManagerLike } from './manager/background-manager-like';
-/**
- * We use a FIFO queue so that 2 different Lambdas don't both work on the same
- * thing at the same time.
- */
+import { ExtendedAPIGatewayEvent } from '../config/http/extended-api-gateway-event.js';
+import { BackgroundQueueResponseInternal } from './background-queue-response-internal.js';
+import { BackgroundConfig } from '../config/background/background-config.js';
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { BackgroundMetaResponseInternal } from './background-meta-response-internal.js';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log.js';
+import { BackgroundManagerLike } from './manager/background-manager-like.js';
 export declare class BackgroundHttpAdapterHandler {
     private backgroundConfig;
     private modelValidator;

package/dist/{es/background → background}/background-http-adapter-handler.js

@@ -1,12 +1,17 @@
-import { Logger, StopWatch } from '@bitblit/ratchet-common';
-import { BooleanRatchet } from '@bitblit/ratchet-common';
-import { BackgroundProcessHandling } from './background-process-handling';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { BadRequestError } from '../http/error/bad-request-error';
-import { NotFoundError } from '../http/error/not-found-error';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
+import { BackgroundProcessHandling } from './background-process-handling.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { BooleanRatchet } from '@bitblit/ratchet-common/dist/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/dist/lang/stop-watch.js';
 export class BackgroundHttpAdapterHandler {
-    constructor(backgroundConfig, modelValidator, backgroundManager, maxWaitInMsForBackgroundJobToStart = 10000) {
+    backgroundConfig;
+    modelValidator;
+    backgroundManager;
+    maxWaitInMsForBackgroundJobToStart;
+    constructor(backgroundConfig, modelValidator, backgroundManager, maxWaitInMsForBackgroundJobToStart = 10_000) {
         this.backgroundConfig = backgroundConfig;
         this.modelValidator = modelValidator;
         this.backgroundManager = backgroundManager;

package/dist/{types/background → background}/background-queue-response-internal.d.ts

@@ -1,4 +1,4 @@
-import { BackgroundProcessHandling } from './background-process-handling';
+import { BackgroundProcessHandling } from './background-process-handling.js';
 export interface BackgroundQueueResponseInternal {
     processHandling: BackgroundProcessHandling;
     startProcessorRequested: boolean;

package/dist/{types/background → background}/background-validator.d.ts

@@ -1,11 +1,8 @@
-import { ModelValidator } from '@bitblit/ratchet-misc';
-import { BackgroundConfig } from '../config/background/background-config';
-import { BackgroundEntry } from './background-entry';
-import { BackgroundProcessor } from '../config/background/background-processor';
-import { BackgroundAwsConfig } from '../config/background/background-aws-config';
-/**
- * Handles all submission of work to the background processing system.
- */
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { BackgroundConfig } from '../config/background/background-config.js';
+import { BackgroundEntry } from './background-entry.js';
+import { BackgroundProcessor } from '../config/background/background-processor.js';
+import { BackgroundAwsConfig } from '../config/background/background-aws-config.js';
 export declare class BackgroundValidator {
     private cfg;
     private modelValidator;

package/dist/{es/background → background}/background-validator.js

@@ -1,7 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 export class BackgroundValidator {
+    cfg;
+    modelValidator;
     constructor(cfg, modelValidator) {
         this.cfg = cfg;
         this.modelValidator = modelValidator;

package/dist/{es/background → background}/epsilon-background-process-error.js

@@ -1,5 +1,11 @@
 import util from 'util';
 export class EpsilonBackgroundProcessError extends Error {
+    static EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY = '__epsilonBackgroundProcessErrorFlag';
+    _errors;
+    _detailErrorCode;
+    _details;
+    _requestId;
+    _wrappedError;
     constructor(...errors) {
         super(EpsilonBackgroundProcessError.combineErrorStringsWithDefault(errors));
         Object.setPrototypeOf(this, EpsilonBackgroundProcessError.prototype);
@@ -85,4 +91,3 @@ export class EpsilonBackgroundProcessError extends Error {
         return this._wrappedError;
     }
 }
-EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY = '__epsilonBackgroundProcessErrorFlag';

package/dist/{types/background → background}/internal-background-entry.d.ts

@@ -1,4 +1,4 @@
-import { BackgroundEntry } from './background-entry';
+import { BackgroundEntry } from './background-entry.js';
 export interface InternalBackgroundEntry<T> extends BackgroundEntry<T> {
     guid: string;
     createdEpochMS: number;

package/dist/{types/background → background}/manager/abstract-background-manager.d.ts

@@ -1,13 +1,6 @@
-import { BackgroundEntry } from '../background-entry';
-import { InternalBackgroundEntry } from '../internal-background-entry';
-import { BackgroundManagerLike } from './background-manager-like';
-/**
- * Handles all submission of work to the background processing system.
- *
- * Note that this does NOT validate the input, it just passes it along.  This is
- * because it creates a circular reference to the processors if we try since they
- * define the type and validation.
- */
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { BackgroundManagerLike } from './background-manager-like.js';
 export declare abstract class AbstractBackgroundManager implements BackgroundManagerLike {
     abstract addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
     abstract fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;

package/dist/{es/background → background}/manager/abstract-background-manager.js

@@ -1,8 +1,9 @@
-import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/dist/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 import { DateTime } from 'luxon';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ContextUtil } from '../../util/context-util';
+import { ContextUtil } from '../../util/context-util.js';
 export class AbstractBackgroundManager {
     createEntry(type, data) {
         const rval = {

package/dist/{types/background → background}/manager/aws-sqs-sns-background-manager.d.ts

@@ -1,16 +1,9 @@
 import { GetQueueAttributesCommandOutput, SQSClient } from '@aws-sdk/client-sqs';
-import { BackgroundEntry } from '../background-entry';
-import { BackgroundAwsConfig } from '../../config/background/background-aws-config';
-import { InternalBackgroundEntry } from '../internal-background-entry';
-import { AbstractBackgroundManager } from './abstract-background-manager';
+import { BackgroundEntry } from '../background-entry.js';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
 import { SNSClient } from '@aws-sdk/client-sns';
-/**
- * Handles all submission of work to the background processing system.
- *
- * Note that this does NOT validate the input, it just passes it along.  This is
- * because it creates a circular reference to the processors if we try since they
- * define the type and validation.
- */
 export declare class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
     private _awsConfig;
     private _sqs;

package/dist/{es/background → background}/manager/aws-sqs-sns-background-manager.js

@@ -1,11 +1,15 @@
-import { Logger, NumberRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { NumberRatchet } from '@bitblit/ratchet-common/dist/lang/number-ratchet.js';
 import { DeleteMessageCommand, GetQueueAttributesCommand, ReceiveMessageCommand, SendMessageCommand, } from '@aws-sdk/client-sqs';
-import { EpsilonConstants } from '../../epsilon-constants';
-import { AbstractBackgroundManager } from './abstract-background-manager';
-import { BackgroundValidator } from '../background-validator';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { EpsilonConstants } from '../../epsilon-constants.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
+import { BackgroundValidator } from '../background-validator.js';
 import { PublishCommand } from '@aws-sdk/client-sns';
 export class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
+    _awsConfig;
+    _sqs;
+    _sns;
     constructor(_awsConfig, _sqs, _sns) {
         super();
         this._awsConfig = _awsConfig;

package/dist/{types/background → background}/manager/background-manager-like.d.ts

@@ -1,13 +1,6 @@
-import { BackgroundEntry } from '../background-entry';
-import { InternalBackgroundEntry } from '../internal-background-entry';
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
 import { Subject } from 'rxjs';
-/**
- * Classes implementing this interface handle all submission of work to the background processing system.
- *
- * Note that these do NOT validate the input, they just passes it along.  This is
- * because it creates a circular reference to the processors if we try since they
- * define the type and validation.
- */
 export interface BackgroundManagerLike {
     get backgroundManagerName(): string;
     immediateProcessQueue?(): Subject<InternalBackgroundEntry<any>>;

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

@@ -0,0 +1,73 @@
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { GetQueueAttributesCommand, SQSClient } from '@aws-sdk/client-sqs';
+import { ModelValidator } from '@bitblit/ratchet-misc/dist/model-validator/model-validator.js';
+import { AwsSqsSnsBackgroundManager } from './aws-sqs-sns-background-manager.js';
+import { EchoProcessor } from '../../built-in/background/echo-processor.js';
+import { NoOpProcessor } from '../../built-in/background/no-op-processor.js';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockSqs;
+let mockSns;
+describe('#createEntry', function () {
+    mockSns = mockClient(SNSClient);
+    mockSqs = mockClient(SQSClient);
+    let backgroundMgr;
+    const fakeAccountNumber = '123456789012';
+    let backgroundConfig;
+    let backgroundAwsConfig;
+    const fakeModelValidator = new ModelValidator({ BackgroundBuiltInSampleInputValidatedProcessor: {} });
+    const echoProcessor = new EchoProcessor();
+    const noOpProcessor = new NoOpProcessor();
+    beforeEach(() => {
+        mockSqs.reset();
+        mockSns.reset();
+        backgroundConfig = {
+            processors: [echoProcessor, noOpProcessor],
+            httpSubmissionPath: '/background/',
+            implyTypeFromPathSuffix: true,
+            httpMetaEndpoint: '/background-meta',
+        };
+        backgroundAwsConfig = {
+            queueUrl: 'https://fake-sqs.fake-availability-zone.test.com/' + fakeAccountNumber + '/fakeQueue.fifo',
+            notificationArn: 'arn:aws:sns:fake-availability-zone:' + fakeAccountNumber + ':fakeSnsTopicName',
+        };
+        backgroundMgr = new AwsSqsSnsBackgroundManager(backgroundAwsConfig, mockSqs, mockSns);
+    });
+    it('Should return queue attributes', async () => {
+        mockSqs.on(GetQueueAttributesCommand).resolves({
+            Attributes: {
+                ApproximateNumberOfMessages: 1,
+            },
+        });
+        const queueAttr = await backgroundMgr.fetchCurrentQueueAttributes();
+        const msgCount = await backgroundMgr.fetchApproximateNumberOfQueueEntries();
+        Logger.info('Got : %j', queueAttr);
+        Logger.info('Msg: %d', msgCount);
+        expect(queueAttr).toBeTruthy();
+        expect(msgCount).toEqual(1);
+    });
+    it('Should round-trip guids with prefix no slash', async () => {
+        const prefix = 'test';
+        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+        expect(guid).toBeTruthy();
+        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+        expect(outGuid).toEqual(guid);
+    });
+    it('Should round-trip guids with prefix with slash', async () => {
+        const prefix = 'test/';
+        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+        expect(guid).toBeTruthy();
+        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+        expect(outGuid).toEqual(guid);
+    });
+    it('Should round-trip guids with no prefix', async () => {
+        const prefix = null;
+        const guid = AwsSqsSnsBackgroundManager.generateBackgroundGuid();
+        expect(guid).toBeTruthy();
+        const path = AwsSqsSnsBackgroundManager.backgroundGuidToPath(prefix, guid);
+        const outGuid = AwsSqsSnsBackgroundManager.pathToBackgroundGuid(prefix, path);
+        expect(outGuid).toEqual(guid);
+    });
+});

package/dist/{types/background → background}/manager/single-thread-local-background-manager.d.ts

@@ -1,14 +1,7 @@
 import { Subject } from 'rxjs';
-import { BackgroundEntry } from '../background-entry';
-import { InternalBackgroundEntry } from '../internal-background-entry';
-import { AbstractBackgroundManager } from './abstract-background-manager';
-/**
- * Handles all submission of work to the background processing system.
- *
- * Note that this does NOT validate the input, it just passes it along.  This is
- * because it creates a circular reference to the processors if we try since they
- * define the type and validation.
- */
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
 export declare class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
     private _localBus;
     get backgroundManagerName(): string;

package/dist/{es/background → background}/manager/single-thread-local-background-manager.js

@@ -1,13 +1,13 @@
 import { Subject } from 'rxjs';
-import { Logger } from '@bitblit/ratchet-common';
-import { AbstractBackgroundManager } from './abstract-background-manager';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
 export class SingleThreadLocalBackgroundManager extends AbstractBackgroundManager {
+    _localBus = new Subject();
     get backgroundManagerName() {
         return 'SingleThreadLocalBackgroundManager';
     }
     constructor() {
         super();
-        this._localBus = new Subject();
     }
     immediateProcessQueue() {
         return this._localBus;

package/dist/{types/background → background}/s3-background-transaction-logger.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundTransactionLogger } from '../config/background/background-transaction-logger';
-import { BackgroundTransactionLog } from '../config/background/background-transaction-log';
+import { BackgroundTransactionLogger } from '../config/background/background-transaction-logger.js';
+import { BackgroundTransactionLog } from '../config/background/background-transaction-log.js';
 import { S3Client } from '@aws-sdk/client-s3';
 export declare class S3BackgroundTransactionLogger implements BackgroundTransactionLogger {
     private cfg;

package/dist/{es/background → background}/s3-background-transaction-logger.js

@@ -1,7 +1,10 @@
-import { S3CacheRatchet } from '@bitblit/ratchet-aws';
-import { AbstractBackgroundManager } from './manager/abstract-background-manager';
-import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
+import { S3CacheRatchet } from '@bitblit/ratchet-aws/dist/s3/s3-cache-ratchet.js';
+import { AbstractBackgroundManager } from './manager/abstract-background-manager.js';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class S3BackgroundTransactionLogger {
+    cfg;
+    s3TransactionLogCacheRatchet;
     constructor(cfg) {
         this.cfg = cfg;
         const err = S3BackgroundTransactionLogger.validateConfig(cfg);

package/dist/{types/build → build}/ratchet-epsilon-common-info.d.ts

@@ -1,4 +1,4 @@
-import { BuildInformation } from '@bitblit/ratchet-common';
+import { BuildInformation } from '@bitblit/ratchet-common/dist/build/build-information.js';
 export declare class RatchetEpsilonCommonInfo {
     private constructor();
     static buildInformation(): BuildInformation;

package/dist/{types/built-in → built-in}/background/echo-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class EchoProcessor implements BackgroundProcessor<any> {
     static TYPE_NAME: string;
     get typeName(): string;

package/dist/{es/built-in → built-in}/background/echo-processor.js

@@ -1,6 +1,8 @@
-import { ErrorRatchet, Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/dist/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 export class EchoProcessor {
+    static TYPE_NAME = 'EpsilonEcho';
     get typeName() {
         return EchoProcessor.TYPE_NAME;
     }
@@ -11,4 +13,3 @@ export class EchoProcessor {
         }
     }
 }
-EchoProcessor.TYPE_NAME = 'EpsilonEcho';

package/dist/{types/built-in → built-in}/background/log-and-enqueue-echo-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class LogAndEnqueueEchoProcessor implements BackgroundProcessor<any> {
     get typeName(): string;
     handleEvent(data: any, cfg: BackgroundManagerLike): Promise<void>;

package/dist/{es/built-in → built-in}/background/log-and-enqueue-echo-processor.js

@@ -1,5 +1,5 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { EchoProcessor } from './echo-processor';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { EchoProcessor } from './echo-processor.js';
 export class LogAndEnqueueEchoProcessor {
     get typeName() {
         return 'EpsilonLogAndEnqueueEcho';

package/dist/{types/built-in → built-in}/background/log-message-background-error-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundErrorProcessor } from '../../config/background/background-error-processor';
-import { InternalBackgroundEntry } from '../../background/internal-background-entry';
+import { BackgroundErrorProcessor } from '../../config/background/background-error-processor.js';
+import { InternalBackgroundEntry } from '../../background/internal-background-entry.js';
 export declare class LogMessageBackgroundErrorProcessor implements BackgroundErrorProcessor {
     handleError(submission: InternalBackgroundEntry<any>, error: Error): Promise<void>;
 }

package/dist/{es/built-in → built-in}/background/log-message-background-error-processor.js

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

package/dist/{types/built-in → built-in}/background/no-op-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class NoOpProcessor implements BackgroundProcessor<any> {
     get typeName(): string;
     handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;

package/dist/{es/built-in → built-in}/background/no-op-processor.js

@@ -1,4 +1,4 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class NoOpProcessor {
     get typeName() {
         return 'EpsilonNoOp';

package/dist/{types/built-in → built-in}/background/retry-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class RetryProcessor implements BackgroundProcessor<any> {
     private delegate;
     private opts;

package/dist/{es/built-in → built-in}/background/retry-processor.js

@@ -1,7 +1,12 @@
-import { DurationRatchet, Logger, PromiseRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { NumberRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
+import { DurationRatchet } from '@bitblit/ratchet-common/dist/lang/duration-ratchet.js';
+import { NumberRatchet } from '@bitblit/ratchet-common/dist/lang/number-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
 export class RetryProcessor {
+    delegate;
+    opts;
+    static RETRY_FIELD_NAME = '___RetryProcessorTryNumber';
     constructor(delegate, opts) {
         this.delegate = delegate;
         this.opts = opts;
@@ -33,4 +38,3 @@ export class RetryProcessor {
         }
     }
 }
-RetryProcessor.RETRY_FIELD_NAME = '___RetryProcessorTryNumber';

package/dist/{types/built-in → built-in}/background/sample-delay-processor.d.ts

@@ -1,5 +1,5 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class SampleDelayProcessor implements BackgroundProcessor<any> {
     get typeName(): string;
     handleEvent(data: any, mgr?: BackgroundManagerLike): Promise<void>;

package/dist/{es/built-in → built-in}/background/sample-delay-processor.js

@@ -1,4 +1,5 @@
-import { Logger, PromiseRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/dist/lang/promise-ratchet.js';
 export class SampleDelayProcessor {
     get typeName() {
         return 'EpsilonSampleDelay';

package/dist/{types/built-in → built-in}/background/sample-input-validated-processor.d.ts

@@ -1,6 +1,6 @@
-import { BackgroundProcessor } from '../../config/background/background-processor';
-import { SampleInputValidatedProcessorData } from './sample-input-validated-processor-data';
-import { BackgroundManagerLike } from '../../background/manager/background-manager-like';
+import { BackgroundProcessor } from '../../config/background/background-processor.js';
+import { SampleInputValidatedProcessorData } from './sample-input-validated-processor-data.js';
+import { BackgroundManagerLike } from '../../background/manager/background-manager-like.js';
 export declare class SampleInputValidatedProcessor implements BackgroundProcessor<SampleInputValidatedProcessorData> {
     get typeName(): string;
     handleEvent(data: SampleInputValidatedProcessorData, mgr?: BackgroundManagerLike): Promise<void>;

package/dist/{es/built-in → built-in}/background/sample-input-validated-processor.js

@@ -1,4 +1,4 @@
-import { Logger } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/dist/logger/logger.js';
 export class SampleInputValidatedProcessor {
     get typeName() {
         return 'EpsilonSampleInputValidated';

package/dist/{es/built-in → built-in}/built-in-trace-id-generators.js

@@ -1,5 +1,5 @@
-import { StringRatchet } from '@bitblit/ratchet-common';
-import { ContextUtil } from '../util/context-util';
+import { StringRatchet } from '@bitblit/ratchet-common/dist/lang/string-ratchet.js';
+import { ContextUtil } from '../util/context-util.js';
 export class BuiltInTraceIdGenerators {
     static fullAwsRequestId() {
         let rval = ContextUtil.currentRequestId();

package/dist/{types/built-in → built-in}/daemon/daemon-authorizer-function.d.ts

@@ -1,5 +1,5 @@
-import { DaemonProcessState } from '@bitblit/ratchet-aws';
-import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event';
+import { DaemonProcessState } from '@bitblit/ratchet-aws/dist/daemon/daemon-process-state.js';
+import { ExtendedAPIGatewayEvent } from '../../config/http/extended-api-gateway-event.js';
 export interface DaemonAuthorizerFunction {
     (evt: ExtendedAPIGatewayEvent, proc: DaemonProcessState): Promise<boolean>;
 }