@digitraffic/common 2024.1.24-2 → 2024.1.30-1

package/src/aws/infra/api/handler-factory.mts

@@ -1,86 +0,0 @@
-import { getEnvVariableOrElse } from "../../../utils/utils.mjs";
-import { DtLogger } from "../../runtime/dt-logger.mjs";
-import { LambdaResponse } from "../../types/lambda-response.mjs";
-
-export type LoggingHandler = (
-    method: () => Promise<LambdaResponse>,
-    logger: DtLogger
-) => Promise<LambdaResponse>;
-
-export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
-
-const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
-
-/**
- * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
- * with the defaults:
- * * No error handling
- * * Execution time logging
- *
- * You should instantiate HandlerFactory in your project with desired error handling and use the factory instance for
- * creating handler-functions for your lambdas.
- */
-export class HandlerFactory {
-    private loggingHandler: LoggingHandler;
-    private errorHandler: ErrorHandler;
-
-    constructor() {
-        this.loggingHandler = async (method: () => Promise<LambdaResponse>) => {
-            const start = Date.now();
-
-            try {
-                return await method();
-            } finally {
-                console.info(
-                    "method=%s.handler tookMs=%d",
-                    functionName,
-                    Date.now() - start
-                );
-            }
-        };
-
-        this.errorHandler = (error: unknown) => {
-            throw error;
-        };
-    }
-
-    withLoggingHandler(loggingHandler: LoggingHandler) {
-        this.loggingHandler = loggingHandler;
-        return this;
-    }
-
-    withErrorHandler(errorHandler: ErrorHandler) {
-        this.errorHandler = errorHandler;
-        return this;
-    }
-
-    createEventHandler(
-        handler: (event: unknown) => Promise<LambdaResponse>,
-        logger: DtLogger
-    ) {
-        return async (event: unknown) => {
-            return await this.loggingHandler(async () => {
-                try {
-                    return await handler(event);
-                } catch (error) {
-                    return this.errorHandler(error, logger);
-                }
-            }, logger);
-        };
-    }
-}
-
-export function createJsonLoggingHandler(): LoggingHandler {
-    return async (method: () => Promise<LambdaResponse>, logger: DtLogger) => {
-        const start = Date.now();
-
-        try {
-            return await method();
-        } finally {
-            logger.info({
-                method: `${functionName}.handler`,
-                tookMs: Date.now() - start,
-            });
-        }
-    };
-}

package/src/aws/infra/api/integration.mts

