@bitblit/ratchet-aws 4.0.80-alpha

package/dist/es/index.js

@@ -0,0 +1,78 @@
+export * from './batch/aws-batch-background-processor';
+export * from './batch/aws-batch-ratchet';
+export * from './build/ratchet-aws-info';
+export * from './cache/dynamo-db-storage-provider';
+export * from './cache/s3-storage-provider';
+export * from './cache/simple-cache-object-wrapper';
+export * from './cache/simple-cache-read-options';
+export * from './cache/simple-cache-storage-provider';
+export * from './cache/simple-cache';
+export * from './cloudwatch/cloud-watch-log-group-ratchet';
+export * from './cloudwatch/cloud-watch-logs-ratchet';
+export * from './cloudwatch/cloud-watch-metrics-ratchet';
+export * from './daemon/daemon-like';
+export * from './daemon/daemon-process-create-options';
+export * from './daemon/daemon-process-state-public-token';
+export * from './daemon/daemon-process-state';
+export * from './daemon/daemon-util';
+export * from './daemon/daemon';
+export * from './dao/prototype-dao-config';
+export * from './dao/prototype-dao-db';
+export * from './dao/prototype-dao-provider';
+export * from './dao/prototype-dao';
+export * from './dao/s3-prototype-dao-provider';
+export * from './dao/s3-simple-dao';
+export * from './dao/simple-dao-item';
+export * from './dynamodb/dynamo-ratchet-like';
+export * from './dynamodb/dynamo-ratchet';
+export * from './dynamodb/dynamo-table-ratchet';
+export * from './dynamodb/hash-spreader';
+export * from './ec2/ec2-ratchet';
+export * from './environment/cascade-environment-service-provider';
+export * from './environment/env-var-environment-service-provider';
+export * from './environment/environment-service-config';
+export * from './environment/environment-service-provider';
+export * from './environment/environment-service';
+export * from './environment/fixed-environment-service-provider';
+export * from './environment/s3-environment-service-provider';
+export * from './environment/ssm-environment-service-provider';
+export * from './expiring-code/dynamo-expiring-code-provider';
+export * from './expiring-code/expiring-code-params';
+export * from './expiring-code/expiring-code-provider';
+export * from './expiring-code/expiring-code-ratchet';
+export * from './expiring-code/expiring-code';
+export * from './expiring-code/s3-expiring-code-provider';
+export * from './iam/aws-credentials-ratchet';
+export * from './lambda/lambda-event-detector';
+export * from './lambda/lambda-event-type-guards';
+export * from './model/cloud-watch-metrics-minute-level-dynamo-count-request';
+export * from './model/cloud-watch-metrics-unit';
+export * from './model/dynamo-count-result';
+export * from './model/dynamo/doc-put-item-command-input';
+export * from './model/dynamo/doc-query-command-input';
+export * from './model/dynamo/doc-scan-command-input';
+export * from './model/dynamo/doc-update-item-command-input';
+export * from './route53/route-53-ratchet';
+export * from './runtime-parameter/cached-stored-runtime-parameter';
+export * from './runtime-parameter/dynamo-runtime-parameter-provider';
+export * from './runtime-parameter/global-variable-override-runtime-parameter-provider';
+export * from './runtime-parameter/memory-runtime-parameter-provider';
+export * from './runtime-parameter/runtime-parameter-provider';
+export * from './runtime-parameter/runtime-parameter-ratchet';
+export * from './runtime-parameter/stored-runtime-parameter';
+export * from './s3/s3-cache-ratchet';
+export * from './s3/s3-cache-to-local-disk-ratchet';
+export * from './s3/s3-location-sync-ratchet';
+export * from './s3/s3-ratchet';
+export * from './ses/email-attachment';
+export * from './ses/mailer-config';
+export * from './ses/mailer-like';
+export * from './ses/mailer';
+export * from './ses/ratchet-template-renderer';
+export * from './ses/ready-to-send-email';
+export * from './ses/remote-handlebars-template-renderer';
+export * from './ses/resolved-ready-to-send-email';
+export * from './sns/sns-ratchet';
+export * from './sync-lock/dynamo-db-sync-lock';
+export * from './sync-lock/memory-sync-lock';
+export * from './sync-lock/sync-lock-provider';

