@bitblit/ratchet-aws 6.0.146-alpha → 6.0.147-alpha

package/src/ecr/used-image-finders/lambda-used-image-finder.ts

@@ -0,0 +1,51 @@
+import { UsedImageFinder } from '../used-image-finder.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import {
+  FunctionConfiguration,
+  GetFunctionCommand,
+  GetFunctionCommandOutput,
+  LambdaClient,
+  ListFunctionsCommand,
+  ListFunctionsCommandInput,
+} from '@aws-sdk/client-lambda';
+import { ListFunctionsResponse } from '@aws-sdk/client-lambda/dist-types/models';
+
+export class LambdaUsedImageFinder implements UsedImageFinder {
+  constructor(private lambda: LambdaClient) {
+    RequireRatchet.notNullOrUndefined(lambda, 'lambda');
+  }
+
+  public async findUsedImageUris(): Promise<string[]> {
+    const rval: Set<string> = new Set<string>();
+    const fns: FunctionConfiguration[] = await this.fetchFunctions();
+    Logger.info('Found %d functions', fns.length);
+    for (const fn of fns) {
+      //for (let i = 0; i < fns.length; i++) {
+      if (fn.PackageType === 'Image') {
+        const out: GetFunctionCommandOutput = await this.lambda.send(new GetFunctionCommand({ FunctionName: fn.FunctionName }));
+        if (out.Code.RepositoryType === 'ECR' && out.Code.ImageUri) {
+          rval.add(out.Code.ImageUri);
+        }
+      } else {
+        Logger.info('Skipping zip packaged function: %s', fn.FunctionName);
+      }
+    }
+    return Array.from(rval);
+  }
+
+  public async fetchFunctions(): Promise<FunctionConfiguration[]> {
+    let rval: any[] = [];
+    const cmd: ListFunctionsCommandInput = {};
+    let resp: ListFunctionsResponse = null;
+
+    do {
+      resp = await this.lambda.send(new ListFunctionsCommand(cmd));
+      rval = rval.concat(resp.Functions);
+      cmd.Marker = resp.NextMarker;
+    } while (StringRatchet.trimToNull(cmd.Marker));
+
+    return rval;
+  }
+}

package/src/environment/cascade-environment-service-provider.ts