@@ -1,147 +0,0 @@
-import {
-    IntegrationResponse,
-    LambdaIntegration,
-    PassthroughBehavior,
-} from "aws-cdk-lib/aws-apigateway";
-import { IFunction } from "aws-cdk-lib/aws-lambda";
-import { MediaType } from "../../types/mediatypes.mjs";
-import { DigitrafficIntegrationResponse } from "../../runtime/digitraffic-integration-response.mjs";
-
-type ParameterType =
-    | "path"
-    | "querystring"
-    | "multivaluequerystring"
-    | "context"
-    | "header";
-
-interface ApiParameter {
-    type: ParameterType;
-    name: string;
-}
-
-export class DigitrafficIntegration<T extends string> {
-    readonly lambda: IFunction;
-    readonly mediaType: MediaType;
-    readonly parameters: ApiParameter[] = [];
-    readonly sunset?: string;
-
-    constructor(
-        lambda: IFunction,
-        mediaType = MediaType.TEXT_PLAIN,
-        sunset?: string
-    ) {
-        this.lambda = lambda;
-        this.mediaType = mediaType;
-        this.sunset = sunset;
-    }
-
-    addPathParameter(...names: T[]): this {
-        names.forEach((name) => this.parameters.push({ type: "path", name }));
-
-        return this;
-    }
-
-    addQueryParameter(...names: T[]): this {
-        names.forEach((name) =>
-            this.parameters.push({ type: "querystring", name })
-        );
-        return this;
-    }
-
-    addMultiValueQueryParameter(...names: T[]): this {
-        names.forEach((name) =>
-            this.parameters.push({ type: "multivaluequerystring", name })
-        );
-        return this;
-    }
-
-    /**
-     * Note that context parameter values needs to be in json format as they will be parsed in template as json.
-     * See createRequestTemplates below.
-     * @param names for the parameters
-     * @returns
-     */
-    addContextParameter(...names: T[]): this {
-        names.forEach((name) =>
-            this.parameters.push({ type: "context", name })
-        );
-
-        return this;
-    }
-
-    /**
-     * Do not use Authorization header as that will be consumed by ApiGW.
-     * If Authorization header is needed, use lambda authorizers.
-     * @param names for the headers
-     */
-    addHeaderParameter(...names: T[]): this {
-        names.forEach((name) => this.parameters.push({ type: "header", name }));
-
-        return this;
-    }
-
-    build(): LambdaIntegration {
-        const integrationResponses = this.createResponses();
-
-        return new LambdaIntegration(this.lambda, {
-            proxy: false,
-            integrationResponses,
-            requestParameters:
-                this.parameters.length == 0
-                    ? undefined
-                    : this.createRequestParameters(),
-            requestTemplates:
-                this.parameters.length == 0
-                    ? undefined
-                    : this.createRequestTemplates(),
-            passthroughBehavior: PassthroughBehavior.WHEN_NO_MATCH,
-        });
-    }
-
-    createRequestParameters(): Record<string, string> {
-        const requestParameters: Record<string, string> = {};
-
-        // filter out context parameters
-        this.parameters
-            .filter((parameter) => parameter.type !== "context")
-            .forEach((parameter: ApiParameter) => {
-                requestParameters[
-                    `integration.request.${parameter.type.replace(
-                        "multivaluequerystring",
-                        "querystring"
-                    )}.${parameter.name}`
-                ] = `method.request.${parameter.type}.${parameter.name}`;
-            });
-
-        return requestParameters;
-    }
-
-    createRequestTemplates(): Record<string, string> {
-        const requestJson: Record<string, string> = {};
-
-        this.parameters.forEach((parameter: ApiParameter) => {
-            if (parameter.type === "context") {
-                requestJson[
-                    parameter.name
-                ] = `$util.parseJson($context.${parameter.name})`;
-            } else if (parameter.type === "multivaluequerystring") {
-                // make multivaluequerystring values to array
-                requestJson[
-                    parameter.name
-                ] = `[#foreach($val in $method.request.multivaluequerystring.get('${parameter.name}'))"$util.escapeJavaScript($val)"#if($foreach.hasNext),#end#end]`;
-            } else {
-                requestJson[
-                    parameter.name
-                ] = `$util.escapeJavaScript($input.params('${parameter.name}'))`;
-            }
-        });
-
-        return {
-            [MediaType.APPLICATION_JSON]: JSON.stringify(requestJson),
-        };
-    }
-
-    createResponses(): IntegrationResponse[] {
-        return [DigitrafficIntegrationResponse.ok(this.mediaType, this.sunset)];
-    }
-}

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

