@digitraffic/common 2022.11.22-1 → 2022.11.23-2

package/src/aws/infra/api/response.ts

@@ -1,5 +1,12 @@
-import apigateway = require('aws-cdk-lib/aws-apigateway');
-import {MediaType} from "../../types/mediatypes";
+import { MediaType } from "../../types/mediatypes";
+import {
+    JsonSchemaType,
+    JsonSchemaVersion,
+    JsonSchema,
+    MethodResponse,
+    Model,
+} from "aws-cdk-lib/aws-apigateway";
+import { IModel } from "aws-cdk-lib/aws-apigateway/lib/model";
 
 /**
  * This is velocity-script, that assumes the response to be LambdaResponse(status and body).
@@ -23,45 +30,119 @@ $inputRoot.body
 
 const BODY_FROM_INPUT_PATH = "$input.path('$').body";
 
-// DEPRECATED
-const messageSchema: apigateway.JsonSchema = {
-    schema: apigateway.JsonSchemaVersion.DRAFT4,
-    type: apigateway.JsonSchemaType.OBJECT,
-    description: 'Response with message',
+/// @deprecated
+const messageSchema: JsonSchema = {
+    schema: JsonSchemaVersion.DRAFT4,
+    type: JsonSchemaType.OBJECT,
+    description: "Response with message",
     properties: {
         message: {
-            type: apigateway.JsonSchemaType.STRING,
-            description: 'Response message',
+            type: JsonSchemaType.STRING,
+            description: "Response message",
         },
     },
 };
 
-// DEPRECATED
+/// @deprecated
 export const MessageModel = {
     contentType: MediaType.APPLICATION_JSON,
-    modelName: 'MessageResponseModel',
+    modelName: "MessageResponseModel",
     schema: messageSchema,
 };
 
-const NotFoundMessage = 'Not found';
-export const NotFoundResponse = JSON.stringify({message: NotFoundMessage});
+const NotFoundMessage = "Not found";
+export const NotFoundResponse = JSON.stringify({ message: NotFoundMessage });
 
-const InternalServerErrorMessage = 'Error';
-const InternalServerErrorResponse = JSON.stringify({message: InternalServerErrorMessage});
+const InternalServerErrorMessage = "Error";
+const InternalServerErrorResponse = JSON.stringify({
+    message: InternalServerErrorMessage,
+});
 
-const BadRequestMessage = 'Bad request';
-const BadRequestResponse = JSON.stringify({message: BadRequestMessage});
+const BadRequestMessage = "Bad request";
+const BadRequestResponse = JSON.stringify({ message: BadRequestMessage });
 
-export const BadRequestResponseTemplate = createResponses(MediaType.APPLICATION_JSON, BadRequestResponse);
-export const NotFoundResponseTemplate = createResponses(MediaType.APPLICATION_JSON, NotFoundResponse);
-export const XmlResponseTemplate = createResponses(MediaType.APPLICATION_XML, BODY_FROM_INPUT_PATH);
-export const SvgResponseTemplate = createResponses(MediaType.IMAGE_SVG, BODY_FROM_INPUT_PATH);
-export const InternalServerErrorResponseTemplate = createResponses(MediaType.APPLICATION_JSON, InternalServerErrorResponse);
+/// @deprecated
+export const BadRequestResponseTemplate = createResponses(
+    MediaType.APPLICATION_JSON,
+    BadRequestResponse
+);
+/// @deprecated
+export const NotFoundResponseTemplate = createResponses(
+    MediaType.APPLICATION_JSON,
+    NotFoundResponse
+);
+/// @deprecated
+export const XmlResponseTemplate = createResponses(
+    MediaType.APPLICATION_XML,
+    BODY_FROM_INPUT_PATH
+);
+/// @deprecated
+export const InternalServerErrorResponseTemplate = createResponses(
+    MediaType.APPLICATION_JSON,
+    InternalServerErrorResponse
+);
 
-export function createResponses<T>(key: MediaType, value: T): Record<string, T> {
-    const map: Record<string, T> = {};
+/// @deprecated
+export function createResponses<T>(
+    key: MediaType,
+    value: T
+): Record<string, T> {
+    return {
+        [key]: value,
+    };
+}
+
+export class DigitrafficMethodResponse {
+    static response(
+        statusCode: string,
+        model: IModel,
+        mediaType: MediaType,
+        disableCors = false
+    ): MethodResponse {
+        return {
+            statusCode,
+            responseModels: {
+                [mediaType]: model,
+            },
+            responseParameters: disableCors
+                ? {}
+                : {
+                      "method.response.header.Access-Control-Allow-Origin":
+                          true,
+                  },
+        };
+    }
+
+    static response200(model: IModel, mediaType = MediaType.APPLICATION_JSON) {
+        return DigitrafficMethodResponse.response(
+            "200",
+            model,
+            mediaType,
+            false
+        );
+    }
 
-    map[key] = value;
+    static response500(
+        model = Model.EMPTY_MODEL,
+        mediaType = MediaType.APPLICATION_JSON
+    ) {
+        return DigitrafficMethodResponse.response(
+            "500",
+            model,
+            mediaType,
+            false
+        );
+    }
 
-    return map;
+    static response400(
+        model = Model.EMPTY_MODEL,
+        mediaType = MediaType.APPLICATION_JSON
+    ) {
+        return DigitrafficMethodResponse.response(
+            "400",
+            model,
+            mediaType,
+            false
+        );
+    }
 }

package/src/aws/infra/api/responses.ts

@@ -52,6 +52,9 @@ export const RESPONSE_404_NOT_FOUND = {
     responseTemplates: NotFoundResponseTemplate,
 };
 
+/**
+ * @deprecated Use DigitrafficMethodResponse
+ */
 export function methodResponse(
     status: string,
     contentType: MediaType,
@@ -65,6 +68,9 @@ export function methodResponse(
     };
 }
 
