@digitraffic/common 2023.3.21-2 → 2023.4.3-1

package/dist/types/urn.d.ts

@@ -1 +1 @@
-export declare type URN<Namespace extends string, NamespaceSpecificString extends string = ""> = `urn:${Namespace}:${NamespaceSpecificString}`;
+export type URN<Namespace extends string, NamespaceSpecificString extends string = ""> = `urn:${Namespace}:${NamespaceSpecificString}`;

package/dist/utils/logging.d.ts

@@ -1,4 +1,31 @@
-import { AxiosError } from "axios";
 import { DtLogger } from "../aws/runtime/dt-logger";
-export declare function logException(logger: DtLogger, error: Error | string, includeStack?: boolean): void;
-export declare function logException(logger: DtLogger, error: AxiosError): void;
+/**
+ * Curried version of logException.
+ *
+ * @example <caption>Using default configuration</caption>
+ * Promise.reject(x).catch(createExceptionLogger())
+ *
+ * @example <caption>Providing external logger and requiring stack</caption>
+ * import {logger} from "@digitraffic/common/dist/aws/runtime/dt-logger-default"
+ * Promise.reject(x).catch(createExceptionLogger(logger, true))
+ *
+ * @param [logger=undefined] - DtLogger to use. If not given, will create a new instance of DtLogger
+ * @param [includeStack=false] - Define if the stack trace should be logged.
+ * @param error - The error instance to be logged.
+ * @returns Logs the error without rethrowing.
+ * @see {@link logException}
+ */
+export declare function createExceptionLogger(logger?: DtLogger | undefined, includeStack?: boolean): (error: unknown) => void;
+/**
+ * Log given exception with level ERROR to given logger.
+ *
+ * Supports AxiosError, Error and string
+ *
+ * @param logger - DtLogger to use
+ * @param error - AxiosError, Error or string to log
+ * @param [includeStack=true] - Include stack in the message, default false
+ * @returns Logs the error without rethrowing
+ * @see {@link DtLogger.log}
+ * @see {@link createExceptionLogger} for a curried setup
+ */
+export declare function logException(logger: DtLogger, error: unknown, includeStack?: boolean): void;

package/dist/utils/logging.js

@@ -1,28 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logException = void 0;
+exports.logException = exports.createExceptionLogger = void 0;
 const axios_1 = require("axios");
+const dt_logger_1 = require("../aws/runtime/dt-logger");
 const utils_1 = require("./utils");
 const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME", "test");