@@ -1,165 +0,0 @@
-import { MediaType } from "../../types/mediatypes.mjs";
-import {
-    JsonSchema,
-    JsonSchemaType,
-    JsonSchemaVersion,
-    MethodResponse,
-    Model,
-  type IModel
-} from "aws-cdk-lib/aws-apigateway";
-import { dateFromIsoString } from "../../../utils/date-utils.mjs";
-
-/**
- * This is velocity-script, that assumes the response to be LambdaResponse(status and body).
- * It will always return the body and status, but if status in something else than 200 OK the content-type
- * will be overridden to text/plain. (it's assumed, that lambda will return error text).
- *
- * Body content must be base64-encoded! use LambdaResponse for this! This way you can also return
- * non-textual content.
- *
- * If fileName is set, then Content-Disposition-header will be set to use it
- * If timestamp is set, then ETag & Last-Modified headers will be set
- */
-export const RESPONSE_DEFAULT_LAMBDA = `#set($inputRoot = $input.path('$'))
-#if ($inputRoot.status != 200)
-#set ($context.responseOverride.status = $inputRoot.status)
-#set ($context.responseOverride.header.Content-Type = 'text/plain')
-#end
-#set ($context.responseOverride.header.Access-Control-Allow-Origin = '*')
-#if ("$!inputRoot.timestamp" != "")
-#set ($context.responseOverride.header.Last-Modified = $inputRoot.timestamp)
-#end
-#if ("$!inputRoot.etag" != "")
-#set ($context.responseOverride.header.ETag = $inputRoot.etag)
-#end
-#if ("$!inputRoot.fileName" != "")
-#set ($disposition = 'attachment; filename="FN"')
-#set ($context.responseOverride.header.Content-Disposition = $disposition.replaceAll('FN', $inputRoot.fileName))
-#end
-$util.base64Decode($inputRoot.body)`;
-
-/**
- * Use this for deprecated integrations.
- * Will add HTTP headers Deprecation and Sunset to response.
- * Example:
- *  Deprecation: true
- *  Sunset: Tue, 20 Dec 2022 00:00:00 GMT
- * @param sunset Sunset date as string in ISO 8601 date-time format (YYYY-MM-DD)
- */
-
-export const getDeprecatedDefaultLambdaResponse = (sunset: string) => {
-    const setDeprecationHeaders = `#set ($context.responseOverride.header.Deprecation = 'true')
-#set ($context.responseOverride.header.Sunset = '${dateFromIsoString(
-        sunset
-    ).toUTCString()}')`;
-    return RESPONSE_DEFAULT_LAMBDA.concat(setDeprecationHeaders);
-};
-
-const BODY_FROM_INPUT_PATH = "$input.path('$').body";
-
-/// @deprecated
-const messageSchema: JsonSchema = {
-    schema: JsonSchemaVersion.DRAFT4,
-    type: JsonSchemaType.OBJECT,
-    description: "Response with message",
-    properties: {
-        message: {
-            type: JsonSchemaType.STRING,
-            description: "Response message",
-        },
-    },
-};
-
-/// @deprecated
-export const MessageModel = {
-    contentType: MediaType.APPLICATION_JSON,
-    modelName: "MessageResponseModel",
-    schema: messageSchema,
-};
-
-const NotFoundMessage = "Not found";
-export const NotFoundResponse = JSON.stringify({ message: NotFoundMessage });
-
-const InternalServerErrorMessage = "Error";
-const InternalServerErrorResponse = JSON.stringify({
-    message: InternalServerErrorMessage,
-});
-
-const BadRequestMessage = "Bad request";
-const BadRequestResponse = JSON.stringify({ message: BadRequestMessage });
-
-/// @deprecated
-export const BadRequestResponseTemplate = {
-    [MediaType.APPLICATION_JSON]: BadRequestResponse,
-};
-/// @deprecated
-export const NotFoundResponseTemplate = {
-    [MediaType.APPLICATION_JSON]: NotFoundResponse,
-};
-/// @deprecated
-export const XmlResponseTemplate = {
-    [MediaType.APPLICATION_XML]: BODY_FROM_INPUT_PATH,
-};
-/// @deprecated
-export const InternalServerErrorResponseTemplate = {
-    [MediaType.APPLICATION_JSON]: InternalServerErrorResponse,
-};
-
-export class DigitrafficMethodResponse {
-    static response(
-        statusCode: string,
-        model: IModel,
-        mediaType: MediaType,
-        disableCors = false,
-        deprecation = false
-    ): MethodResponse {
-        return {
-            statusCode,
-            responseModels: {
-                [mediaType]: model,
-            },
-            responseParameters: {
-                ...(!disableCors && {
-                    "method.response.header.Access-Control-Allow-Origin": true,
-                }),
-                ...(deprecation && {
-                    "method.response.header.Deprecation": true,
-                    "method.response.header.Sunset": true,
-                }),
-            },
-        };
-    }
-
-    static response200(model: IModel, mediaType = MediaType.APPLICATION_JSON) {
-        return DigitrafficMethodResponse.response(
-            "200",
-            model,
-            mediaType,
-            false
-        );
-    }
-
-    static response500(
-        model = Model.EMPTY_MODEL,
-        mediaType = MediaType.APPLICATION_JSON
-    ) {
-        return DigitrafficMethodResponse.response(
-            "500",
-            model,
-            mediaType,
-            false
-        );
-    }
-
-    static response400(
-        model = Model.EMPTY_MODEL,
-        mediaType = MediaType.APPLICATION_JSON
-    ) {
-        return DigitrafficMethodResponse.response(
-            "400",
-            model,
-            mediaType,
-            false
-        );
-    }
-}

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