+/**
+ * @deprecated Use DigitrafficMethodResponse
+ */
 export function corsMethod(response: MethodResponse): MethodResponse {
     return {
         ...response,
@@ -89,6 +95,8 @@ interface IntegrationOptions {
  * Creates a default Lambda integration for a REST API resource _root_
  * @param lambdaFunction The Lambda function
  * @param options Options
+ *
+ * @deprecated Use DigitrafficIntegration
  */
 export function defaultIntegration(
     lambdaFunction: AWSFunction,

package/src/aws/infra/api/static-integration.ts

@@ -1,13 +1,17 @@
-import {MockIntegration, PassthroughBehavior, Resource} from "aws-cdk-lib/aws-apigateway";
-import {MediaType} from "../../types/mediatypes";
-import {corsMethod, RESPONSE_CORS_INTEGRATION} from "./responses";
+import {
+    MockIntegration,
+    PassthroughBehavior,
+    Resource,
+} from "aws-cdk-lib/aws-apigateway";
+import { MediaType } from "../../types/mediatypes";
+import { corsMethod, RESPONSE_CORS_INTEGRATION } from "./responses";
 
 const INTEGRATION_RESPONSE_200 = `{
     "statusCode": 200
 }`;
 
 const METHOD_RESPONSE_200 = {
-    statusCode: '200',
+    statusCode: "200",
 };
 
 /**
@@ -19,9 +23,18 @@ const METHOD_RESPONSE_200 = {
  */
 export class DigitrafficStaticIntegration extends MockIntegration {
     constructor(
-        resource: Resource, mediaType: MediaType, response: string, enableCors = true, apiKeyRequired = true,
+        resource: Resource,
+        mediaType: MediaType,
+        response: string,
+        enableCors = true,
+        apiKeyRequired = true
     ) {
-        const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse(response, mediaType, enableCors);
+        const integrationResponse =
+            DigitrafficStaticIntegration.createIntegrationResponse(
+                response,
+                mediaType,
+                enableCors
+            );
 
         super({
             passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES,
@@ -31,32 +44,53 @@ export class DigitrafficStaticIntegration extends MockIntegration {
             integrationResponses: [integrationResponse],
         });
 
-        ['GET', 'HEAD'].forEach((httpMethod) => {
+        ["GET", "HEAD"].forEach((httpMethod) => {
             resource.addMethod(httpMethod, this, {
                 apiKeyRequired,
-                methodResponses: [DigitrafficStaticIntegration.createMethodResponse(enableCors)],
+                methodResponses: [
+                    DigitrafficStaticIntegration.createMethodResponse(
+                        enableCors
+                    ),
+                ],
             });
         });
     }
 
-    static json<K>(resource: Resource, response: K, enableCors = true, apiKeyRequired = true) {
+    static json<K>(
+        resource: Resource,
+        response: K,
+        enableCors = true,
+        apiKeyRequired = true
+    ) {
         return new DigitrafficStaticIntegration(
-            resource, MediaType.APPLICATION_JSON, JSON.stringify(response), enableCors, apiKeyRequired,
+            resource,
+            MediaType.APPLICATION_JSON,
+            JSON.stringify(response),
+            enableCors,
+            apiKeyRequired
         );
     }
 
-    private static createIntegrationResponse(response: string, mediaType: MediaType, enableCors: boolean) {
+    private static createIntegrationResponse(
+        response: string,
+        mediaType: MediaType,
+        enableCors: boolean
+    ) {
         const integrationResponse = {
-            statusCode: '200',
+            statusCode: "200",
             responseTemplates: {
                 [mediaType]: response,
             },
         };
 
-        return enableCors ? {...integrationResponse, ...RESPONSE_CORS_INTEGRATION} : integrationResponse;
+        return enableCors
+            ? { ...integrationResponse, ...RESPONSE_CORS_INTEGRATION }
+            : integrationResponse;
     }
 
     private static createMethodResponse(enableCors: boolean) {
-        return enableCors ? corsMethod(METHOD_RESPONSE_200) : METHOD_RESPONSE_200;
+        return enableCors
+            ? corsMethod(METHOD_RESPONSE_200)
+            : METHOD_RESPONSE_200;
     }
 }

package/src/aws/runtime/secrets/dbsecret.ts

@@ -1,24 +1,18 @@
-import { GenericSecret, withSecret, withSecretAndPrefix } from "./secret";
+import {withSecret, withSecretAndPrefix} from "./secret";
 
 export type DbSecret = {
-    readonly username: string;
-    readonly password: string;
-    readonly host: string;
-    readonly ro_host: string;
+    readonly username: string
+    readonly password: string
+    readonly host: string
+    readonly ro_host: string
 };
 
 export enum RdsProxySecretKey {
-    username = "username",
-    password = "password",
-    proxy_host = "proxy_host",
-    proxy_ro_host = "proxy_ro_host",
+    username = "username", password = "password", proxy_host = "proxy_host", proxy_ro_host = "proxy_ro_host"
 }
 
 export enum RdsSecretKey {
-    username = "username",
-    password = "password",
-    host = "host",
-    ro_host = "ro_host",
+    username = "username", password = "password", host = "host", ro_host = "ro_host"
 }
 
 export type RdsProxySecret = Record<RdsProxySecretKey, string>;
@@ -43,7 +37,7 @@ function setDbSecret(secret: DbSecret) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let cachedSecret: any;
 
-const missingSecretErrorText = "Missing or empty secretId";
+const missingSecretErrorText = 'Missing or empty secretId';
 
 /**
  * You can give the following options for retrieving a secret:
@@ -54,22 +48,13 @@ const missingSecretErrorText = "Missing or empty secretId";
 
  */
 export type SecretOptions = {
-    readonly expectedKeys?: string[];
-    readonly prefix?: string;
-};
+    readonly expectedKeys?: string[],
+    readonly prefix?: string
+}
 
-export type SecretToPromiseFunction<Secret, Response = void> = (
-    secret: Secret
-) => Promise<Response> | void;
-export type SecretFunction<Secret, Response = void> = (
-    secretId: string,
-    fn: SecretToPromiseFunction<Secret, Response>,
-    options?: SecretOptions
-) => Promise<Response | void>;
-export type EmptySecretFunction<Response = void> = SecretFunction<
-    DbSecret,
-    Response
->;
+export type SecretToPromiseFunction<Secret, Response = void> = (secret: Secret) => Promise<Response> | void;
+export type SecretFunction<Secret, Response = void> = (secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions) => Promise<Response | void>;
+export type EmptySecretFunction<Response = void> = SecretFunction<DbSecret, Response>;
 
 /**
  * Run the given function with secret retrieved from Secrets Manager.  Also injects database-credentials into environment.
@@ -81,11 +66,7 @@ export type EmptySecretFunction<Response = void> = SecretFunction<
  * @param {function} fn
  * @param {SecretOptions} options
  */
-export async function withDbSecret<Secret, Response>(
-    secretId: string,
-    fn: SecretToPromiseFunction<Secret, Response>,
-    options?: SecretOptions
-): Promise<Response | void> {
+export async function withDbSecret<Secret, Response>(secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions): Promise<Response | void> {
     if (!secretId) {
         console.error(missingSecretErrorText);
         return Promise.reject(missingSecretErrorText);
@@ -100,13 +81,9 @@ export async function withDbSecret<Secret, Response>(
             });
 
             // then actual secret
-            await withSecretAndPrefix(
-                secretId,
-                options.prefix,
-                (fetchedSecret: Secret) => {
-                    cachedSecret = fetchedSecret;
-                }
-            );
+            await withSecretAndPrefix(secretId, options.prefix, (fetchedSecret: Secret) => {
+                cachedSecret = fetchedSecret;
+            });
         } else {
             await withSecret(secretId, (fetchedSecret: DbSecret) => {
                 setDbSecret(fetchedSecret);
@@ -120,10 +97,7 @@ export async function withDbSecret<Secret, Response>(
         }
         return fn(cachedSecret);
     } catch (error) {
-        console.error(
-            "method=withDbSecret Caught an error, refreshing secret",
-            error
-        );
+        console.error('method=withDbSecret Caught an error, refreshing secret', error);
         // try to refetch secret in case it has changed
         await withSecret(secretId, (fetchedSecret: DbSecret) => {
             setDbSecret(fetchedSecret);
@@ -133,15 +107,10 @@ export async function withDbSecret<Secret, Response>(
     }
 }
 
-export function checkExpectedSecretKeys<Secret extends GenericSecret>(
-    keys: string[],
-    secret: Secret
-) {
-    const missingKeys = keys.filter((key) => !(key in secret));
+export function checkExpectedSecretKeys<Secret>(keys: string[], secret: Secret) {
+    const missingKeys = keys.filter(key => !(key in secret));
     if (missingKeys.length) {
-        console.error(
-            `method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys}`
-        );
-        throw new Error("Expected keys were not found");
+        console.error(`method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys}`);
+        throw new Error('Expected keys were not found');
     }
 }

package/src/aws/runtime/secrets/secret-holder.ts

@@ -23,7 +23,7 @@ const DEFAULT_CONFIGURATION = {
  *
  * Supports setting the database environment paramaters from the secret too.
  */
-export class SecretHolder<Secret extends GenericSecret> {
+export class SecretHolder<Secret> {
     private readonly secretId: string;
     private readonly prefix: string;
     private readonly expectedKeys: string[];
@@ -51,7 +51,7 @@ export class SecretHolder<Secret extends GenericSecret> {
         this.secretCache.push(DEFAULT_SECRET_KEY, secretValue);
     }
 
-    public static create<S extends GenericSecret>(
+    public static create<S>(
         prefix = DEFAULT_PREFIX,
         expectedKeys: string[] = []
     ) {
@@ -67,7 +67,10 @@ export class SecretHolder<Secret extends GenericSecret> {
         const parsedSecret =
             this.prefix === DEFAULT_PREFIX
                 ? secret
-                : this.parseSecret(secret, `${this.prefix}.`);
+                : this.parseSecret(
+                      secret as unknown as GenericSecret,
+                      `${this.prefix}.`
+                  );
 
         if (this.expectedKeys.length > 0) {
             checkExpectedSecretKeys(this.expectedKeys, parsedSecret);

package/src/database/database.ts

@@ -1,6 +1,6 @@
 import { IDatabase, ITask } from "pg-promise";
 import { DatabaseEnvironmentKeys } from "../aws/runtime/secrets/dbsecret";
-import { getEnvVariable, getEnvVariableSafe } from "../utils/utils";
+import { getEnvVariable } from "../utils/utils";
 import { envValue } from "../aws/runtime/environment";
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires