@bitblit/ratchet-aws 4.0.115-alpha → 4.0.116-alpha

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

@@ -1,156 +0,0 @@
-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/lib/dynamodb/dynamo-table-ratchet.js

@@ -1,88 +0,0 @@
-import { CreateTableCommand, DeleteTableCommand, DescribeTableCommand, } from '@aws-sdk/client-dynamodb';
-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) {
-            throw 'awsDDB may not be null';
-        }
-    }
-    async deleteTable(tableName, waitForDelete = true) {
-        RequireRatchet.notNullOrUndefined(tableName);
-        const input = {
-            TableName: tableName,
-        };
-        Logger.debug('Deleting ddb table %s', tableName);
-        const rval = await this.awsDDB.send(new DeleteTableCommand(input));
-        if (waitForDelete) {
-            Logger.debug('Table marked for delete, waiting for deletion');
-            await this.waitForTableDelete(tableName);
-        }
-        return rval;
-    }
-    async createTable(input, waitForReady = true, replaceIfExists = false) {
-        RequireRatchet.notNullOrUndefined(input);
-        RequireRatchet.notNullOrUndefined(input.TableName);
-        Logger.debug('Creating new table : %j', input);
-        const exists = await this.tableExists(input.TableName);
-        if (exists) {
-            if (replaceIfExists) {
-                Logger.debug('Table %s exists and replace specified - deleting', input.TableName);
-                await this.deleteTable(input.TableName);
-            }
-            else {
-                ErrorRatchet.throwFormattedErr('Cannot create table %s - exists already and replace not specified', input.TableName);
-            }
-        }
-        const rval = await this.awsDDB.send(new CreateTableCommand(input));
-        if (waitForReady) {
-            Logger.debug('Table created, awaiting ready');
-            await this.waitForTableReady(input.TableName);
-        }
-        return rval;
-    }
-    async waitForTableReady(tableName) {
-        let rval = true;
-        let out = await this.safeDescribeTable(tableName);
-        while (!!out && !!out.Table && out.Table.TableStatus !== 'ACTIVE') {
-            Logger.silly('Table not ready - waiting 2 seconds');
-            await PromiseRatchet.wait(2000);
-            out = await this.safeDescribeTable(tableName);
-        }
-        if (!out && !out.Table) {
-            Logger.warn('Cannot wait for %s to be ready - table does not exist', tableName);
-            rval = false;
-        }
-        return rval;
-    }
-    async waitForTableDelete(tableName) {
-        let out = await this.safeDescribeTable(tableName);
-        while (!!out) {
-            Logger.silly('Table %s still exists, waiting 2 seconds (State is %s)', tableName, out.Table.TableStatus);
-            await PromiseRatchet.wait(2000);
-            out = await this.safeDescribeTable(tableName);
-        }
-    }
-    async tableExists(tableName) {
-        const desc = await this.safeDescribeTable(tableName);
-        return !!desc;
-    }
-    async safeDescribeTable(tableName) {
-        try {
-            const out = await this.awsDDB.send(new DescribeTableCommand({ TableName: tableName }));
-            return out;
-        }
-        catch (err) {
-            if (!!err['code'] && err['code'] === 'ResourceNotFoundException') {
-                return null;
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-}

package/lib/dynamodb/hash-spreader.js

@@ -1,65 +0,0 @@
-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;
-        this.separator = separator;
-        this.alphabet = alphabet;
-        RequireRatchet.true(spots > 0, 'Spots must be larger than 0');
-        RequireRatchet.true(buckets > 1, 'Buckets must be larger than 1');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(alphabet), 'Alphabet may not be null or empty');
-        RequireRatchet.true(StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
-        RequireRatchet.true(StringRatchet.stringContainsOnlyAlphanumeric(alphabet), 'Alphabet must be alphanumeric');
-        const permutations = Math.pow(alphabet.length, spots);
-        RequireRatchet.true(buckets < permutations, 'Buckets must be less than permutations (' + buckets + ' / ' + permutations + ')');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(this.separator), 'Separator must be nonnull and nonempty');
-        const allPerms = StringRatchet.allPermutationsOfLength(spots, alphabet);
-        this._allSlots = allPerms.slice(0, buckets);
-    }
-    get allBuckets() {
-        return Object.assign([], this._allSlots);
-    }
-    get randomBucket() {
-        return this._allSlots[Math.floor(Math.random() * this.buckets)];
-    }
-    allSpreadValues(input) {
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
-        const rval = this._allSlots.map((s) => input + this.separator + s);
-        return rval;
-    }
-    allSpreadValuesForArray(inputs) {
-        RequireRatchet.true(inputs && inputs.length > 0, 'Cannot spread null/empty array');
-        let rval = [];
-        inputs.forEach((i) => {
-            rval = rval.concat(this.allSpreadValues(i));
-        });
-        return rval;
-    }
-    addSpreader(input) {
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
-        return input + this.separator + this.randomBucket;
-    }
-    extractBucket(input) {
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
-        const loc = input.length - this.spots;
-        if (loc < 0 || input.charAt(loc) !== this.separator) {
-            ErrorRatchet.throwFormattedErr('Cannot extract bucket, not created by this spreader (missing %s at location %d)', this.separator, loc);
-        }
-        return input.substring(loc);
-    }
-    removeBucket(input) {
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
-        const loc = input.length - this.spots;
-        if (loc < 0 || input.charAt(loc) !== this.separator) {
-            ErrorRatchet.throwFormattedErr('Cannot remove bucket, not created by this spreader (missing %s at location %d)', this.separator, loc);
-        }
-        return input.substring(0, loc);
-    }
-}

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

