@bitblit/ratchet-aws 4.0.80-alpha

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoTableRatchet = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class DynamoTableRatchet {
+    constructor(awsDDB) {
+        this.awsDDB = awsDDB;
+        if (!awsDDB) {
+            throw 'awsDDB may not be null';
+        }
+    }
+    async deleteTable(tableName, waitForDelete = true) {
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(tableName);
+        const input = {
+            TableName: tableName,
+        };
+        ratchet_common_1.Logger.debug('Deleting ddb table %s', tableName);
+        const rval = await this.awsDDB.send(new client_dynamodb_1.DeleteTableCommand(input));
+        if (waitForDelete) {
+            ratchet_common_1.Logger.debug('Table marked for delete, waiting for deletion');
+            await this.waitForTableDelete(tableName);
+        }
+        return rval;
+    }
+    async createTable(input, waitForReady = true, replaceIfExists = false) {
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(input);
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(input.TableName);
+        ratchet_common_1.Logger.debug('Creating new table : %j', input);
+        const exists = await this.tableExists(input.TableName);
+        if (exists) {
+            if (replaceIfExists) {
+                ratchet_common_1.Logger.debug('Table %s exists and replace specified - deleting', input.TableName);
+                await this.deleteTable(input.TableName);
+            }
+            else {
+                ratchet_common_4.ErrorRatchet.throwFormattedErr('Cannot create table %s - exists already and replace not specified', input.TableName);
+            }
+        }
+        const rval = await this.awsDDB.send(new client_dynamodb_1.CreateTableCommand(input));
+        if (waitForReady) {
+            ratchet_common_1.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') {
+            ratchet_common_1.Logger.silly('Table not ready - waiting 2 seconds');
+            await ratchet_common_3.PromiseRatchet.wait(2000);
+            out = await this.safeDescribeTable(tableName);
+        }
+        if (!out && !out.Table) {
+            ratchet_common_1.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) {
+            ratchet_common_1.Logger.silly('Table %s still exists, waiting 2 seconds (State is %s)', tableName, out.Table.TableStatus);
+            await ratchet_common_3.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 client_dynamodb_1.DescribeTableCommand({ TableName: tableName }));
+            return out;
+        }
+        catch (err) {
+            if (!!err['code'] && err['code'] === 'ResourceNotFoundException') {
+                return null;
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+}
+exports.DynamoTableRatchet = DynamoTableRatchet;

package/dist/cjs/dynamodb/hash-spreader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashSpreader = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class HashSpreader {
+    constructor(spots = 3, buckets = 16, separator = '_', alphabet = '0123456789ABCDEF') {
+        this.spots = spots;
+        this.buckets = buckets;
+        this.separator = separator;
+        this.alphabet = alphabet;
+        ratchet_common_1.RequireRatchet.true(spots > 0, 'Spots must be larger than 0');
+        ratchet_common_1.RequireRatchet.true(buckets > 1, 'Buckets must be larger than 1');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(alphabet), 'Alphabet may not be null or empty');
+        ratchet_common_1.RequireRatchet.true(ratchet_common_1.StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
+        ratchet_common_1.RequireRatchet.true(ratchet_common_1.StringRatchet.stringContainsOnlyAlphanumeric(alphabet), 'Alphabet must be alphanumeric');
+        const permutations = Math.pow(alphabet.length, spots);
+        ratchet_common_1.RequireRatchet.true(buckets < permutations, 'Buckets must be less than permutations (' + buckets + ' / ' + permutations + ')');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(this.separator), 'Separator must be nonnull and nonempty');
+        const allPerms = ratchet_common_1.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) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
+        const rval = this._allSlots.map((s) => input + this.separator + s);
+        return rval;
+    }
+    allSpreadValuesForArray(inputs) {
+        ratchet_common_1.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) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(input), 'Cannot spread null/empty value');
+        return input + this.separator + this.randomBucket;
+    }
+    extractBucket(input) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
+        const loc = input.length - this.spots;
+        if (loc < 0 || input.charAt(loc) !== this.separator) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot extract bucket, not created by this spreader (missing %s at location %d)', this.separator, loc);
+        }
+        return input.substring(loc);
+    }
+    removeBucket(input) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(ratchet_common_1.StringRatchet.trimToNull(input), 'Cannot extract from null or empty value');
+        const loc = input.length - this.spots;
+        if (loc < 0 || input.charAt(loc) !== this.separator) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot remove bucket, not created by this spreader (missing %s at location %d)', this.separator, loc);
+        }
+        return input.substring(0, loc);
+    }
+}
+exports.HashSpreader = HashSpreader;