@@ -1,127 +0,0 @@
-import {
-    InternalServerErrorResponseTemplate,
-    XmlResponseTemplate,
-    NotFoundResponseTemplate,
-    BadRequestResponseTemplate,
-} from "./response.mjs";
-import {
-    LambdaIntegration,
-    MethodResponse,
-    IntegrationResponse,
-    PassthroughBehavior,
-  type IModel
-} from "aws-cdk-lib/aws-apigateway";
-import { Function as AWSFunction } from "aws-cdk-lib/aws-lambda";
-import {
-    BAD_REQUEST_MESSAGE,
-    ERROR_MESSAGE,
-    NOT_FOUND_MESSAGE,
-} from "../../types/errors.mjs";
-import { MediaType } from "../../types/mediatypes.mjs";
-
-/// @deprecated
-export const RESPONSE_200_OK: IntegrationResponse = {
-    statusCode: "200",
-};
-
-/// @deprecated
-export const RESPONSE_400_BAD_REQUEST: IntegrationResponse = {
-    statusCode: "400",
-    selectionPattern: BAD_REQUEST_MESSAGE,
-    responseTemplates: BadRequestResponseTemplate,
-};
-
-/// @deprecated
-export const RESPONSE_500_SERVER_ERROR: IntegrationResponse = {
-    statusCode: "500",
-    selectionPattern: ERROR_MESSAGE,
-    responseTemplates: InternalServerErrorResponseTemplate,
-};
-
-/// @deprecated
-const RESPONSE_XML = {
-    responseTemplates: XmlResponseTemplate,
-};
-
-/// @deprecated
-export const RESPONSE_CORS_INTEGRATION = {
-    responseParameters: {
-        "method.response.header.Access-Control-Allow-Origin": "'*'",
-    },
-};
-
-/// @deprecated
-export const RESPONSE_404_NOT_FOUND = {
-    statusCode: "404",
-    selectionPattern: NOT_FOUND_MESSAGE,
-    responseTemplates: NotFoundResponseTemplate,
-};
-
-/**
- * @deprecated Use DigitrafficMethodResponse
- */
-export function methodResponse(
-    status: string,
-    contentType: MediaType,
-    model: IModel,
-    parameters?: Record<string, boolean>
-): MethodResponse {
-    return {
-        statusCode: status,
-        responseModels: {
-            [contentType]: model,
-        },
-        responseParameters: parameters ?? {},
-    };
-}
-
-interface IntegrationOptions {
-    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
-    requestParameters?: { [dest: string]: string };
-    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
-    requestTemplates?: { [contentType: string]: string };
-    responses?: IntegrationResponse[];
-    disableCors?: boolean;
-    xml?: boolean;
-    passthroughBehavior?: PassthroughBehavior;
-}
-
-/**
- * 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,
-    options?: IntegrationOptions
-): LambdaIntegration {
-    return new LambdaIntegration(lambdaFunction, {
-        proxy: false,
-        integrationResponses: options?.responses ?? [
-            getResponse(RESPONSE_200_OK, options),
-            getResponse(RESPONSE_400_BAD_REQUEST, options),
-            getResponse(RESPONSE_404_NOT_FOUND, options),
-            getResponse(RESPONSE_500_SERVER_ERROR, options),
-        ],
-        requestParameters: options?.requestParameters ?? {},
-        requestTemplates: options?.requestTemplates ?? {},
-        passthroughBehavior:
-            options?.passthroughBehavior ?? PassthroughBehavior.WHEN_NO_MATCH,
-    });
-}
-
-export function getResponse(
-    response: IntegrationResponse,
-    options?: IntegrationOptions
-): IntegrationResponse {
-    if (options?.xml) {
-        response = { ...response, ...RESPONSE_XML };
-    }
-    if (!options?.disableCors) {
-        response = { ...response, ...RESPONSE_CORS_INTEGRATION };
-    }
-
-    return response;
-}

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

@@ -1,108 +0,0 @@
-import {
-    MethodResponse,
-    MockIntegration,
-    PassthroughBehavior,
-    Resource,
-} from "aws-cdk-lib/aws-apigateway";
-import { MediaType } from "../../types/mediatypes.mjs";
-import { RESPONSE_CORS_INTEGRATION } from "./responses.mjs";
-
-const INTEGRATION_RESPONSE_200 = `{
-    "statusCode": 200
-}`;
-
-const METHOD_RESPONSE_200 = {
-    statusCode: "200",
-};
-
-/**
- * Static integration, that returns the given response with given mediaType from given resource.
- *
- * @param resource
- * @param mediaType
- * @param response
- */
-export class DigitrafficStaticIntegration extends MockIntegration {
-    constructor(
-        resource: Resource,
-        mediaType: MediaType,
-        response: string,
-        enableCors = true,
-        apiKeyRequired = true
-    ) {
-        const integrationResponse =
-            DigitrafficStaticIntegration.createIntegrationResponse(
-                response,
-                mediaType,
-                enableCors
-            );
-
-        super({
-            passthroughBehavior: PassthroughBehavior.WHEN_NO_TEMPLATES,
-            requestTemplates: {
-                [mediaType]: INTEGRATION_RESPONSE_200,
-            },
-            integrationResponses: [integrationResponse],
-        });
-
-        ["GET", "HEAD"].forEach((httpMethod) => {
-            resource.addMethod(httpMethod, this, {
-                apiKeyRequired,
-                methodResponses: [
-                    DigitrafficStaticIntegration.createMethodResponse(
-                        enableCors
-                    ),
-                ],
-            });
-        });
-    }
-
-    static json<K>(
-        resource: Resource,
-        response: K,
-        enableCors = true,
-        apiKeyRequired = true
-    ) {
-        return new DigitrafficStaticIntegration(
-            resource,
-            MediaType.APPLICATION_JSON,
-            JSON.stringify(response),
-            enableCors,
-            apiKeyRequired
-        );
-    }
-
-    private static createIntegrationResponse(
-        response: string,
-        mediaType: MediaType,
-        enableCors: boolean
-    ) {
-        const integrationResponse = {
-            statusCode: "200",
-            responseTemplates: {
-                [mediaType]: response,
-            },
-        };
-
-        return enableCors
-            ? { ...integrationResponse, ...RESPONSE_CORS_INTEGRATION }
-            : integrationResponse;
-    }
-
-    private static createMethodResponse(enableCors: boolean) {
-        return enableCors
-            ? corsMethod(METHOD_RESPONSE_200)
-            : METHOD_RESPONSE_200;
-    }
-}
-
-function corsMethod(response: MethodResponse): MethodResponse {
-    return {
-        ...response,
-        ...{
-            responseParameters: {
-                "method.response.header.Access-Control-Allow-Origin": true,
-            },
-        },
-    };
-}