@@ -1,17 +0,0 @@
-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/lib/ec2/ec2-ratchet.js

@@ -1,107 +0,0 @@
-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/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;
-        this.ec2 = new EC2Client({ region: region });
-        this.ec2InstanceConnect = new EC2InstanceConnectClient({ region: region });
-    }
-    async stopInstance(instanceId, maxWaitForShutdownMS = 0) {
-        let rval = true;
-        try {
-            const stopParams = {
-                InstanceIds: [instanceId],
-                DryRun: false,
-            };
-            Logger.info('About to stop instances : %j', stopParams);
-            await this.ec2.send(new StopInstancesCommand(stopParams));
-            Logger.info('Stop instance command sent, waiting on shutdown');
-            let status = await this.describeInstance(instanceId);
-            if (maxWaitForShutdownMS > 0) {
-                const start = new Date().getTime();
-                while (!!status && status.State.Code !== 16 && new Date().getTime() - start < maxWaitForShutdownMS) {
-                    Logger.debug('Instance status is %j - waiting for 5 seconds (up to %s)', status.State, DurationRatchet.formatMsDuration(maxWaitForShutdownMS));
-                    await PromiseRatchet.wait(5000);
-                    status = await this.describeInstance(instanceId);
-                }
-            }
-        }
-        catch (err) {
-            Logger.error('Failed to stop instance %s : %s', instanceId, err, err);
-            rval = false;
-        }
-        return rval;
-    }
-    async launchInstance(instanceId, maxWaitForStartupMS = 0) {
-        let rval = true;
-        try {
-            const startParams = {
-                InstanceIds: [instanceId],
-                DryRun: false,
-            };
-            Logger.info('About to start instance : %j', startParams);
-            await this.ec2.send(new StartInstancesCommand(startParams));
-            Logger.info('Start instance command sent, waiting on startup');
-            let status = await this.describeInstance(instanceId);
-            if (maxWaitForStartupMS > 0) {
-                const start = new Date().getTime();
-                while (!!status && status.State.Code !== 16 && new Date().getTime() - start < maxWaitForStartupMS) {
-                    Logger.debug('Instance status is %j - waiting for 5 seconds (up to %s)', status.State, DurationRatchet.formatMsDuration(maxWaitForStartupMS));
-                    await PromiseRatchet.wait(5000);
-                    status = await this.describeInstance(instanceId);
-                }
-            }
-            if (!!status && !!status.PublicIpAddress) {
-                Logger.info('Instance address is %s', status.PublicIpAddress);
-                Logger.info('SSH command : ssh -i path_to_pem_file ec2-user@%s', status.PublicIpAddress);
-            }
-        }
-        catch (err) {
-            Logger.error('Failed to start instance %s : %s', instanceId, err, err);
-            rval = false;
-        }
-        return rval;
-    }
-    async describeInstance(instanceId) {
-        const res = await this.listAllInstances([instanceId]);
-        return res.length === 1 ? res[0] : null;
-    }
-    async listAllInstances(instanceIds = []) {
-        let rval = [];
-        const req = {
-            NextToken: null,
-        };
-        if (instanceIds && instanceIds.length > 0) {
-            req.InstanceIds = instanceIds;
-        }
-        do {
-            Logger.debug('Pulling instances... (%j)', req);
-            const res = await this.ec2.send(new DescribeInstancesCommand(req));
-            res.Reservations.forEach((r) => {
-                rval = rval.concat(r.Instances);
-            });
-            req.NextToken = res.NextToken;
-        } while (req.NextToken);
-        Logger.debug('Finished pulling instances (found %d)', rval.length);
-        return rval;
-    }
-    async sendPublicKeyToEc2Instance(instanceId, publicKeyString, instanceOsUser) {
-        const userName = instanceOsUser || 'ec2-user';
-        const req = {
-            InstanceId: instanceId,
-            AvailabilityZone: this.availabilityZone,
-            InstanceOSUser: userName,
-            SSHPublicKey: publicKeyString,
-        };
-        const rval = await this.ec2InstanceConnect.send(new SendSSHPublicKeyCommand(req));
-        return rval;
-    }
-}

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