package/dist/cjs/ec2/ec2-ratchet.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ec2Ratchet = void 0;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_ec2_instance_connect_1 = require("@aws-sdk/client-ec2-instance-connect");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+class Ec2Ratchet {
+    constructor(region = 'us-east-1', availabilityZone = 'us-east-1a') {
+        this.region = region;
+        this.availabilityZone = availabilityZone;
+        this.ec2 = new client_ec2_1.EC2Client({ region: region });
+        this.ec2InstanceConnect = new client_ec2_instance_connect_1.EC2InstanceConnectClient({ region: region });
+    }
+    async stopInstance(instanceId, maxWaitForShutdownMS = 0) {
+        let rval = true;
+        try {
+            const stopParams = {
+                InstanceIds: [instanceId],
+                DryRun: false,
+            };
+            ratchet_common_1.Logger.info('About to stop instances : %j', stopParams);
+            await this.ec2.send(new client_ec2_1.StopInstancesCommand(stopParams));
+            ratchet_common_1.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) {
+                    ratchet_common_1.Logger.debug('Instance status is %j - waiting for 5 seconds (up to %s)', status.State, ratchet_common_2.DurationRatchet.formatMsDuration(maxWaitForShutdownMS));
+                    await ratchet_common_3.PromiseRatchet.wait(5000);
+                    status = await this.describeInstance(instanceId);
+                }
+            }
+        }
+        catch (err) {
+            ratchet_common_1.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,
+            };
+            ratchet_common_1.Logger.info('About to start instance : %j', startParams);
+            await this.ec2.send(new client_ec2_1.StartInstancesCommand(startParams));
+            ratchet_common_1.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) {
+                    ratchet_common_1.Logger.debug('Instance status is %j - waiting for 5 seconds (up to %s)', status.State, ratchet_common_2.DurationRatchet.formatMsDuration(maxWaitForStartupMS));
+                    await ratchet_common_3.PromiseRatchet.wait(5000);
+                    status = await this.describeInstance(instanceId);
+                }
+            }
+            if (!!status && !!status.PublicIpAddress) {
+                ratchet_common_1.Logger.info('Instance address is %s', status.PublicIpAddress);
+                ratchet_common_1.Logger.info('SSH command : ssh -i path_to_pem_file ec2-user@%s', status.PublicIpAddress);
+            }
+        }
+        catch (err) {
+            ratchet_common_1.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 {
+            ratchet_common_1.Logger.debug('Pulling instances... (%j)', req);
+            const res = await this.ec2.send(new client_ec2_1.DescribeInstancesCommand(req));
+            res.Reservations.forEach((r) => {
+                rval = rval.concat(r.Instances);
+            });
+            req.NextToken = res.NextToken;
+        } while (req.NextToken);
+        ratchet_common_1.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 client_ec2_instance_connect_1.SendSSHPublicKeyCommand(req));
+        return rval;
+    }
+}
+exports.Ec2Ratchet = Ec2Ratchet;

package/dist/cjs/environment/cascade-environment-service-provider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeEnvironmentServiceProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class CascadeEnvironmentServiceProvider {
+    constructor(providers) {
+        this.providers = providers;
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(providers);
+        ratchet_common_2.RequireRatchet.true(providers.length > 0);
+    }
+    async fetchConfig(name) {
+        ratchet_common_1.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) {
+                ratchet_common_1.Logger.error('Provider %d failed - trying next : %s', i, err, err);
+                rval = null;
+            }
+        }
+        return rval;
+    }
+}
+exports.CascadeEnvironmentServiceProvider = CascadeEnvironmentServiceProvider;