package/dist/es/lambda/lambda-event-detector.js

@@ -0,0 +1,38 @@
+export class LambdaEventDetector {
+    static isValidCronEvent(event) {
+        return event && event.source == 'aws.events' && event.resources && event.resources.length > 0;
+    }
+    static isValidSnsEvent(event) {
+        return event && event.Records && event.Records.length > 0 && event.Records[0].EventSource == 'aws:sns';
+    }
+    static isValidDynamoDBEvent(event) {
+        return event && event.Records && event.Records.length > 0 && event.Records[0].eventSource == 'aws:dynamodb';
+    }
+    static isValidS3Event(event) {
+        return event && event.Records && event.Records.length > 0 && event.Records[0].eventSource == 'aws:s3';
+    }
+    static isValidApiGatewayV2WithRequestContextEvent(event) {
+        return event && event.rawPath && event.requestContext && event.routeKey;
+    }
+    static isValidApiGatewayEvent(event) {
+        return event && event.httpMethod && event.path && event.requestContext;
+    }
+    static isValidApiGatewayAuthorizerEvent(event) {
+        return event && event.authorizationToken && event.methodArn;
+    }
+    static isSingleCronEvent(event) {
+        return this.isValidCronEvent(event) && LambdaEventDetector.isSingleEntryEvent(event, 'resources');
+    }
+    static isSingleSnsEvent(event) {
+        return this.isValidSnsEvent(event) && LambdaEventDetector.isSingleEntryEvent(event);
+    }
+    static isSingleDynamoDBEvent(event) {
+        return this.isValidDynamoDBEvent(event) && LambdaEventDetector.isSingleEntryEvent(event);
+    }
+    static isSingleS3Event(event) {
+        return this.isValidS3Event(event) && LambdaEventDetector.isSingleEntryEvent(event);
+    }
+    static isSingleEntryEvent(event, entryName = 'Records') {
+        return event && event[entryName] && event[entryName] instanceof Array && event[entryName].length === 1;
+    }
+}

package/dist/es/lambda/lambda-event-type-guards.js

@@ -0,0 +1,24 @@
+import { LambdaEventDetector } from './lambda-event-detector';
+export class LambdaEventTypeGuards {
+    static isValidCronEvent(event) {
+        return LambdaEventDetector.isValidCronEvent(event);
+    }
+    static isValidSnsEvent(event) {
+        return LambdaEventDetector.isValidSnsEvent(event);
+    }
+    static isValidDynamoDBEvent(event) {
+        return LambdaEventDetector.isValidDynamoDBEvent(event);
+    }
+    static isValidS3Event(event) {
+        return LambdaEventDetector.isValidS3Event(event);
+    }
+    static isValidApiGatewayV2WithRequestContextEvent(event) {
+        return LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(event);
+    }
+    static isValidApiGatewayEvent(event) {
+        return LambdaEventDetector.isValidApiGatewayEvent(event);
+    }
+    static isValidApiGatewayAuthorizerEvent(event) {
+        return LambdaEventDetector.isValidApiGatewayAuthorizerEvent(event);
+    }
+}

package/dist/es/model/cloud-watch-metrics-minute-level-dynamo-count-request.js

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

package/dist/es/model/cloud-watch-metrics-unit.js