@@ -0,0 +1,28 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+
+/**
+ * Reads a series of providers, returning the first non-null, non-error
+ */
+export class CascadeEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+  public constructor(private providers: EnvironmentServiceProvider<T>[]) {
+    RequireRatchet.notNullOrUndefined(providers);
+    RequireRatchet.true(providers.length > 0);
+  }
+
+  public async fetchConfig(name: string): Promise<T> {
+    Logger.silly('CascadeEnvironmentServiceProvider fetch for %s', name);
+    let rval: T = 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/src/environment/env-var-environment-service-provider.ts

@@ -0,0 +1,36 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+
+/**
+ * Service for reading environmental variables
+ * Also hides the decryption detail from higher up servicess
+ */
+export class EnvVarEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+  public constructor(private envVarName: string) {
+    RequireRatchet.notNullOrUndefined(envVarName);
+  }
+
+  public async fetchConfig(): Promise<T> {
+    Logger.silly('EnvVarEnvironmentServiceProvider fetch for %s', this.envVarName);
+
+    let rval: T = null;
+    const src: Record<string, any> = process ? process.env : global ? global : {};
+    const toParse: string = StringRatchet.trimToNull(src[this.envVarName]);
+
+    // If we reach here with a string result, try to parse it
+    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/src/environment/environment-service-config.ts

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

package/src/environment/environment-service-provider.ts

@@ -0,0 +1,7 @@
+/**
+ * Classes implementing EnvironmentServiceProvider offer the ability to fetch a configuration
+ * object from _somewhere_
+ */
+export interface EnvironmentServiceProvider<T> {
+  fetchConfig(name: string): Promise<T>;
+}

package/src/environment/environment-service.spec.ts

@@ -0,0 +1,41 @@
+import { EnvironmentService } from './environment-service.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { FixedEnvironmentServiceProvider } from './fixed-environment-service-provider.js';
+import { describe, expect, test } from 'vitest';
+
+const fixed: FixedEnvironmentServiceProvider<any> = FixedEnvironmentServiceProvider.fromRecord<any>({ a: 'b', c: 5 });
+
+describe('#environmentService', function () {
+  test('should throw exception on missing environment values', async () => {
+    try {
+      const es = new EnvironmentService<any>(fixed);
+      const _vals: any = 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);
+    }
+  });
+
+  test('should find a valid value', async () => {
+    const es = new EnvironmentService<any>(fixed);
+    const vals: any = await es.getConfig('c');
+    expect(vals).toBeTruthy();
+  });
+  /*
+  test.skip('should load config from s3', async () => {
+    Logger.setLevel(LoggerLevelName.silly);
+    const bucket: string = 'xxx';
+    const path: string = 'yyy';
+
+    const es: EnvironmentService<any> = new EnvironmentService<any>(
+      new S3EnvironmentServiceProvider({ bucketName: bucket, region: 'us-east-1' })
+    );
+    const vals: any = await es.getConfig(path);
+    const vals1: any = await es.getConfig(path);
+    const vals2: any = await es.getConfig(path);
+    expect(vals).toBeTruthy();
+  });
+  
+ */
+});

package/src/environment/environment-service.ts

@@ -0,0 +1,89 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+import { EnvironmentServiceConfig } from './environment-service-config.js';
+
+/**
+ * Wraps up a EnvironmentServiceProvider and provides caching and retry-on-failure logic
+ */
+export class EnvironmentService<T> {
+  private readPromiseCache = new Map<string, Promise<any>>();
+
+  public static defaultEnvironmentServiceConfig(): EnvironmentServiceConfig {
+    const rval: EnvironmentServiceConfig = {
+      maxRetries: 3,
+      backoffMultiplierMS: 500,
+    };
+    return rval;
+  }
+
+  constructor(
+    private provider: EnvironmentServiceProvider<T>,
+    private cfg: EnvironmentServiceConfig = EnvironmentService.defaultEnvironmentServiceConfig(),
+  ) {
+    RequireRatchet.notNullOrUndefined(provider);
+    RequireRatchet.notNullOrUndefined(cfg);
+  }
+
+  public async getConfig(name: string): Promise<T> {
+    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);
+  }
+
+  public async fetchConfigValueByPath<T>(cfgName: string, path: string[]): Promise<T> {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(cfgName);
+    RequireRatchet.notNullUndefinedOrEmptyArray(path);
+
+    const env: any = await this.getConfig(cfgName);
+    if (!env) {
+      throw ErrorRatchet.fErr('No config found with name ', cfgName);
+    }
+    let rval: any = env;
+    for (const p of path) {
+      rval = rval ? rval[p] : null;
+    }
+    if (!rval) {
+      throw ErrorRatchet.fErr('No value found in %s for path %s', cfgName, path);
+    }
+    return rval;
+  }
+
+  private async getConfigUncached(name: string): Promise<T> {
+    let tryCount: number = 1;
+    let rval: T = 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: number = 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/src/environment/fixed-environment-service-provider.ts

@@ -0,0 +1,26 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+
+/**
+ * Forces in a single object as the environment
+ */
+export class FixedEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+  public constructor(private value: Map<string, T>) {
+    RequireRatchet.notNullOrUndefined(value);
+  }
+
+  public static fromRecord<T>(record: Record<string, T>): FixedEnvironmentServiceProvider<T> {
+    const m: Map<string, T> = new Map<string, T>();
+    Object.keys(record).forEach((k) => {
+      m.set(k, record[k]);
+    });
+    return new FixedEnvironmentServiceProvider<T>(m);
+  }
+
+  public async fetchConfig(name: string): Promise<T> {
+    Logger.silly('FixedEnvironmentServiceProvider fetch for %s', name);
+    const rval: T = this.value.get(name);
+    return rval;
+  }
+}

package/src/environment/ssm-environment-service-provider.spec.ts

@@ -0,0 +1,18 @@
+import { EnvironmentService } from './environment-service.js';
+import { describe, expect, test } from 'vitest';
+import { SsmEnvironmentServiceProvider } from './ssm-environment-service-provider.js';
+import { AwsCredentialsRatchet } from '../iam/aws-credentials-ratchet';
+
+describe('#ssmEnvironmentService', function () {
+  test.skip('should throw exception on missing environment values', async () => {
+    const profile: string = 'profile'; //pluma';
+    const config: string = 'Configuration'; //Pluma
+    AwsCredentialsRatchet.applySetProfileEnvironmentalVariable(profile);
+    const environmentService: EnvironmentService<any> = new EnvironmentService<any>(new SsmEnvironmentServiceProvider(), {
+      maxRetries: 5,
+      backoffMultiplierMS: 500,
+    });
+    const cfg: any = await environmentService.getConfig(config);
+    expect(cfg).not.toBeNull;
+  });
+});

package/src/environment/ssm-environment-service-provider.ts

@@ -0,0 +1,71 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { GetParameterCommand, GetParameterCommandOutput, ParameterNotFound, SSMClient } from '@aws-sdk/client-ssm';
+import { EnvironmentServiceProvider } from './environment-service-provider.js';
+
+/**
+ * Service for reading environmental variables
+ * Also hides the decryption detail from higher up services
+ */
+export class SsmEnvironmentServiceProvider<T> implements EnvironmentServiceProvider<T> {
+  private ssm: SSMClient;
+  public constructor(
+    private region = 'us-east-1',
+    private ssmEncrypted = true,
+  ) {
+    RequireRatchet.notNullOrUndefined(region);
+    RequireRatchet.notNullOrUndefined(ssmEncrypted);
+    this.ssm = new SSMClient({ region: this.region });
+  }
+
+  public async fetchConfig(name: string): Promise<T> {
+    Logger.silly('SsmEnvironmentServiceProvider fetch for %s', name);
+    const params = {
+      Name: name /* required */,
+      WithDecryption: this.ssmEncrypted,
+    };
+
+    let rval: T = null;
+    let toParse: string = null;
+    try {
+      const value: GetParameterCommandOutput = await this.ssm.send(new GetParameterCommand(params));
+      toParse = StringRatchet.trimToNull(value?.Parameter?.Value);
+    } catch (err) {
+      if (err instanceof ParameterNotFound) {
+        const errMsg: string = Logger.warn('AWS could not find parameter %s in region %s - are you using the right AWS key?', name, this.region
+
+        );
+        throw new Error(errMsg);
+      } else if (err.name === 'CredentialsProviderError') {
+        Logger.warn('Token is expired - if on SSO cli try "aws sso login"');
+        throw err;
+      } else if ((ErrorRatchet.safeStringifyErr(err) || '').toLowerCase().indexOf('throttl') > -1) {
+        // CAW 2023-10-26 : Ok, so in AWS Sdk v3 there is no ThrottlingException for SSM (although there
+        // are for other services like Route53...) so maybe they just don't throw this any more but that
+        // seems unlikely so I'm putting this in just as belt-and-suspenders... if they really never throttle
+        // any more then this will just never get called
+        Logger.warn('Throttled while trying to read parameters - waiting 1 second before allowing retry');
+        await PromiseRatchet.wait(1_000);
+      } else {
+        Logger.error('Final environment fetch error (cannot retry) : %s', err, err);
+        throw err;
+      }
+    }
+
+    // If we reach here with a string result, try to parse it
+    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 {
+      throw ErrorRatchet.fErr('Could not find system parameter with name : %s in this account', name);
+    }
+    return rval;
+  }
+}

package/src/expiring-code/expiring-code-params.ts

@@ -0,0 +1,7 @@
+export interface ExpiringCodeParams {
+  context: string;
+  timeToLiveSeconds: number;
+  tags?: string[];
+  length: number;
+  alphabet: string;
+}

package/src/expiring-code/expiring-code-provider.ts

@@ -0,0 +1,6 @@
+import { ExpiringCode } from './expiring-code.js';
+
+export interface ExpiringCodeProvider {
+  storeCode(code: ExpiringCode): Promise<boolean>;
+  checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean>;
+}

package/src/expiring-code/expiring-code-ratchet.spec.ts

@@ -0,0 +1,10 @@
+import { ExpiringCodeRatchet } from './expiring-code-ratchet.js';
+import { ExpiringCode } from './expiring-code.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#ExpiringCodeRatchet', () => {
+  test('Should generate valid codes', async () => {
+    const output: ExpiringCode = ExpiringCodeRatchet.generateCode({ context: 'test', length: 5, timeToLiveSeconds: 10, alphabet: 'A' });
+    expect(output.code).toEqual('AAAAA');
+  });
+});

