@bitblit/ratchet-aws 4.0.99-alpha → 4.0.103-alpha

package/{dist/types → lib}/dao/prototype-dao.d.ts

@@ -1,5 +1,5 @@
-import { PrototypeDaoProvider } from './prototype-dao-provider';
-import { PrototypeDaoConfig } from './prototype-dao-config';
+import { PrototypeDaoProvider } from './prototype-dao-provider.js';
+import { PrototypeDaoConfig } from './prototype-dao-config.js';
 export declare class PrototypeDao<T> {
     private provider;
     private cfg;

package/{dist/es → lib}/dao/prototype-dao.js

@@ -1,14 +1,10 @@
-import { MapRatchet, RequireRatchet, StringRatchet } 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 { MapRatchet } from '@bitblit/ratchet-common/lib/lang/map-ratchet.js';
 import { DateTime } from 'luxon';
 export class PrototypeDao {
-    constructor(provider, cfg = PrototypeDao.defaultDaoConfig()) {
-        this.provider = provider;
-        this.cfg = cfg;
-        RequireRatchet.notNullOrUndefined(provider, 'provider');
-        RequireRatchet.notNullOrUndefined(cfg, 'cfg');
-        RequireRatchet.notNullOrUndefined(cfg.guidCreateFunction, 'cfg.guidCreateFunction');
-        RequireRatchet.notNullOrUndefined(cfg.guidFieldName, 'cfg.guidFieldName');
-    }
+    provider;
+    cfg;
     static defaultDaoConfig() {
         return {
             guidCreateFunction: StringRatchet.createType4Guid,
@@ -19,6 +15,14 @@ export class PrototypeDao {
             updatedUtcTimestampFieldName: null,
         };
     }
+    constructor(provider, cfg = PrototypeDao.defaultDaoConfig()) {
+        this.provider = provider;
+        this.cfg = cfg;
+        RequireRatchet.notNullOrUndefined(provider, 'provider');
+        RequireRatchet.notNullOrUndefined(cfg, 'cfg');
+        RequireRatchet.notNullOrUndefined(cfg.guidCreateFunction, 'cfg.guidCreateFunction');
+        RequireRatchet.notNullOrUndefined(cfg.guidFieldName, 'cfg.guidFieldName');
+    }
     async fetchAll() {
         const db = await this.provider.loadDatabase();
         return db.items || [];

package/lib/dao/prototype-dao.spec.d.ts

@@ -0,0 +1,8 @@
+export interface TestPrototypeItem {
+    fieldA: number;
+    fieldB: string;
+    type: string;
+    createdEpochMS?: number;
+    updatedEpochMS?: number;
+    guid?: string;
+}

package/lib/dao/prototype-dao.spec.js

@@ -0,0 +1,26 @@
+import { PrototypeDao } from './prototype-dao.js';
+import { S3PrototypeDaoProvider } from './s3-prototype-dao-provider.js';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { S3Client } from '@aws-sdk/client-s3';
+describe('#PrototypeDao', () => {
+    xit('Should save/load files', async () => {
+        const svc = new PrototypeDao(new S3PrototypeDaoProvider(new S3CacheRatchet(new S3Client({}), 'some-bucket'), 'test-data.json'));
+        await svc.resetDatabase();
+        await svc.store({ fieldA: 1, fieldB: 'test1', type: 'a' });
+        await svc.store({ fieldA: 2, fieldB: 'test2', type: 'a' });
+        await svc.store({ fieldA: 2, fieldB: 'test3', type: 'b' });
+        await svc.store({ guid: 'forceGuid', fieldA: 4, fieldB: 'test4', type: 'c' });
+        const test1 = await svc.fetchAll();
+        expect(test1.length).toBe(4);
+        const test2 = await svc.fetchById('forceGuid');
+        expect(test2).not.toBeNull();
+        expect(test2.createdEpochMS).not.toBeNull();
+        expect(test2.updatedEpochMS).not.toBeNull();
+        const test3 = await svc.searchByField('fieldA', 4);
+        expect(test3.length).toBe(1);
+        expect(test3[0].guid).toEqual('forceGuid');
+        const test4 = await svc.searchByFieldMap({ type: 'a', fieldA: 2 });
+        expect(test4.length).toBe(1);
+        await svc.resetDatabase();
+    }, 300_000);
+});

package/{dist/types → lib}/dao/s3-prototype-dao-provider.d.ts

@@ -1,6 +1,6 @@
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-import { PrototypeDaoProvider } from './prototype-dao-provider';
-import { PrototypeDaoDb } from './prototype-dao-db';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { PrototypeDaoProvider } from './prototype-dao-provider.js';
+import { PrototypeDaoDb } from './prototype-dao-db.js';
 export declare class S3PrototypeDaoProvider<T> implements PrototypeDaoProvider<T> {
     private s3CacheRatchet;
     private keyName;

package/{dist/es → lib}/dao/s3-prototype-dao-provider.js

@@ -1,5 +1,7 @@
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class S3PrototypeDaoProvider {
+    s3CacheRatchet;
+    keyName;
     constructor(s3CacheRatchet, keyName) {
         this.s3CacheRatchet = s3CacheRatchet;
         this.keyName = keyName;

package/{dist/types → lib}/dao/s3-simple-dao.d.ts

@@ -1,5 +1,5 @@
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-import { SimpleDaoItem } from './simple-dao-item';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { SimpleDaoItem } from './simple-dao-item.js';
 export declare class S3SimpleDao<T extends SimpleDaoItem> {
     private cache;
     private prefix?;

package/{dist/es → lib}/dao/s3-simple-dao.js

@@ -1,6 +1,8 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class S3SimpleDao {
+    cache;
+    prefix;
     constructor(cache, prefix) {
         this.cache = cache;
         this.prefix = prefix;

package/{dist/types → lib}/dynamodb/dynamo-ratchet-like.d.ts

@@ -1,8 +1,8 @@
-import { DynamoCountResult } from '../model/dynamo-count-result';
+import { DynamoCountResult } from '../model/dynamo-count-result.js';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { DeleteItemCommandOutput, PutItemOutput } from '@aws-sdk/client-dynamodb';
-import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input';
-import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input';
+import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input.js';
+import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input.js';
 export interface DynamoRatchetLike {
     getDDB(): DynamoDBDocumentClient;
     tableIsEmpty(tableName: string): Promise<boolean>;

package/{dist/types → lib}/dynamodb/dynamo-ratchet.d.ts

@@ -1,9 +1,9 @@
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-import { DynamoCountResult } from '../model/dynamo-count-result';
-import { DynamoRatchetLike } from './dynamo-ratchet-like';
+import { DynamoCountResult } from '../model/dynamo-count-result.js';
+import { DynamoRatchetLike } from './dynamo-ratchet-like.js';
 import { DeleteItemCommandOutput, PutItemCommandOutput, QueryCommandOutput, ScanCommandOutput } from '@aws-sdk/client-dynamodb';
-import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input';
-import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input';
+import { DocScanCommandInput } from '../model/dynamo/doc-scan-command-input.js';
+import { DocQueryCommandInput } from '../model/dynamo/doc-query-command-input.js';
 export declare class DynamoRatchet implements DynamoRatchetLike {
     private awsDDB;
     constructor(awsDDB: DynamoDBDocumentClient);

package/{dist/es → lib}/dynamodb/dynamo-ratchet.js

@@ -1,12 +1,13 @@
 import { BatchGetCommand, BatchWriteCommand, DeleteCommand, GetCommand, PutCommand, QueryCommand, ScanCommand, } from '@aws-sdk/lib-dynamodb';
-import { Logger } from '@bitblit/ratchet-common';
-import { DurationRatchet } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { NumberRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { DurationRatchet } from '@bitblit/ratchet-common/lib/lang/duration-ratchet.js';
+import { NumberRatchet } from '@bitblit/ratchet-common/lib/lang/number-ratchet.js';
 import { UpdateItemCommand, } from '@aws-sdk/client-dynamodb';
 export class DynamoRatchet {
+    awsDDB;
     constructor(awsDDB) {
         this.awsDDB = awsDDB;
         if (!awsDDB) {

package/lib/dynamodb/dynamo-ratchet.spec.js

@@ -0,0 +1,156 @@
+import { DynamoRatchet } from './dynamo-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { mockClient } from 'aws-sdk-client-mock';
+let mockDynamo;
+describe('#dynamoRatchet', function () {
+    mockDynamo = mockClient(DynamoDBDocumentClient);
+    beforeEach(() => {
+        mockDynamo.reset();
+    });
+    xit('should handle ProvisionedThroughputExceeded exceptions', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        let row = 0;
+        const scan = {
+            TableName: 'cache-device-data',
+            ProjectionExpression: 'compositeKey',
+        };
+        Logger.info('Starting scan');
+        const cnt = await dr.fullyExecuteProcessOverScan(scan, async (ob) => {
+            if (row % 100 === 0) {
+                Logger.info('Row : %d : %j', row, ob);
+            }
+            row++;
+        });
+        Logger.info('Count was : %d', cnt);
+    }, 300_000_000);
+    xit('should only write if a field is null', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        const tableName = 'some-table';
+        const test1 = { lockingKey: 'aaa', xx: null };
+        await dr.simplePut(tableName, test1);
+        const test2 = { lockingKey: 'aaa', xx: 5 };
+        const val1 = await dr.simplePutOnlyIfFieldIsNullOrUndefined(tableName, test2, 'xx');
+        expect(val1).toBeTruthy();
+        const test3 = { lockingKey: 'aaa', xx: 7 };
+        const val2 = await dr.simplePutOnlyIfFieldIsNullOrUndefined(tableName, test3, 'xx');
+        expect(val2).toBeFalsy();
+    });
+    xit('should fetch items from a key-only index query', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        const tableName = 'some-table';
+        const limit = 200;
+        const qry = {
+            TableName: tableName,
+            IndexName: 'purchaseId-notBeforeEpochMS-index',
+            KeyConditionExpression: 'purchaseId = :purchaseId',
+            Limit: limit,
+            ExpressionAttributeValues: {
+                ':purchaseId': 'some-purchase',
+            },
+        };
+        const res = await dr.fetchFullObjectsMatchingKeysOnlyIndexQuery(qry, ['key1', 'key2']);
+        Logger.info('Got : %s', res);
+        expect(res).toBeTruthy();
+    });
+    xit('should increment the counter and return the new value', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        const tableName = 'xxx';
+        const res = await dr.atomicCounter(tableName, { groupId: 'global', unitId: 'sequence' }, 'lastValue', 1);
+        Logger.info('Got : %s', res);
+        expect(res).toBeTruthy();
+    });
+    xit('should stop after the soft limit', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        const now = new Date().getTime();
+        const nowSec = Math.floor(now / 1000);
+        const curHash = 'someHash';
+        const qry = {
+            TableName: 'some-table',
+            KeyConditionExpression: 'hashVal = :hashVal',
+            ExpressionAttributeValues: {
+                ':hashVal': curHash,
+            },
+        };
+        const res = await dr.fullyExecuteQuery(qry, null, 150);
+        Logger.info('Got : %s', res);
+        expect(res).toBeTruthy();
+    }, 300_000);
+    xit('should run an insert / read test for slowdown', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        Logger.setLevel(LoggerLevelName.debug);
+        const now = new Date().getTime();
+        const nowSec = Math.floor(now / 1000);
+        const nums = [];
+        for (let i = 0; i < 300; i++) {
+            const toWrite = {
+                id: 'CW_DDB_TEST',
+                data: 'SOME DATA',
+                numData: i,
+            };
+            nums.push(toWrite);
+        }
+        Logger.info('About to start');
+        const writeProms = nums.map((n) => dr.simplePut('some-table', n));
+        const writeOut = await Promise.all(writeProms);
+        Logger.info('Write : %j', writeOut);
+        const readProms = [];
+        Logger.info('Start : %d', new Date().getTime());
+        for (let i = 0; i < 10000; i++) {
+            readProms.push(dr.simpleGet('some-table', { id: 'CW_DDB_TEST' }));
+        }
+        Logger.info('Mid : %d', new Date().getTime());
+        const readOut = await Promise.all(readProms);
+        Logger.info('Read : %d : %j', new Date().getTime(), readOut);
+    });
+    xit('should run a collision test', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        Logger.setLevel(LoggerLevelName.debug);
+        const val = {
+            k1: 'abc',
+            k2: 1,
+        };
+        for (let i = 0; i < 5; i++) {
+            const rval = await dr.simplePutWithCollisionAvoidance('cwtest', val, ['k1', 'k2'], (v) => {
+                v.k2++;
+                return v;
+            }, null, 3);
+            Logger.info('output was : %j', rval);
+        }
+    });
+    xit('should do a simple get with counter decrement', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        Logger.setLevel(LoggerLevelName.debug);
+        const v = await dr.simpleGetWithCounterDecrement('cwtest', { k1: 'abc', k2: 11 }, 'counter', true);
+        Logger.info('Got : %j', v);
+    });
+    xit('should do a full query', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        Logger.setLevel(LoggerLevelName.debug);
+        const input = {
+            TableName: 'some-table',
+            KeyConditionExpression: 'groupId = :g',
+            ExpressionAttributeValues: {
+                ':g': 'NeonBatch',
+            },
+        };
+        const res = await dr.fullyExecuteQuery(input);
+        Logger.info('Got : %j', res);
+    });
+    xit('should do a process over full query', async () => {
+        const dr = new DynamoRatchet(mockDynamo);
+        Logger.setLevel(LoggerLevelName.debug);
+        const input = {
+            TableName: 'some-table',
+            KeyConditionExpression: 'groupId = :g',
+            ExpressionAttributeValues: {
+                ':g': 'NeonBatch',
+            },
+        };
+        const res = await dr.fullyExecuteProcessOverQuery(input, async (v) => {
+            Logger.info('Proc %j', v);
+        });
+        Logger.info('Got : %j', res);
+    });
+});

package/{dist/es → lib}/dynamodb/dynamo-table-ratchet.js

@@ -1,9 +1,10 @@
 import { CreateTableCommand, DeleteTableCommand, DescribeTableCommand, } from '@aws-sdk/client-dynamodb';
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
 export class DynamoTableRatchet {
+    awsDDB;
     constructor(awsDDB) {
         this.awsDDB = awsDDB;
         if (!awsDDB) {

package/{dist/es → lib}/dynamodb/hash-spreader.js

@@ -1,5 +1,12 @@
-import { ErrorRatchet, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class HashSpreader {
+    spots;
+    buckets;
+    separator;
+    alphabet;
+    _allSlots;
     constructor(spots = 3, buckets = 16, separator = '_', alphabet = '0123456789ABCDEF') {
         this.spots = spots;
         this.buckets = buckets;

package/lib/dynamodb/hash-spreader.spec.js

@@ -0,0 +1,17 @@
+import { HashSpreader } from './hash-spreader.js';
+describe('#hashSpreader', function () {
+    it('should enumerate spread', async () => {
+        const spread = new HashSpreader(3, 16);
+        expect(spread.allBuckets.length).toEqual(16);
+        const spread2 = new HashSpreader(3, 19);
+        expect(spread2.allBuckets.length).toEqual(19);
+    });
+    it('should spread1', async () => {
+        const spread = new HashSpreader(3, 16);
+        expect(spread.allSpreadValues('x').length).toEqual(16);
+    });
+    it('should spread multi', async () => {
+        const spread = new HashSpreader(3, 16);
+        expect(spread.allSpreadValuesForArray(['x', 'y']).length).toEqual(32);
+    });
+});

package/{dist/types → lib}/ec2/ec2-ratchet.d.ts

@@ -1,16 +1,5 @@
 import { Instance } from '@aws-sdk/client-ec2';
 import { SendSSHPublicKeyCommandOutput } from '@aws-sdk/client-ec2-instance-connect';
-/**
- * Service to simplify interacting with EC2 instances
- *
- * NOTE!  If you are going to describe instances, you MUST use resource: '*' in your
- * IAM priv - any other value will fail.  See
- * https://forums.aws.amazon.com/thread.jspa?threadID=142312 and
- * https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html
- *
- *
- * Really should combine start and stop below
- */
 export declare class Ec2Ratchet {
     private region;
     private availabilityZone;

package/{dist/es → lib}/ec2/ec2-ratchet.js

@@ -1,9 +1,13 @@
 import { DescribeInstancesCommand, EC2Client, StartInstancesCommand, StopInstancesCommand, } from '@aws-sdk/client-ec2';
 import { EC2InstanceConnectClient, SendSSHPublicKeyCommand, } from '@aws-sdk/client-ec2-instance-connect';
-import { Logger } from '@bitblit/ratchet-common';
-import { DurationRatchet } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
+import { DurationRatchet } from '@bitblit/ratchet-common/lib/lang/duration-ratchet.js';
 export class Ec2Ratchet {
+    region;
+    availabilityZone;
+    ec2;
+    ec2InstanceConnect;
     constructor(region = 'us-east-1', availabilityZone = 'us-east-1a') {
         this.region = region;
         this.availabilityZone = availabilityZone;

package/lib/ec2/ec2-ratchet.spec.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { Ec2Ratchet } from './ec2-ratchet.js';
+describe('#EC2Ratchet', function () {
+    xit('should send a public key', async () => {
+        const ratchet = new Ec2Ratchet();
+        const instId = 'i-replace_me';
+        const pubKey = fs.readFileSync(path.join(os.homedir(), '.ssh/id_rsa.pub')).toString();
+        const res = await ratchet.sendPublicKeyToEc2Instance(instId, pubKey);
+        Logger.info('Got : %j', res);
+        expect(res).toBeTruthy();
+    });
+    xit('should list instances', async () => {
+        const ratchet = new Ec2Ratchet();
+        const res = await ratchet.listAllInstances();
+        Logger.info('Got : %j', res);
+        expect(res).toBeTruthy();
+        expect(res.length).toBeGreaterThan(1);
+    });
+    xit('should start and stop an instance', async () => {
+        const ratchet = new Ec2Ratchet();
+        const instId = 'i-replace_me';
+        Logger.info('First start');
+        await ratchet.launchInstance(instId, 1000 * 60);
+        Logger.info('Next stop');
+        await ratchet.stopInstance(instId, 1000 * 60);
+        Logger.info('Complete');
+    });
+});

package/{dist/types → lib}/environment/cascade-environment-service-provider.d.ts

@@ -1,7 +1,4 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
-/**
- * Reads a series of providers, returning the first non-null, non-error
- */
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
 export declare class CascadeEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
     private providers;
     constructor(providers: EnvironmentServiceProvider<T>[]);

package/{dist/es → lib}/environment/cascade-environment-service-provider.js

@@ -1,6 +1,7 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class CascadeEnvironmentServiceProvider {
+    providers;
     constructor(providers) {
         this.providers = providers;
         RequireRatchet.notNullOrUndefined(providers);

package/{dist/types → lib}/environment/env-var-environment-service-provider.d.ts

@@ -1,8 +1,4 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
-/**
- * Service for reading environmental variables
- * Also hides the decryption detail from higher up servicess
- */
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
 export declare class EnvVarEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
     private envVarName;
     constructor(envVarName: string);

package/{dist/es → lib}/environment/env-var-environment-service-provider.js

@@ -1,8 +1,9 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
 export class EnvVarEnvironmentServiceProvider {
+    envVarName;
     constructor(envVarName) {
         this.envVarName = envVarName;
         RequireRatchet.notNullOrUndefined(envVarName);

package/{dist/types → lib}/environment/environment-service-config.d.ts

@@ -1,6 +1,3 @@
-/**
- * Configuration of environmental server
- */
 export interface EnvironmentServiceConfig {
     maxRetries: number;
     backoffMultiplierMS: number;

package/lib/environment/environment-service-provider.d.ts

@@ -0,0 +1,3 @@
+export interface EnvironmentServiceProvider<T> {
+    fetchConfig(name: string): Promise<T>;
+}

package/{dist/types → lib}/environment/environment-service.d.ts

@@ -1,8 +1,5 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
-import { EnvironmentServiceConfig } from './environment-service-config';
-/**
- * Wraps up a EnvironmentServiceProvider and provides caching and retry-on-failure logic
- */
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+import { EnvironmentServiceConfig } from './environment-service-config.js';
 export declare class EnvironmentService<T> {
     private provider;
     private cfg;

package/{dist/es → lib}/environment/environment-service.js

@@ -1,15 +1,11 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { PromiseRatchet } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lib/lang/error-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
 export class EnvironmentService {
-    constructor(provider, cfg = EnvironmentService.defaultEnvironmentServiceConfig()) {
-        this.provider = provider;
-        this.cfg = cfg;
-        this.readPromiseCache = new Map();
-        RequireRatchet.notNullOrUndefined(provider);
-        RequireRatchet.notNullOrUndefined(cfg);
-    }
+    provider;
+    cfg;
+    readPromiseCache = new Map();
     static defaultEnvironmentServiceConfig() {
         const rval = {
             maxRetries: 3,
@@ -17,6 +13,12 @@ export class EnvironmentService {
         };
         return rval;
     }
+    constructor(provider, cfg = EnvironmentService.defaultEnvironmentServiceConfig()) {
+        this.provider = provider;
+        this.cfg = cfg;
+        RequireRatchet.notNullOrUndefined(provider);
+        RequireRatchet.notNullOrUndefined(cfg);
+    }
     async getConfig(name) {
         Logger.silly('EnvService:Request to read config %s', name);
         if (!this.readPromiseCache.has(name)) {

package/lib/environment/environment-service.spec.js

@@ -0,0 +1,22 @@
+import { EnvironmentService } from './environment-service.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { FixedEnvironmentServiceProvider } from './fixed-environment-service-provider.js';
+const fixed = FixedEnvironmentServiceProvider.fromRecord({ a: 'b', c: 5 });
+describe('#environmentService', function () {
+    it('should throw exception on missing environment values', async () => {
+        try {
+            const es = new EnvironmentService(fixed);
+            const vals = await es.getConfig('i_do_not_exist');
+            this.bail('Should not have returned a value');
+        }
+        catch (err) {
+            expect(err).toBeTruthy();
+            Logger.info('Success - threw %s', err);
+        }
+    });
+    it('should find a valid value', async () => {
+        const es = new EnvironmentService(fixed);
+        const vals = await es.getConfig('c');
+        expect(vals).toBeTruthy();
+    });
+});

package/{dist/types → lib}/environment/fixed-environment-service-provider.d.ts

@@ -1,7 +1,4 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
-/**
- * Forces in a single object as the environment
- */
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
 export declare class FixedEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
     private value;
     constructor(value: Map<string, T>);

package/{dist/es → lib}/environment/fixed-environment-service-provider.js

@@ -1,6 +1,7 @@
-import { Logger } from '@bitblit/ratchet-common';
-import { RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
 export class FixedEnvironmentServiceProvider {
+    value;
     constructor(value) {
         this.value = value;
         RequireRatchet.notNullOrUndefined(value);

package/{dist/types → lib}/environment/s3-environment-service-provider.d.ts

@@ -1,8 +1,5 @@
-import { EnvironmentServiceProvider } from './environment-service-provider';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
 import { S3Client } from '@aws-sdk/client-s3';
-/**
- * Service for reading environmental variables from S3
- */
 export declare class S3EnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
     private cfg;
     private ratchet;

package/{dist/es → lib}/environment/s3-environment-service-provider.js

@@ -1,10 +1,12 @@
-import { S3CacheRatchet } from '../s3/s3-cache-ratchet';
-import { RequireRatchet } from '@bitblit/ratchet-common';
-import { StopWatch } from '@bitblit/ratchet-common';
-import { Logger } from '@bitblit/ratchet-common';
-import { StringRatchet } from '@bitblit/ratchet-common';
+import { S3CacheRatchet } from '../s3/s3-cache-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
+import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
+import { StopWatch } from '@bitblit/ratchet-common/lib/lang/stop-watch.js';
 import { S3Client } from '@aws-sdk/client-s3';
 export class S3EnvironmentServiceProvider {
+    cfg;
+    ratchet;
     constructor(cfg) {
         this.cfg = cfg;
         RequireRatchet.notNullOrUndefined(cfg);