@@ -0,0 +1,30 @@
+export var CloudWatchMetricsUnit;
+(function (CloudWatchMetricsUnit) {
+    CloudWatchMetricsUnit["Seconds"] = "Seconds";
+    CloudWatchMetricsUnit["Microseconds"] = "Microseconds";
+    CloudWatchMetricsUnit["Milliseconds"] = "Milliseconds";
+    CloudWatchMetricsUnit["Bytes"] = "Bytes";
+    CloudWatchMetricsUnit["Kilobytes"] = "Kilobytes";
+    CloudWatchMetricsUnit["Megabytes"] = "Megabytes";
+    CloudWatchMetricsUnit["Gigabytes"] = "Gigabytes";
+    CloudWatchMetricsUnit["Terabytes"] = "Terabytes";
+    CloudWatchMetricsUnit["Bits"] = "Bits";
+    CloudWatchMetricsUnit["Kilobits"] = "Kilobits";
+    CloudWatchMetricsUnit["Megabits"] = "Megabits";
+    CloudWatchMetricsUnit["Gigabits"] = "Gigabits";
+    CloudWatchMetricsUnit["Terabits"] = "Terabits";
+    CloudWatchMetricsUnit["Percent"] = "Percent";
+    CloudWatchMetricsUnit["Count"] = "Count";
+    CloudWatchMetricsUnit["BytesPerSecond"] = "Bytes/Second";
+    CloudWatchMetricsUnit["KilobytesPerSecond"] = "Kilobytes/Second";
+    CloudWatchMetricsUnit["MegabytesPerSecond"] = "Megabytes/Second";
+    CloudWatchMetricsUnit["GigabytesPerSecond"] = "Gigabytes/Second";
+    CloudWatchMetricsUnit["TerabytesPerSecond"] = "Terabytes/Second";
+    CloudWatchMetricsUnit["BitsPerSecond"] = "Terabytes/Second";
+    CloudWatchMetricsUnit["KilobitsPerSecond"] = "Kilobits/Second";
+    CloudWatchMetricsUnit["MegabitsPerSecond"] = "Megabits/Second";
+    CloudWatchMetricsUnit["GigabitsPerSecond"] = "Gigabits/Second";
+    CloudWatchMetricsUnit["TerabitsPerSecond"] = "Terabits/Second";
+    CloudWatchMetricsUnit["CountPerSecond"] = "Count/Second";
+    CloudWatchMetricsUnit["None"] = "None";
+})(CloudWatchMetricsUnit || (CloudWatchMetricsUnit = {}));

package/dist/es/model/dynamo/doc-put-item-command-input.js

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

package/dist/es/model/dynamo/doc-query-command-input.js

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

package/dist/es/model/dynamo/doc-scan-command-input.js

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

package/dist/es/model/dynamo/doc-update-item-command-input.js

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

package/dist/es/model/dynamo-count-result.js

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

package/dist/es/route53/route-53-ratchet.js

@@ -0,0 +1,53 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { ChangeResourceRecordSetsCommand, waitUntilResourceRecordSetsChanged, } from '@aws-sdk/client-route-53';
+import { WaiterState } from '@aws-sdk/util-waiter';
+export class Route53Ratchet {
+    constructor(route53, hostedZoneId) {
+        this.route53 = route53;
+        this.hostedZoneId = hostedZoneId;
+        if (!this.route53) {
+            throw 'route53 may not be null';
+        }
+    }
+    async changeCnameRecordTarget(domainName, target, hostedZoneId = this.hostedZoneId, ttlSeconds = 600) {
+        Logger.info('Updating %s to point to %s', domainName, target);
+        try {
+            const params = {
+                ChangeBatch: {
+                    Changes: [
+                        {
+                            Action: 'UPSERT',
+                            ResourceRecordSet: {
+                                Name: domainName,
+                                ResourceRecords: [
+                                    {
+                                        Value: target,
+                                    },
+                                ],
+                                TTL: ttlSeconds,
+                                Type: 'CNAME',
+                            },
+                        },
+                    ],
+                },
+                HostedZoneId: hostedZoneId,
+            };
+            const result = await this.route53.send(new ChangeResourceRecordSetsCommand(params));
+            Logger.debug('Updated domain result: %j', result);
+            const waitParams = {
+                Id: result.ChangeInfo.Id,
+            };
+            const waitResult = await waitUntilResourceRecordSetsChanged({ client: this.route53, maxWaitTime: 300 }, waitParams);
+            Logger.debug('Wait responsed: %j', waitResult);
+            if (waitResult.state === WaiterState.SUCCESS) {
+                Logger.info('Updated %s to point to %s', domainName, hostedZoneId);
+                return true;
+            }
+        }
+        catch (err) {
+            Logger.warn('Error update CName for %s with value %s: %j', domainName, target, err);
+        }
+        Logger.info('Cannot update %s to point to %s', domainName, target);
+        return false;
+    }
+}