package/src/expiring-code/expiring-code-ratchet.ts

@@ -0,0 +1,44 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { ExpiringCodeProvider } from './expiring-code-provider.js';
+import { ExpiringCodeParams } from './expiring-code-params.js';
+import { ExpiringCode } from './expiring-code.js';
+
+/**
+ * Supports creating and checking single use codes
+ */
+export class ExpiringCodeRatchet {
+  constructor(private provider: ExpiringCodeProvider) {}
+
+  public static generateCode(params: ExpiringCodeParams): ExpiringCode {
+    RequireRatchet.notNullOrUndefined(params, 'params');
+    RequireRatchet.notNullOrUndefined(params.context, 'params.context');
+    RequireRatchet.notNullOrUndefined(params.length, 'params.length');
+    RequireRatchet.notNullOrUndefined(params.alphabet, 'params.alphabet');
+
+    let code: string = '';
+
+    while (code.length < params.length) {
+      code += params.alphabet.charAt(Math.floor(params.alphabet.length * Math.random()));
+    }
+
+    const rval: ExpiringCode = {
+      code: code,
+      context: params.context,
+      tags: params.tags,
+      expiresEpochMS: Date.now() + params.timeToLiveSeconds * 1000,
+    };
+    return rval;
+  }
+
+  public async createNewCode(params: ExpiringCodeParams): Promise<ExpiringCode> {
+    const value: ExpiringCode = ExpiringCodeRatchet.generateCode(params);
+    const rval: boolean = await this.provider.storeCode(value);
+    return rval ? value : null;
+  }
+
+  public async checkCode(code: string, context: string, deleteOnMatch?: boolean): Promise<boolean> {
+    const rval: boolean = await this.provider.checkCode(StringRatchet.trimToEmpty(code), StringRatchet.trimToEmpty(context), deleteOnMatch);
+    return rval;
+  }
+}