+/**
+ * Curried version of logException.
+ *
+ * @example <caption>Using default configuration</caption>
+ * Promise.reject(x).catch(createExceptionLogger())
+ *
+ * @example <caption>Providing external logger and requiring stack</caption>
+ * import {logger} from "@digitraffic/common/dist/aws/runtime/dt-logger-default"
+ * Promise.reject(x).catch(createExceptionLogger(logger, true))
+ *
+ * @param [logger=undefined] - DtLogger to use. If not given, will create a new instance of DtLogger
+ * @param [includeStack=false] - Define if the stack trace should be logged.
+ * @param error - The error instance to be logged.
+ * @returns Logs the error without rethrowing.
+ * @see {@link logException}
+ */
+function createExceptionLogger(logger = undefined, includeStack = false) {
+    let thatLogger;
+    if (logger) {
+        thatLogger = logger;
+    }
+    else {
+        thatLogger = new dt_logger_1.DtLogger();
+    }
+    return (error) => {
+        logException(thatLogger, error, includeStack);
+    };
+}
+exports.createExceptionLogger = createExceptionLogger;
 /**
  * Log given exception with level ERROR to given logger.
  *
  * Supports AxiosError, Error and string
  *
- * @param logger DtLogger to use
- * @param error AxiosError, Error or string to log
- * @param includeStack Include stack in the message, default false
- * @see log
+ * @param logger - DtLogger to use
+ * @param error - AxiosError, Error or string to log
+ * @param [includeStack=true] - Include stack in the message, default false
+ * @returns Logs the error without rethrowing
+ * @see {@link DtLogger.log}
+ * @see {@link createExceptionLogger} for a curried setup
  */
 function logException(logger, error, includeStack = false) {
-    const message = error instanceof Error ? error.message : error;
+    const message = error instanceof Error
+        ? error.message
+        : typeof error === "string"
+            ? error
+            : JSON.stringify(error);
     const stack = error instanceof Error && includeStack ? error.stack : undefined;
-    const code = error instanceof axios_1.AxiosError ? error.code : undefined;
+    const customCode = error instanceof axios_1.AxiosError ? error.code : undefined;
     logger.error({
         type: "Error",
         method: `${functionName}.logException`,
         message,
-        code,
+        customCode,
         stack,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2023.3.21-2",
+  "version": "2023.4.3-1",
   "description": "",
   "repository": {
     "type": "git",
@@ -17,13 +17,13 @@
     "src/**/*.ts"
   ],
   "peerDependencies": {
-    "@aws-cdk/aws-synthetics-alpha": "2.62.2-alpha.0",
+    "@aws-cdk/aws-synthetics-alpha": "2.70.0-alpha.0",
     "@types/geojson": "^7946.0.10",
-    "aws-cdk-lib": "2.62.2",
-    "aws-sdk": "^2.1304.0",
-    "axios": "^1.2.6",
+    "aws-cdk-lib": "2.70.0",
+    "aws-sdk": "^2.1343.0",
+    "axios": "^1.3.4",
     "change-case": "^4.1.2",
-    "constructs": "^10.1.235",
+    "constructs": "^10.1.292",
     "geojson-validation": "^1.0.2",
     "moment": "^2.29.4",
     "node-ttl": "^0.2.0",
@@ -31,38 +31,39 @@
     "pg-promise": "^10.12.0"
   },
   "devDependencies": {
-    "@aws-cdk/aws-synthetics-alpha": "2.62.2-alpha.0",
-    "@types/aws-lambda": "^8.10.110",
+    "@aws-cdk/aws-synthetics-alpha": "2.70.0-alpha.0",
+    "@types/aws-lambda": "^8.10.114",
     "@types/geojson": "^7946.0.10",
-    "@types/jest": "^29.2.5",
-    "@types/node": "^18.13.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash": "^4.14.192",
+    "@types/node": "^18.15.10",
     "@types/ramda": "^0.28.23",
     "@types/sinon": "^10.0.13",
-    "@typescript-eslint/eslint-plugin": "^5.51.0",
-    "@typescript-eslint/parser": "^5.51.0",
-    "aws-cdk-lib": "2.62.2",
-    "aws-sdk": "^2.1304.0",
-    "axios": "^1.2.6",
+    "@typescript-eslint/eslint-plugin": "~5.56.0",
+    "@typescript-eslint/parser": "^5.56.0",
+    "aws-cdk-lib": "^2.70.0",
+    "aws-sdk": "^2.1343.0",
+    "axios": "^1.3.4",
     "change-case": "^4.1.2",
-    "constructs": "^10.1.222",
-    "eslint": "~8.34.0",
-    "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-deprecation": "1.3.3",
+    "constructs": "^10.1.292",
+    "eslint": "~8.36.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-deprecation": "~1.3.3",
     "geojson-validation": "^1.0.2",
     "husky": "^8.0.3",
-    "jest": "^29.4.2",
+    "jest": "^29.5.0",
     "jest-junit": "^15.0.0",
-    "lint-staged": "^13.1.1",
+    "lint-staged": "^13.2.0",
     "moment": "^2.29.4",
     "node-ttl": "^0.2.0",
     "pg-native": "^3.0.1",
     "pg-promise": "^10.12.0",
-    "prettier": "^2.8.3",
+    "prettier": "^2.8.7",
     "ramda": "^0.28.0",
     "rimraf": "^4.1.0",
-    "sinon": "^15.0.1",
+    "sinon": "^15.0.3",
     "ts-jest": "^29.0.5",
-    "typescript": "~4.8.4"
+    "typescript": "~4.9.5"
   },
   "externals": [
     "aws-sdk",
@@ -71,12 +72,16 @@
   "lint-staged": {
     "*.{js,ts,css,md,yml,yaml,json}": "prettier --write"
   },
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
   "scripts": {
     "build": "tsc",
     "lint": "eslint --cache .",
     "eslint-report": "eslint . --format html",
     "ci:eslint-report": "eslint . --format html -o report.html",
     "clean": "rimraf dist output",
-    "test": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest"
+    "test": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest",
+    "test:watch": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest --watch"
   }
 }

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

@@ -7,7 +7,7 @@ import { IFunction } from "aws-cdk-lib/aws-lambda";
 import { MediaType } from "../../types/mediatypes";
 import { DigitrafficIntegrationResponse } from "../../runtime/digitraffic-integration-response";
 
-type ParameterType = "path" | "querystring";
+type ParameterType = "path" | "querystring" | "context";
 
 interface ApiParameter {
     type: ParameterType;
@@ -44,6 +44,14 @@ export class DigitrafficIntegration {
         return this;
     }
 
+    addContextParameter(...names: string[]): this {
+        names.forEach((name) =>
+            this.parameters.push({ type: "context", name })
+        );
+
+        return this;
+    }
+
     build(): LambdaIntegration {
         const integrationResponses = this.createResponses();
 
@@ -65,11 +73,14 @@ export class DigitrafficIntegration {
     createRequestParameters(): Record<string, string> {
         const requestParameters: Record<string, string> = {};
 
-        this.parameters.forEach((parameter: ApiParameter) => {
-            requestParameters[
-                `integration.request.${parameter.type}.${parameter.name}`
-            ] = `method.request.${parameter.type}.${parameter.name}`;
-        });
+        // filter out context parameters
+        this.parameters
+            .filter((parameter) => parameter.type !== "context")
+            .forEach((parameter: ApiParameter) => {
+                requestParameters[
+                    `integration.request.${parameter.type}.${parameter.name}`
+                ] = `method.request.${parameter.type}.${parameter.name}`;
+            });
 
         return requestParameters;
     }
@@ -78,9 +89,15 @@ export class DigitrafficIntegration {
         const requestJson: Record<string, string> = {};
 
         this.parameters.forEach((parameter: ApiParameter) => {
-            requestJson[
-                parameter.name
-            ] = `$util.escapeJavaScript($input.params('${parameter.name}'))`;
+            if (parameter.type === "context") {
+                requestJson[
+                    parameter.name
+                ] = `$util.parseJson($context.${parameter.name})`;
+            } else {
+                requestJson[
+                    parameter.name
+                ] = `$util.escapeJavaScript($input.params('${parameter.name}'))`;
+            }
         });
 
         return {

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

@@ -1,7 +1,13 @@
-import {MediaType} from "../../types/mediatypes";
-import {JsonSchema, JsonSchemaType, JsonSchemaVersion, MethodResponse, Model,} from "aws-cdk-lib/aws-apigateway";
-import {IModel} from "aws-cdk-lib/aws-apigateway/lib/model";
-import {dateFromIsoString} from "../../../utils/date-utils";
+import { MediaType } from "../../types/mediatypes";
+import {
+    JsonSchema,
+    JsonSchemaType,
+    JsonSchemaVersion,
+    MethodResponse,
+    Model,
+} from "aws-cdk-lib/aws-apigateway";
+import { IModel } from "aws-cdk-lib/aws-apigateway/lib/model";
+import { dateFromIsoString } from "../../../utils/date-utils";
 
 /**
  * This is velocity-script, that assumes the response to be LambdaResponse(status and body).
@@ -37,7 +43,9 @@ $util.base64Decode($inputRoot.body)
 
 export const getDeprecatedDefaultLambdaResponse = (sunset: string) => {
     const setDeprecationHeaders = `#set ($context.responseOverride.header.Deprecation = 'true')
-#set ($context.responseOverride.header.Sunset = '${dateFromIsoString(sunset).toUTCString()}')`;
+#set ($context.responseOverride.header.Sunset = '${dateFromIsoString(
+        sunset
+    ).toUTCString()}')`;
     return RESPONSE_DEFAULT_LAMBDA.concat(setDeprecationHeaders);
 };
 
@@ -75,35 +83,21 @@ const BadRequestMessage = "Bad request";
 const BadRequestResponse = JSON.stringify({ message: BadRequestMessage });
 
 /// @deprecated
-export const BadRequestResponseTemplate = createResponses(
-    MediaType.APPLICATION_JSON,
-    BadRequestResponse
-);
-/// @deprecated
-export const NotFoundResponseTemplate = createResponses(
-    MediaType.APPLICATION_JSON,
-    NotFoundResponse
-);
+export const BadRequestResponseTemplate = {
+    [MediaType.APPLICATION_JSON]: BadRequestResponse,
+};
 /// @deprecated
-export const XmlResponseTemplate = createResponses(
-    MediaType.APPLICATION_XML,
-    BODY_FROM_INPUT_PATH
-);
+export const NotFoundResponseTemplate = {
+    [MediaType.APPLICATION_JSON]: NotFoundResponse,
+};
 /// @deprecated
-export const InternalServerErrorResponseTemplate = createResponses(
-    MediaType.APPLICATION_JSON,
-    InternalServerErrorResponse
-);
-
+export const XmlResponseTemplate = {
+    [MediaType.APPLICATION_XML]: BODY_FROM_INPUT_PATH,
+};
 /// @deprecated
-export function createResponses<T>(
-    key: MediaType,
-    value: T
-): Record<string, T> {
-    return {
-        [key]: value,
-    };
-}
+export const InternalServerErrorResponseTemplate = {
+    [MediaType.APPLICATION_JSON]: InternalServerErrorResponse,
+};
 
 export class DigitrafficMethodResponse {
     static response(

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

@@ -1,6 +1,5 @@
 import {
     InternalServerErrorResponseTemplate,
-    createResponses,
     XmlResponseTemplate,
     NotFoundResponseTemplate,
     BadRequestResponseTemplate,
@@ -20,32 +19,38 @@ import {
 } from "../../types/errors";
 import { MediaType } from "../../types/mediatypes";
 
+/// @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,
@@ -63,7 +68,9 @@ export function methodResponse(
 ): MethodResponse {
     return {
         statusCode: status,
-        responseModels: createResponses(contentType, model),
+        responseModels: {
+            [contentType]: model,
+        },
         responseParameters: parameters ?? {},
     };
 }

package/src/aws/runtime/dt-logger.ts

@@ -1,37 +1,76 @@
 import { Writable } from "stream";
+import _ from "lodash";
 
-type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
+/** Logging level */
+export type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
 
+/**
+ * Configuration object for configuring the Digitraffic logging utility
+ * @see {@link DtLogger}
+ */
 export interface LoggerConfiguration {
+    /** Name of the lambda */
     lambdaName?: string;
+    /** The file name where the logging occurs */
     fileName?: string;
+    /** The lambda runtime environment */
     runTime?: string;
+    /** Custom end point to write the logs to */
     writeStream?: Writable;
 }
 
-export interface LoggableType {
-    /** name of method logging the message */
+interface LoggableTypeInternal extends LoggableType {
+    level: LOG_LEVEL;
+}
+
+/**
+ * CustomParams allows to add keys prefixed with `custom` keyword to be added to an
+ * object.
+ */
+export interface CustomParams {
+    /** do not log your apikey! */
+    customApikey?: never;
+    /** do not log your apikey! */
+    customApiKey?: never;
+    [key: `custom${Capitalize<string>}Count`]: number;
+
+    [key: `custom${Capitalize<string>}`]:
+        | string
+        | number
+        | boolean
+        | Date
+        | null
+        | undefined;
+}
+
+/**
+ * Digitraffic logging object.
+ *
+ * `method` property is the only required propetry. {@link CustomParams} can be added by
+ * prefixin the property with keyword `custom`. The prefix is removed before writing to
+ * logging end point.
+ *
+ * @see {@link CustomParams}
+ */
+export interface LoggableType extends CustomParams {
+    /** Name of the method logging the message */
     method: `${string}.${string}`;
-    /** message to log, optional */
+    /** Message to log, optional */
     message?: string;
-    /** type of message, optional */
+    /** Type of message, optional */
     type?: string;
-    /** stack trace, optional */
-    stack?: string;
-    /** amount of time some operation took in milliseconds, optional */
+    /** Stack trace, optional */
+    stack?: string | undefined;
+    /** Amount of time some operation took in milliseconds, optional */
     tookMs?: number;
-    /** count of something, optional */
-    count?: number;
-    /** do not log your apikey! */
-    apikey?: never;
-    /** do not log your apikey! */
-    apiKey?: never;
-    /** any other loggable key */
-    [key: string]: string | number | boolean | Date | undefined;
+    /** Pass error object, which will be stringified before logging */
+    error?: unknown;
 }
 
 /**
- * Helper class for json-logging.  Logged line will include
+ * Helper class for json-logging.
+ *
+ * Logged line will include:
  * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
@@ -39,15 +78,18 @@ export interface LoggableType {
  */
 export class DtLogger {
     readonly lambdaName?: string;
-    readonly fileName?: string;
     readonly runtime?: string;
 
     readonly writeStream: Writable;
 
+    /**
+     * Create a new Logger instance.
+     * @constructor
+     * @param {LoggerConfiguration?} [config] - Accepts configuration options @see {@link LoggerConfiguration}
+     */
     constructor(config?: LoggerConfiguration) {
         this.lambdaName =
             config?.lambdaName ?? process.env.AWS_LAMBDA_FUNCTION_NAME;
-        this.fileName = config?.fileName;
         this.runtime = config?.runTime ?? process.env.AWS_EXECUTION_ENV;
         this.writeStream = config?.writeStream ?? process.stdout;
     }
@@ -56,13 +98,13 @@ export class DtLogger {
      * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
      *
      * @param message anything
-     * @see log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
      */
     debug(message: unknown): void {
         const logMessage = {
             message,
             level: "DEBUG",
-            fileName: this.fileName,
             lambdaName: this.lambdaName,
             runtime: this.runtime,
         };
@@ -74,46 +116,57 @@ export class DtLogger {
      * Log given message with level INFO
      *
      * @param message Json-object to log
-     * @see log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
      */
     info(message: LoggableType): void {
-        this.log("INFO", message);
+        this.log({ ...message, level: "INFO" });
     }
 
     /**
      * Log given message with level WARN
      *
      * @param message Json-object to log
-     * @see log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
      */
     warn(message: LoggableType): void {
-        this.log("WARN", message);
+        this.log({ ...message, level: "WARN" });
     }
     /**
      * Log given message with level INFO
      *
      * @param message Json-object to log
-     * @see log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
      */
     error(message: LoggableType): void {
-        this.log("ERROR", message);
+        this.log({
+            ...message,
+            level: "ERROR",
+        });
     }
 
     /**
-     * Log message with given log level.  If message is a json object, it will be logged as it is and if it is a string it will be wrapped into json-element with key "message".
+     * Log message with given log level.
+     *
      * Some metadata is also added to the message:
      * * runtime     - can be configured with constructor or inferred from environment
      * * lambdaName  - can be configured with constructor or inferred from environment
-     * * fileName    - can be configured with constructor
      *
-     * @param level "DEBUG", "INFO" or "ERROR"
-     * @param message Either a string or json-object
+     * @param message Json-object to log
+     * @see {@link LoggableType}
      */
-    log(level: LOG_LEVEL, message: LoggableType): void {
+    private log(message: LoggableTypeInternal): void {
+        const error = message.error
+            ? typeof message.error === "string"
+                ? message.error
+                : JSON.stringify(message.error)
+            : undefined;
+
         const logMessage = {
-            ...message,
-            level,
-            fileName: message.fileName ?? this.fileName,
+            ...removePrefix("custom", message),
+            error,
             lambdaName: this.lambdaName,
             runtime: this.runtime,
         };
@@ -121,3 +174,9 @@ export class DtLogger {
         this.writeStream.write(JSON.stringify(logMessage) + "\n");
     }
 }
+
+function removePrefix(prefix: string, loggable: LoggableType) {
+    return _.mapKeys(loggable, (_index, key: string) =>
+        key.startsWith(prefix) ? _.lowerFirst(key.replace(prefix, "")) : key
+    );
+}

package/src/database/database.ts

@@ -1,6 +1,5 @@
 import { IDatabase, ITask } from "pg-promise";
-import { getEnvVariable } from "../utils/utils";
-import { envValue } from "../aws/runtime/environment";
+import { getEnvVariable, getEnvVariableOrElse } from "../utils/utils";
 
 export enum DatabaseEnvironmentKeys {
     DB_USER = "DB_USER",
@@ -78,13 +77,13 @@ async function doInDatabase<T>(
     readonly: boolean,
     fn: (db: DTDatabase) => Promise<T>
 ): Promise<T> {
-    const db_application = envValue(
+    const db_application = getEnvVariableOrElse(
         DatabaseEnvironmentKeys.DB_APPLICATION,
         "unknown-cdk-application"
     );
     const db_uri = readonly
-        ? envValue(DatabaseEnvironmentKeys.DB_RO_URI)
-        : envValue(DatabaseEnvironmentKeys.DB_URI);
+        ? getEnvVariable(DatabaseEnvironmentKeys.DB_RO_URI)
+        : getEnvVariable(DatabaseEnvironmentKeys.DB_URI);
 
     const db = initDbConnection(
         getEnvVariable(DatabaseEnvironmentKeys.DB_USER),