package/dist/es/runtime-parameter/cached-stored-runtime-parameter.js

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

package/dist/es/runtime-parameter/dynamo-runtime-parameter-provider.js

@@ -0,0 +1,34 @@
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger } from '@bitblit/ratchet-common';
+export class DynamoRuntimeParameterProvider {
+    constructor(dynamo, tableName) {
+        this.dynamo = dynamo;
+        this.tableName = tableName;
+        RequireRatchet.notNullOrUndefined(this.dynamo);
+        RequireRatchet.notNullOrUndefined(this.tableName);
+    }
+    async readParameter(groupId, paramKey) {
+        Logger.silly('Reading %s / %s from underlying db', groupId, paramKey);
+        const req = {
+            groupId: groupId,
+            paramKey: paramKey,
+        };
+        const rval = await this.dynamo.simpleGet(this.tableName, req);
+        return rval;
+    }
+    async readAllParametersForGroup(groupId) {
+        const qry = {
+            TableName: this.tableName,
+            KeyConditionExpression: 'groupId = :groupId',
+            ExpressionAttributeValues: {
+                ':groupId': groupId,
+            },
+        };
+        const all = await this.dynamo.fullyExecuteQuery(qry);
+        return all;
+    }
+    async writeParameter(toStore) {
+        const rval = await this.dynamo.simplePut(this.tableName, toStore);
+        return !!rval;
+    }
+}

package/dist/es/runtime-parameter/global-variable-override-runtime-parameter-provider.js