package/src/expiring-code/expiring-code.ts

@@ -0,0 +1,6 @@
+export interface ExpiringCode {
+  code: string;
+  context: string;
+  expiresEpochMS: number;
+  tags?: string[];
+}

package/src/iam/aws-credentials-ratchet.ts

@@ -0,0 +1,25 @@
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+/**
+ * Ratchet for manipulating credentials
+ *
+ * Mainly here so I don't have to remember certain specific AWS environmental variable names
+ */
+export class AwsCredentialsRatchet {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static applySetProfileEnvironmentalVariable(newProfile: string): void {
+    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');
+    }
+  }
+}

package/src/lambda/lambda-event-detector.ts

@@ -0,0 +1,55 @@
+// Simple switch to see what kind of event I am looking at
+
+export class LambdaEventDetector {
+  public static isValidCronEvent(event: any): boolean {
+    return event && event.source == 'aws.events' && event.resources && event.resources.length > 0;
+  }
+
+  public static isValidSnsEvent(event: any): boolean {
+    return event && event.Records && event.Records.length > 0 && event.Records[0].EventSource == 'aws:sns';
+  }
+
+  public static isValidSqsEvent(event: any): boolean {
+    return event && event.Records && event.Records.length > 0 && event.Records[0].eventSource == 'aws:sqs';
+  }
+
+  public static isValidDynamoDBEvent(event: any): boolean {
+    return event && event.Records && event.Records.length > 0 && event.Records[0].eventSource == 'aws:dynamodb';
+  }
+
+  public static isValidS3Event(event: any): boolean {
+    return event && event.Records && event.Records.length > 0 && event.Records[0].eventSource == 'aws:s3';
+  }
+
+  public static isValidApiGatewayV2WithRequestContextEvent(event: any): boolean {
+    return event && event.rawPath && event.requestContext && event.routeKey;
+  }
+
+  public static isValidApiGatewayEvent(event: any): boolean {
+    return event && event.httpMethod && event.path && event.requestContext;
+  }
+
+  public static isValidApiGatewayAuthorizerEvent(event: any): boolean {
+    return event && event.authorizationToken && event.methodArn;
+  }
+
+  public static isSingleCronEvent(event: any): boolean {
+    return this.isValidCronEvent(event) && LambdaEventDetector.isSingleEntryEvent(event, 'resources');
+  }
+
+  public static isSingleSnsEvent(event: any): boolean {
+    return this.isValidSnsEvent(event) && LambdaEventDetector.isSingleEntryEvent(event);
+  }
+
+  public static isSingleDynamoDBEvent(event: any): boolean {
+    return this.isValidDynamoDBEvent(event) && LambdaEventDetector.isSingleEntryEvent(event);
+  }
+
+  public static isSingleS3Event(event: any): boolean {
+    return this.isValidS3Event(event) && LambdaEventDetector.isSingleEntryEvent(event);
+  }
+
+  public static isSingleEntryEvent(event: any, entryName: string = 'Records'): boolean {
+    return event && event[entryName] && event[entryName] instanceof Array && event[entryName].length === 1;
+  }
+}