package/src/aws/infra/canaries/Synthetics.d.mts

@@ -1,21 +0,0 @@
-declare module 'Synthetics' {
-  import {type RequestOptions} from "http";
-
-  interface SyntheticsConfiguration {
-    withIncludeRequestBody: (value: boolean) => SyntheticsConfiguration;
-    withIncludeRequestHeaders: (value: boolean) => SyntheticsConfiguration;
-    withIncludeResponseBody: (value: boolean) => SyntheticsConfiguration;
-    withIncludeResponseHeaders: (value: boolean) => SyntheticsConfiguration;
-    withFailedCanaryMetric: (value: boolean) => SyntheticsConfiguration;
-    disableRequestMetrics: () => SyntheticsConfiguration;
-  }
-
-    export function executeHttpStep<T>(
-      name: string,
-      requestOptions: RequestOptions,
-      callback: JsonCheckerFunction<T>
-    ): Promise<void>;
-    export function getConfiguration(): SyntheticsConfiguration;
-
-    export function executeStep(s: string, f: ()=>void, c: Record<string, boolean>)
-};

package/src/aws/infra/canaries/canary-alarm.mts

@@ -1,33 +0,0 @@
-import { Construct } from "constructs";
-import { CanaryParameters } from "./canary-parameters.mjs";
-import { Alarm, ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
-import { Canary } from "aws-cdk-lib/aws-synthetics";
-import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
-import { Topic } from "aws-cdk-lib/aws-sns";
-
-export class CanaryAlarm {
-    constructor(stack: Construct, canary: Canary, params: CanaryParameters) {
-        const alarmName = params.alarm?.alarmName ?? `${params.name}-alarm`;
-
-        const alarm = new Alarm(stack, alarmName, {
-            alarmName,
-            alarmDescription: params.alarm?.description ?? "",
-            metric: canary.metricSuccessPercent(),
-            evaluationPeriods: params.alarm?.evalutionPeriods ?? 1,
-            threshold: params.alarm?.threshold ?? 100,
-            comparisonOperator: ComparisonOperator.LESS_THAN_THRESHOLD,
-        });
-
-        if (params.alarm?.topicArn) {
-            alarm.addAlarmAction(
-                new SnsAction(
-                    Topic.fromTopicArn(
-                        stack,
-                        `${alarmName}-action`,
-                        params.alarm.topicArn
-                    )
-                )
-            );
-        }
-    }
-}

package/src/aws/infra/canaries/canary-keys.mts

@@ -1,3 +0,0 @@
-export const ENV_API_KEY = "apiKeyId";
-export const ENV_HOSTNAME = "hostname";
-export const ENV_SECRET = "secret";