package/dist/cjs/environment/env-var-environment-service-provider.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvVarEnvironmentServiceProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+class EnvVarEnvironmentServiceProvider {
+    constructor(envVarName) {
+        this.envVarName = envVarName;
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(envVarName);
+    }
+    async fetchConfig() {
+        ratchet_common_1.Logger.silly('EnvVarEnvironmentServiceProvider fetch for %s', this.envVarName);
+        let rval = null;
+        const src = process ? process.env : global ? global : {};
+        const toParse = ratchet_common_4.StringRatchet.trimToNull(src[this.envVarName]);
+        if (toParse) {
+            try {
+                rval = JSON.parse(toParse);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Failed to read env - null or invalid JSON : %s : %s', err, toParse, err);
+                throw err;
+            }
+        }
+        else {
+            ratchet_common_3.ErrorRatchet.throwFormattedErr('Could not find env var with name : %s', this.envVarName);
+        }
+        return rval;
+    }
+}
+exports.EnvVarEnvironmentServiceProvider = EnvVarEnvironmentServiceProvider;

package/dist/cjs/environment/environment-service-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentService = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+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();
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(provider);
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(cfg);
+    }
+    async getConfig(name) {
+        ratchet_common_1.Logger.silly('EnvService:Request to read config %s', name);
+        if (!this.readPromiseCache.has(name)) {
+            ratchet_common_1.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++;
+            ratchet_common_1.Logger.silly('Attempting fetch of %s', name);
+            try {
+                rval = await this.provider.fetchConfig(name);
+            }
+            catch (err) {
+                const waitMS = tryCount * this.cfg.backoffMultiplierMS;
+                ratchet_common_1.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 ratchet_common_2.PromiseRatchet.wait(waitMS);
+            }
+        }
+        if (!rval) {
+            ratchet_common_4.ErrorRatchet.throwFormattedErr('Was unable to fetch config %s even after %d retries', name, this.cfg.maxRetries);
+        }
+        return rval;
+    }
+}
+exports.EnvironmentService = EnvironmentService;

package/dist/cjs/environment/fixed-environment-service-provider.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedEnvironmentServiceProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class FixedEnvironmentServiceProvider {
+    constructor(value) {
+        this.value = value;
+        ratchet_common_2.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) {
+        ratchet_common_1.Logger.silly('FixedEnvironmentServiceProvider fetch for %s', name);
+        const rval = this.value.get(name);
+        return rval;
+    }
+}
+exports.FixedEnvironmentServiceProvider = FixedEnvironmentServiceProvider;