@@ -0,0 +1,49 @@
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { ErrorRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class GlobalVariableOverrideRuntimeParameterProvider {
+    constructor(wrapped, opts) {
+        this.wrapped = wrapped;
+        this.options = {
+            globalTTL: 1,
+            separator: '.',
+            prefix: 'RuntimeEnv-',
+            suffix: '',
+        };
+        RequireRatchet.notNullOrUndefined(this.wrapped, 'wrapped');
+        RequireRatchet.notNullOrUndefined(global?.process?.env, '"process" not found - this only runs in Node, not the browser');
+        if (opts) {
+            this.options = opts;
+        }
+        RequireRatchet.notNullOrUndefined(this.options.globalTTL, 'this.options.globalTTL');
+        RequireRatchet.notNullOrUndefined(this.options.separator, 'this.options.separator');
+        RequireRatchet.true(this.options.globalTTL > 0, 'this.options.globalTTL must be larger than 0');
+    }
+    generateName(groupId, paramKey) {
+        return (StringRatchet.trimToEmpty(this.options.prefix) +
+            groupId +
+            StringRatchet.trimToEmpty(this.options.separator) +
+            paramKey +
+            StringRatchet.trimToEmpty(this.options.suffix));
+    }
+    async readParameter(groupId, paramKey) {
+        const asString = StringRatchet.trimToNull(process.env[this.generateName(groupId, paramKey)]);
+        if (asString && !StringRatchet.canParseAsJson(asString)) {
+            ErrorRatchet.throwFormattedErr('Cannot parse ENV override (%s / %s) as JSON - did you forget the quotes on a string?', groupId, paramKey);
+        }
+        const rval = asString
+            ? {
+                groupId: groupId,
+                paramKey: paramKey,
+                paramValue: asString,
+                ttlSeconds: this.options.globalTTL,
+            }
+            : await this.wrapped.readParameter(groupId, paramKey);
+        return rval;
+    }
+    async readAllParametersForGroup(groupId) {
+        return this.wrapped.readAllParametersForGroup(groupId);
+    }
+    async writeParameter(toStore) {
+        return this.wrapped.writeParameter(toStore);
+    }
+}

package/dist/es/runtime-parameter/memory-runtime-parameter-provider.js

@@ -0,0 +1,26 @@
+import { Logger } from '@bitblit/ratchet-common';
+export class MemoryRuntimeParameterProvider {
+    constructor(data = Promise.resolve({})) {
+        this.data = data;
+    }
+    async readParameter(groupId, paramKey) {
+        Logger.silly('Reading %s / %s from underlying db', groupId, paramKey);
+        const d = await this.data;
+        return d[groupId + '::' + paramKey];
+    }
+    async readAllParametersForGroup(groupId) {
+        const d = await this.data;
+        const out = [];
+        Object.keys(d).forEach((k) => {
+            if (k.startsWith(groupId)) {
+                out.push(d[k]);
+            }
+        });
+        return out;
+    }
+    async writeParameter(toStore) {
+        const d = await this.data;
+        d[toStore.groupId + '::' + toStore.paramKey] = toStore;
+        return true;
+    }
+}

package/dist/es/runtime-parameter/runtime-parameter-provider.js

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

package/dist/es/runtime-parameter/runtime-parameter-ratchet.js

@@ -0,0 +1,70 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+export class RuntimeParameterRatchet {
+    constructor(provider) {
+        this.provider = provider;
+        this.cache = new Map();
+        RequireRatchet.notNullOrUndefined(this.provider);
+    }
+    async fetchParameter(groupId, paramKey, defaultValue = null, forceFreshRead = false) {
+        Logger.debug('Reading parameter %s / %s / Force : %s', groupId, paramKey, forceFreshRead);
+        const cached = this.cache.get(RuntimeParameterRatchet.toCacheStoreKey(groupId, paramKey));
+        let rval = null;
+        const now = new Date().getTime();
+        if (!forceFreshRead && !!cached) {
+            const oldest = !!cached.ttlSeconds ? now - cached.ttlSeconds * 1000 : 0;
+            if (cached.storedEpochMS > oldest) {
+                Logger.silly('Fetched %s / %s from cache', groupId, paramKey);
+                rval = JSON.parse(cached.paramValue);
+            }
+        }
+        if (!rval) {
+            const temp = await this.readUnderlyingEntry(groupId, paramKey);
+            if (!!temp) {
+                this.addToCache(temp);
+                rval = JSON.parse(temp.paramValue);
+            }
+        }
+        rval = rval || defaultValue;
+        return rval;
+    }
+    async fetchAllParametersForGroup(groupId) {
+        const all = await this.readUnderlyingEntries(groupId);
+        const rval = new Map();
+        all.forEach((t) => {
+            rval.set(t.paramKey, JSON.parse(t.paramValue));
+            this.addToCache(t);
+        });
+        return rval;
+    }
+    async readUnderlyingEntry(groupId, paramKey) {
+        return this.provider.readParameter(groupId, paramKey);
+    }
+    async readUnderlyingEntries(groupId) {
+        return this.provider.readAllParametersForGroup(groupId);
+    }
+    async storeParameter(groupId, paramKey, paramValue, ttlSeconds) {
+        const toStore = {
+            groupId: groupId,
+            paramKey: paramKey,
+            paramValue: JSON.stringify(paramValue),
+            ttlSeconds: ttlSeconds,
+        };
+        const wrote = await this.provider.writeParameter(toStore);
+        return this.provider.readParameter(groupId, paramKey);
+    }
+    static toCacheStoreKey(groupId, paramKey) {
+        return groupId + ':::' + paramKey;
+    }
+    addToCache(temp) {
+        if (!!temp) {
+            const now = new Date().getTime();
+            const toStore = Object.assign({ storedEpochMS: now }, temp);
+            this.cache.set(RuntimeParameterRatchet.toCacheStoreKey(temp.groupId, temp.paramKey), toStore);
+        }
+    }
+    clearCache() {
+        Logger.debug('Clearing runtime parameter cache');
+        this.cache = new Map();
+    }
+}

package/dist/es/runtime-parameter/stored-runtime-parameter.js

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