package/src/lambda/lambda-event-type-guards.ts

@@ -0,0 +1,38 @@
+// Simple switch to see what kind of event I am looking at
+
+import { APIGatewayEvent, APIGatewayProxyEventV2, DynamoDBStreamEvent, S3Event, ScheduledEvent, SNSEvent, SQSEvent } from 'aws-lambda';
+import { LambdaEventDetector } from './lambda-event-detector.js';
+
+export class LambdaEventTypeGuards {
+  public static isValidCronEvent(event: any): event is ScheduledEvent {
+    return LambdaEventDetector.isValidCronEvent(event);
+  }
+
+  public static isValidSqsEvent(event: any): event is SQSEvent {
+    return LambdaEventDetector.isValidSqsEvent(event);
+  }
+
+  public static isValidSnsEvent(event: any): event is SNSEvent {
+    return LambdaEventDetector.isValidSnsEvent(event);
+  }
+
+  public static isValidDynamoDBEvent(event: any): event is DynamoDBStreamEvent {
+    return LambdaEventDetector.isValidDynamoDBEvent(event);
+  }
+
+  public static isValidS3Event(event: any): event is S3Event {
+    return LambdaEventDetector.isValidS3Event(event);
+  }
+
+  public static isValidApiGatewayV2WithRequestContextEvent(event: any): event is APIGatewayProxyEventV2 {
+    return LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(event);
+  }
+
+  public static isValidApiGatewayEvent(event: any): event is APIGatewayEvent {
+    return LambdaEventDetector.isValidApiGatewayEvent(event);
+  }
+
+  public static isValidApiGatewayAuthorizerEvent(event: any): boolean {
+    return LambdaEventDetector.isValidApiGatewayAuthorizerEvent(event);
+  }
+}

package/src/model/cloud-watch-metrics-minute-level-dynamo-count-request.ts

@@ -0,0 +1,18 @@
+/*
+    Service for interacting with cloudwatch
+*/
+
+import { KeyValue } from '@bitblit/ratchet-common/lang/key-value';
+import { DynamoRatchet } from '../dynamodb/dynamo-ratchet.js';
+import { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
+
+export interface CloudWatchMetricsMinuteLevelDynamoCountRequest {
+  dynamoRatchet: DynamoRatchet;
+  query: QueryCommandInput;
+  scan: ScanCommandInput;
+
+  minuteUTC: string; // Format yyyy-MM-dd HH:mm
+  namespace: string;
+  metric: string;
+  dims: KeyValue<any>[];
+}

package/src/model/dynamo-count-result.ts

@@ -0,0 +1,8 @@
+/*
+Strong typing for results from dynamo db count queries
+ */
+export interface DynamoCountResult {
+  count: number;
+  scannedCount: number;
+  pages: number;
+}