package/dist/cjs/environment/s3-environment-service-provider.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3EnvironmentServiceProvider = void 0;
+const s3_cache_ratchet_1 = require("../s3/s3-cache-ratchet");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+const client_s3_1 = require("@aws-sdk/client-s3");
+class S3EnvironmentServiceProvider {
+    constructor(cfg) {
+        this.cfg = cfg;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg);
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg.bucketName);
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg.region);
+        ratchet_common_1.RequireRatchet.true(!!cfg.s3Override || !!cfg.region, 'You must set either region or S3Override');
+        const s3 = cfg.s3Override || new client_s3_1.S3Client({ region: cfg.region });
+        this.ratchet = new s3_cache_ratchet_1.S3CacheRatchet(s3, cfg.bucketName);
+    }
+    async fetchConfig(name) {
+        const readPath = ratchet_common_4.StringRatchet.trimToEmpty(this.cfg.pathPrefix) + name + ratchet_common_4.StringRatchet.trimToEmpty(this.cfg.pathSuffix);
+        ratchet_common_3.Logger.silly('S3EnvironmentServiceProvider:Request to read config from : %s / %s', this.cfg.bucketName, readPath);
+        const sw = new ratchet_common_2.StopWatch();
+        const rval = await this.ratchet.fetchCacheFileAsObject(readPath);
+        sw.log();
+        return rval;
+    }
+}
+exports.S3EnvironmentServiceProvider = S3EnvironmentServiceProvider;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SsmEnvironmentServiceProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const client_ssm_1 = require("@aws-sdk/client-ssm");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const ratchet_common_4 = require("@bitblit/ratchet-common");
+const ratchet_common_5 = require("@bitblit/ratchet-common");
+class SsmEnvironmentServiceProvider {
+    constructor(region = 'us-east-1', ssmEncrypted = true) {
+        this.region = region;
+        this.ssmEncrypted = ssmEncrypted;
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(region);
+        ratchet_common_3.RequireRatchet.notNullOrUndefined(ssmEncrypted);
+        this.ssm = new client_ssm_1.SSMClient({ region: this.region });
+    }
+    async fetchConfig(name) {
+        var _a;
+        ratchet_common_1.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 client_ssm_1.GetParameterCommand(params));
+            toParse = ratchet_common_5.StringRatchet.trimToNull((_a = value === null || value === void 0 ? void 0 : value.Parameter) === null || _a === void 0 ? void 0 : _a.Value);
+        }
+        catch (err) {
+            const errCode = err['code'] || '';
+            if (errCode.toLowerCase().indexOf('throttlingexception') !== -1) {
+                ratchet_common_1.Logger.warn('Throttled while trying to read parameters - waiting 1 second before allowing retry');
+                await ratchet_common_2.PromiseRatchet.wait(1000);
+            }
+            else if (errCode.toLowerCase().indexOf('parameternotfound') !== -1) {
+                const errMsg = ratchet_common_1.Logger.warn('AWS could not find parameter %s - are you using the right AWS key?', name);
+                throw new Error(errMsg);
+            }
+            else {
+                ratchet_common_1.Logger.error('Final environment fetch error (cannot retry) : %s', err, err);
+                throw err;
+            }
+        }
+        if (toParse) {
+            try {
+                rval = JSON.parse(toParse);
+            }
+            catch (err) {
+                ratchet_common_1.Logger.error('Failed to read env - null or invalid JSON : %s : %s', err, toParse, err);
+                throw err;
+            }
+        }
+        else {
+            ratchet_common_4.ErrorRatchet.throwFormattedErr('Could not find system parameter with name : %s in this account', name);
+        }
+        return rval;
+    }
+}
+exports.SsmEnvironmentServiceProvider = SsmEnvironmentServiceProvider;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoExpiringCodeProvider = void 0;
+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;
+    }
+}
+exports.DynamoExpiringCodeProvider = DynamoExpiringCodeProvider;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiringCodeRatchet = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+class ExpiringCodeRatchet {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    static generateCode(params) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(params, 'params');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(params.context, 'params.context');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(params.length, 'params.length');
+        ratchet_common_1.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(ratchet_common_2.StringRatchet.trimToEmpty(code), ratchet_common_2.StringRatchet.trimToEmpty(context), deleteOnMatch);
+        return rval;
+    }
+}
+exports.ExpiringCodeRatchet = ExpiringCodeRatchet;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3ExpiringCodeProvider = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class S3ExpiringCodeProvider {
+    constructor(s3CacheRatchet, keyName) {
+        this.s3CacheRatchet = s3CacheRatchet;
+        this.keyName = keyName;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(s3CacheRatchet, 's3CacheRatchet');
+        ratchet_common_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(s3CacheRatchet.getDefaultBucket(), 's3CacheRatchet.defaultBucket');
+        ratchet_common_1.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());
+        ratchet_common_1.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) => { var _a, _b; return ((_a = d === null || d === void 0 ? void 0 : d.code) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === (code === null || code === void 0 ? void 0 : code.toUpperCase()) && ((_b = d === null || d === void 0 ? void 0 : d.context) === null || _b === void 0 ? void 0 : _b.toUpperCase()) === (context === null || context === void 0 ? void 0 : context.toUpperCase()); });
+        if (rval) {
+            if (deleteOnMatch || rval.expiresEpochMS < Date.now()) {
+                ratchet_common_1.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;
+    }
+}
+exports.S3ExpiringCodeProvider = S3ExpiringCodeProvider;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsCredentialsRatchet = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class AwsCredentialsRatchet {
+    constructor() { }
+    static applySetProfileEnvironmentalVariable(newProfile) {
+        if (!!process.env) {
+            if (ratchet_common_1.StringRatchet.trimToNull(newProfile)) {
+                process.env['AWS_PROFILE'] = newProfile;
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot set profile to null/empty string');
+            }
+        }
+        else {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot set profile - not in a node environment - process missing');
+        }
+    }
+}
+exports.AwsCredentialsRatchet = AwsCredentialsRatchet;