@bitblit/ratchet-aws 4.0.80-alpha

package/dist/es/dynamodb/dynamo-table-ratchet.js

@@ -0,0 +1,87 @@
+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';
+export class DynamoTableRatchet {
+    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/dist/es/dynamodb/hash-spreader.js

@@ -0,0 +1,58 @@
+import { ErrorRatchet, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class HashSpreader {
+    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/dist/es/ec2/ec2-ratchet.js

@@ -0,0 +1,103 @@
+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';
+export class Ec2Ratchet {
+    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/dist/es/environment/cascade-environment-service-provider.js

@@ -0,0 +1,23 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class CascadeEnvironmentServiceProvider {
+    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/dist/es/environment/env-var-environment-service-provider.js

@@ -0,0 +1,29 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class EnvVarEnvironmentServiceProvider {
+    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/dist/es/environment/environment-service-config.js

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

package/dist/es/environment/environment-service-provider.js

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

package/dist/es/environment/environment-service.js

@@ -0,0 +1,48 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+export class EnvironmentService {
+    static defaultEnvironmentServiceConfig() {
+        const rval = {
+            maxRetries: 3,
+            backoffMultiplierMS: 500,
+        };
+        return rval;
+    }
+    constructor(provider, cfg = EnvironmentService.defaultEnvironmentServiceConfig()) {
+        this.provider = provider;
+        this.cfg = cfg;
+        this.readPromiseCache = new Map();
+        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/dist/es/environment/fixed-environment-service-provider.js

@@ -0,0 +1,20 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class FixedEnvironmentServiceProvider {
+    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/dist/es/environment/s3-environment-service-provider.js

@@ -0,0 +1,25 @@
+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 { S3Client } from '@aws-sdk/client-s3';
+export class S3EnvironmentServiceProvider {
+    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;
+    }
+}

package/dist/es/environment/ssm-environment-service-provider.js

@@ -0,0 +1,56 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+import { PromiseRatchet } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class SsmEnvironmentServiceProvider {
+    constructor(region = 'us-east-1', ssmEncrypted = true) {
+        this.region = region;
+        this.ssmEncrypted = ssmEncrypted;
+        RequireRatchet.notNullOrUndefined(region);
+        RequireRatchet.notNullOrUndefined(ssmEncrypted);
+        this.ssm = new SSMClient({ region: this.region });
+    }
+    async fetchConfig(name) {
+        Logger.silly('SsmEnvironmentServiceProvider fetch for %s', name);
+        const params = {
+            Name: name,
+            WithDecryption: this.ssmEncrypted,
+        };
+        let rval = null;
+        let toParse = null;
+        try {
+            const value = await this.ssm.send(new GetParameterCommand(params));
+            toParse = StringRatchet.trimToNull(value?.Parameter?.Value);
+        }
+        catch (err) {
+            const errCode = err['code'] || '';
+            if (errCode.toLowerCase().indexOf('throttlingexception') !== -1) {
+                Logger.warn('Throttled while trying to read parameters - waiting 1 second before allowing retry');
+                await PromiseRatchet.wait(1000);
+            }
+            else if (errCode.toLowerCase().indexOf('parameternotfound') !== -1) {
+                const errMsg = Logger.warn('AWS could not find parameter %s - are you using the right AWS key?', name);
+                throw new Error(errMsg);
+            }
+            else {
+                Logger.error('Final environment fetch error (cannot retry) : %s', err, err);
+                throw err;
+            }
+        }
+        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 system parameter with name : %s in this account', name);
+        }
+        return rval;
+    }
+}

package/dist/es/expiring-code/dynamo-expiring-code-provider.js

@@ -0,0 +1,22 @@
+export class DynamoExpiringCodeProvider {
+    constructor(tableName, dynamoRatchet) {
+        this.tableName = tableName;
+        this.dynamoRatchet = dynamoRatchet;
+    }
+    async checkCode(code, context, deleteOnMatch) {
+        const keys = { code: code, context: context };
+        const expCode = await this.dynamoRatchet.simpleGet(this.tableName, keys);
+        const rval = expCode && expCode.expiresEpochMS > Date.now();
+        if (rval && deleteOnMatch) {
+            await this.dynamoRatchet.simpleDelete(this.tableName, keys);
+        }
+        return rval;
+    }
+    async storeCode(code) {
+        const output = await this.dynamoRatchet.simplePut(this.tableName, code);
+        return output && output.ConsumedCapacity.CapacityUnits > 0;
+    }
+    async createTableIfMissing(dtr) {
+        return null;
+    }
+}

package/dist/es/expiring-code/expiring-code-params.js

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

package/dist/es/expiring-code/expiring-code-provider.js

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

package/dist/es/expiring-code/expiring-code-ratchet.js

@@ -0,0 +1,33 @@
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { StringRatchet } from '@bitblit/ratchet-common';
+export class ExpiringCodeRatchet {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    static generateCode(params) {
+        RequireRatchet.notNullOrUndefined(params, 'params');
+        RequireRatchet.notNullOrUndefined(params.context, 'params.context');
+        RequireRatchet.notNullOrUndefined(params.length, 'params.length');
+        RequireRatchet.notNullOrUndefined(params.alphabet, 'params.alphabet');
+        let code = '';
+        for (let i = 0; i < params.length; i++) {
+            code += params.alphabet.charAt(Math.floor(params.alphabet.length * Math.random()));
+        }
+        const rval = {
+            code: code,
+            context: params.context,
+            tags: params.tags,
+            expiresEpochMS: Date.now() + params.timeToLiveSeconds * 1000,
+        };
+        return rval;
+    }
+    async createNewCode(params) {
+        const value = ExpiringCodeRatchet.generateCode(params);
+        const rval = await this.provider.storeCode(value);
+        return rval ? value : null;
+    }
+    async checkCode(code, context, deleteOnMatch) {
+        const rval = await this.provider.checkCode(StringRatchet.trimToEmpty(code), StringRatchet.trimToEmpty(context), deleteOnMatch);
+        return rval;
+    }
+}

package/dist/es/expiring-code/expiring-code.js

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

package/dist/es/expiring-code/s3-expiring-code-provider.js

@@ -0,0 +1,45 @@
+import { Logger, RequireRatchet } from '@bitblit/ratchet-common';
+export class S3ExpiringCodeProvider {
+    constructor(s3CacheRatchet, keyName) {
+        this.s3CacheRatchet = s3CacheRatchet;
+        this.keyName = keyName;
+        RequireRatchet.notNullOrUndefined(s3CacheRatchet, 's3CacheRatchet');
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(s3CacheRatchet.getDefaultBucket(), 's3CacheRatchet.defaultBucket');
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(keyName, 'keyName');
+    }
+    async fetchFile() {
+        const rval = (await this.s3CacheRatchet.fetchCacheFileAsObject(this.keyName)) || {
+            data: [],
+            lastModifiedEpochMS: Date.now(),
+        };
+        return rval;
+    }
+    async updateFile(vals) {
+        const next = {
+            data: vals || [],
+            lastModifiedEpochMS: Date.now(),
+        };
+        next.data = next.data.filter((d) => d.expiresEpochMS > Date.now());
+        Logger.info('Updating code file to %s codes', next.data.length);
+        const rval = await this.s3CacheRatchet.writeObjectToCacheFile(this.keyName, next);
+        return rval;
+    }
+    async checkCode(code, context, deleteOnMatch) {
+        const val = await this.fetchFile();
+        const rval = val.data.find((d) => d?.code?.toUpperCase() === code?.toUpperCase() && d?.context?.toUpperCase() === context?.toUpperCase());
+        if (rval) {
+            if (deleteOnMatch || rval.expiresEpochMS < Date.now()) {
+                Logger.info('Stripping used/expired code from the database');
+                const newData = val.data.filter((d) => d != rval);
+                await this.updateFile(newData);
+            }
+        }
+        return !!rval && rval.expiresEpochMS > Date.now();
+    }
+    async storeCode(code) {
+        const old = await this.fetchFile();
+        old.data.push(code);
+        const wrote = await this.updateFile(old.data);
+        return !!wrote;
+    }
+}

package/dist/es/iam/aws-credentials-ratchet.js

@@ -0,0 +1,17 @@
+import { ErrorRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class AwsCredentialsRatchet {
+    constructor() { }
+    static applySetProfileEnvironmentalVariable(newProfile) {
+        if (!!process.env) {
+            if (StringRatchet.trimToNull(newProfile)) {
+                process.env['AWS_PROFILE'] = newProfile;
+            }
+            else {
+                ErrorRatchet.throwFormattedErr('Cannot set profile to null/empty string');
+            }
+        }
+        else {
+            ErrorRatchet.throwFormattedErr('Cannot set profile - not in a node environment - process missing');
+        }
+    }
+}