@@ -1,31 +0,0 @@
-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/lib/environment/cascade-environment-service-provider.js

@@ -1,24 +0,0 @@
-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);
-        RequireRatchet.true(providers.length > 0);
-    }
-    async fetchConfig(name) {
-        Logger.silly('CascadeEnvironmentServiceProvider fetch for %s', name);
-        let rval = null;
-        for (let i = 0; i < this.providers.length && !rval; i++) {
-            try {
-                rval = await this.providers[i].fetchConfig(name);
-            }
-            catch (err) {
-                Logger.error('Provider %d failed - trying next : %s', i, err, err);
-                rval = null;
-            }
-        }
-        return rval;
-    }
-}

package/lib/environment/env-var-environment-service-provider.js

@@ -1,30 +0,0 @@
-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);
-    }
-    async fetchConfig() {
-        Logger.silly('EnvVarEnvironmentServiceProvider fetch for %s', this.envVarName);
-        let rval = null;
-        const src = process ? process.env : global ? global : {};
-        const toParse = StringRatchet.trimToNull(src[this.envVarName]);
-        if (toParse) {
-            try {
-                rval = JSON.parse(toParse);
-            }
-            catch (err) {
-                Logger.error('Failed to read env - null or invalid JSON : %s : %s', err, toParse, err);
-                throw err;
-            }
-        }
-        else {
-            ErrorRatchet.throwFormattedErr('Could not find env var with name : %s', this.envVarName);
-        }
-        return rval;
-    }
-}

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

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

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

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

package/lib/environment/environment-service.js

@@ -1,50 +0,0 @@
-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 {
-    provider;
-    cfg;
-    readPromiseCache = new Map();
-    static defaultEnvironmentServiceConfig() {
-        const rval = {
-            maxRetries: 3,
-            backoffMultiplierMS: 500,
-        };
-        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)) {
-            Logger.silly('EnvService: Nothing in cache - adding');
-            this.readPromiseCache.set(name, this.getConfigUncached(name));
-        }
-        return this.readPromiseCache.get(name);
-    }
-    async getConfigUncached(name) {
-        let tryCount = 1;
-        let rval = null;
-        while (!rval && tryCount < this.cfg.maxRetries) {
-            tryCount++;
-            Logger.silly('Attempting fetch of %s', name);
-            try {
-                rval = await this.provider.fetchConfig(name);
-            }
-            catch (err) {
-                const waitMS = tryCount * this.cfg.backoffMultiplierMS;
-                Logger.info('Error attempting to fetch config %s (try %d of %d, waiting %s MS): %s', name, tryCount, this.cfg.maxRetries, waitMS, err, err);
-                await PromiseRatchet.wait(waitMS);
-            }
-        }
-        if (!rval) {
-            ErrorRatchet.throwFormattedErr('Was unable to fetch config %s even after %d retries', name, this.cfg.maxRetries);
-        }
-        return rval;
-    }
-}

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

@@ -1,22 +0,0 @@
-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/lib/environment/fixed-environment-service-provider.js

@@ -1,21 +0,0 @@
-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);
-    }
-    static fromRecord(record) {
-        const m = new Map();
-        Object.keys(record).forEach((k) => {
-            m.set(k, record[k]);
-        });
-        return new FixedEnvironmentServiceProvider(m);
-    }
-    async fetchConfig(name) {
-        Logger.silly('FixedEnvironmentServiceProvider fetch for %s', name);
-        const rval = this.value.get(name);
-        return rval;
-    }
-}

package/lib/environment/s3-environment-service-provider.js

@@ -1,27 +0,0 @@
-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);
-        RequireRatchet.notNullOrUndefined(cfg.bucketName);
-        RequireRatchet.notNullOrUndefined(cfg.region);
-        RequireRatchet.true(!!cfg.s3Override || !!cfg.region, 'You must set either region or S3Override');
-        const s3 = cfg.s3Override || new S3Client({ region: cfg.region });
-        this.ratchet = new S3CacheRatchet(s3, cfg.bucketName);
-    }
-    async fetchConfig(name) {
-        const readPath = StringRatchet.trimToEmpty(this.cfg.pathPrefix) + name + StringRatchet.trimToEmpty(this.cfg.pathSuffix);
-        Logger.silly('S3EnvironmentServiceProvider:Request to read config from : %s / %s', this.cfg.bucketName, readPath);
-        const sw = new StopWatch();
-        const rval = await this.ratchet.fetchCacheFileAsObject(readPath);
-        sw.log();
-        return rval;
-    }
-}