@digitraffic/common 2023.3.10-1 → 2023.3.21-1

package/dist/aws/infra/api/handler-factory.d.ts

@@ -1,7 +1,7 @@
 import { DtLogger } from "../../runtime/dt-logger";
 import { LambdaResponse } from "../../types/lambda-response";
-export type LoggingHandler = (method: () => Promise<LambdaResponse>, logger: DtLogger) => Promise<LambdaResponse>;
-export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
+export declare type LoggingHandler = (method: () => Promise<LambdaResponse>, logger: DtLogger) => Promise<LambdaResponse>;
+export declare type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:

package/dist/aws/infra/api/handler-factory.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonLoggingHandler = exports.HandlerFactory = void 0;
+const utils_1 = require("../../../utils/utils");
+const functionName = (0, utils_1.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:
@@ -18,7 +20,7 @@ class HandlerFactory {
                 return await method();
             }
             finally {
-                console.info("method=%s.handler tookMs=%d", process.env.AWS_LAMBDA_FUNCTION_NAME, Date.now() - start);
+                console.info("method=%s.handler tookMs=%d", functionName, Date.now() - start);
             }
         };
         this.errorHandler = (error) => {
@@ -54,7 +56,10 @@ function createJsonLoggingHandler() {
             return await method();
         }
         finally {
-            logger.info({ tookMs: Date.now() - start });
+            logger.info({
+                method: `${functionName}.handler`,
+                tookMs: Date.now() - start,
+            });
         }
     };
 }

package/dist/aws/infra/api/integration.d.ts

@@ -1,7 +1,7 @@
 import { IntegrationResponse, LambdaIntegration } from "aws-cdk-lib/aws-apigateway";
 import { IFunction } from "aws-cdk-lib/aws-lambda";
 import { MediaType } from "../../types/mediatypes";
-type ParameterType = "path" | "querystring";
+declare type ParameterType = "path" | "querystring";
 interface ApiParameter {
     type: ParameterType;
     name: string;

package/dist/aws/infra/canaries/canary-parameters.d.ts

@@ -1,6 +1,6 @@
 import { Schedule } from "@aws-cdk/aws-synthetics-alpha";
 /** Optional env parameters for canary */
-type CanaryEnv = Record<string, string>;
+declare type CanaryEnv = Record<string, string>;
 export interface CanaryParameters {
     readonly name: string;
     readonly schedule?: Schedule;

package/dist/aws/infra/canaries/url-checker.d.ts

@@ -3,8 +3,8 @@ import { IncomingMessage } from "http";
 import { MediaType } from "../../types/mediatypes";
 import { FeatureCollection } from "geojson";
 export declare const API_KEY_HEADER = "x-api-key";
-type CheckerFunction = (Res: IncomingMessage) => Promise<void>;
-type JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => Promise<void>;
+declare type CheckerFunction = (Res: IncomingMessage) => Promise<void>;
+declare type JsonCheckerFunction<T> = (json: T, body: string, message: IncomingMessage) => Promise<void>;
 export declare class UrlChecker {
     private readonly requestOptions;
     constructor(hostname: string, apiKey?: string);

package/dist/aws/infra/stack/lambda-configs.d.ts

@@ -3,8 +3,8 @@ import { IVpc, SubnetSelection } from "aws-cdk-lib/aws-ec2";
 import { Role } from "aws-cdk-lib/aws-iam";
 import { DigitrafficStack } from "./stack";
 import { MonitoredFunctionAlarmProps } from "./monitoredfunction";
-export type LambdaEnvironment = Record<string, string>;
-export type DBLambdaEnvironment = LambdaEnvironment & {
+export declare type LambdaEnvironment = Record<string, string>;
+export declare type DBLambdaEnvironment = LambdaEnvironment & {
     SECRET_ID?: string;
     DB_APPLICATION: string;
 };
@@ -27,7 +27,7 @@ export interface FunctionParameters {
     architecture?: Architecture;
     singleLambda?: boolean;
 }
-export type MonitoredFunctionParameters = FunctionParameters & {
+export declare type MonitoredFunctionParameters = FunctionParameters & {
     readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
     readonly durationWarningProps?: MonitoredFunctionAlarmProps;
     readonly errorAlarmProps?: MonitoredFunctionAlarmProps;

package/dist/aws/infra/stack/monitoredfunction.js

@@ -11,39 +11,6 @@ const subscription_1 = require("../stack/subscription");
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
  */
 class MonitoredFunction extends aws_lambda_1.Function {
-    /**
-     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
-     *
-     * @param stack DigitrafficStack
-     * @param id Lambda construct Id
-     * @param functionProps Lambda function properties
-     * @param props Monitored function properties
-     */
-    static create(stack, id, functionProps, props) {
-        if (props === MonitoredFunction.DISABLE_ALARMS &&
-            stack.configuration.production) {
-            throw new Error(
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            `Function ${functionProps.functionName} has DISABLE_ALARMS.  Remove before installing to production or define your own properties!`);
-        }
-        return new MonitoredFunction(stack, id, functionProps, stack.alarmTopic, stack.warningTopic, stack.configuration.production, stack.configuration.trafficType, props);
-    }
-    /**
-     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
-     *
-     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
-     *
-     * @param stack DigitrafficStack
-     * @param name param-case name
-     * @param environment Lambda environment
-     * @param functionParameters Lambda function parameters
-     */
-    static createV2(stack, name, environment, functionParameters) {
-        const functionName = functionParameters?.functionName ??
-            `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
-        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
-        return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
-    }
     /**
      * @param scope Stack
      * @param id Lambda construct Id
@@ -81,6 +48,39 @@ class MonitoredFunction extends aws_lambda_1.Function {
             this.createAlarm(scope, this.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, this.getAlarmActionForEnv(alarmSnsAction, warningSnsAction, production), 0, 1, 1, aws_cloudwatch_1.ComparisonOperator.GREATER_THAN_THRESHOLD, props?.throttleAlarmProps);
         }
     }
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.
+     *
+     * @param stack DigitrafficStack
+     * @param id Lambda construct Id
+     * @param functionProps Lambda function properties
+     * @param props Monitored function properties
+     */
+    static create(stack, id, functionProps, props) {
+        if (props === MonitoredFunction.DISABLE_ALARMS &&
+            stack.configuration.production) {
+            throw new Error(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            `Function ${functionProps.functionName} has DISABLE_ALARMS.  Remove before installing to production or define your own properties!`);
+        }
+        return new MonitoredFunction(stack, id, functionProps, stack.alarmTopic, stack.warningTopic, stack.configuration.production, stack.configuration.trafficType, props);
+    }
+    /**
+     * Create new MonitoredFunction.  Use topics from given DigitrafficStack.  Generate names from given name and configuration shortName.
+     *
+     * For example, shortName FOO and given name update-things will create function FOO-UpdateThings and use code from lambda/update-things/update-things.ts method handler.
+     *
+     * @param stack DigitrafficStack
+     * @param name param-case name
+     * @param environment Lambda environment
+     * @param functionParameters Lambda function parameters
+     */
+    static createV2(stack, name, environment, functionParameters) {
+        const functionName = functionParameters?.functionName ??
+            `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
+        const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
+        return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
+    }
     createAlarm(stack, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, evaluationPeriods, datapointsToAlarm, comparisonOperator, alarmProps) {
         metric
             .createAlarm(stack, `${this.node.id}-${alarmId}`, {

package/dist/aws/runtime/dt-logger-default.d.ts

@@ -0,0 +1,5 @@
+import { DtLogger } from "./dt-logger";
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export declare const logger: DtLogger;

package/dist/aws/runtime/dt-logger-default.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const dt_logger_1 = require("./dt-logger");
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+exports.logger = new dt_logger_1.DtLogger();
+//# sourceMappingURL=dt-logger-default.js.map

package/dist/aws/runtime/dt-logger.d.ts

@@ -1,16 +1,35 @@
 /// <reference types="node" />
 import { Writable } from "stream";
-type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+declare type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
 export interface LoggerConfiguration {
     lambdaName?: string;
     fileName?: string;
     runTime?: string;
     writeStream?: Writable;
 }
-export type LoggableType = string | number | Record<string, unknown>;
+export interface LoggableType {
+    /** name of method logging the message */
+    method: `${string}.${string}`;
+    /** message to log, optional */
+    message?: string;
+    /** type of message, optional */
+    type?: string;
+    /** stack trace, optional */
+    stack?: string;
+    /** 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;
+}
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -21,8 +40,44 @@ export declare class DtLogger {
     readonly runtime?: string;
     readonly writeStream: Writable;
     constructor(config?: LoggerConfiguration);
+    /**
+     * Log given message with level DEBUG
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    debug(message: LoggableType): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
     info(message: LoggableType): void;
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    warn(message: LoggableType): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
     error(message: LoggableType): void;
+    /**
+     * 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".
+     * 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
+     */
     log(level: LOG_LEVEL, message: LoggableType): void;
 }
 export {};

package/dist/aws/runtime/dt-logger.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DtLogger = void 0;
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -16,23 +16,59 @@ class DtLogger {
         this.runtime = config?.runTime ?? process.env.AWS_EXECUTION_ENV;
         this.writeStream = config?.writeStream ?? process.stdout;
     }
+    /**
+     * Log given message with level DEBUG
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    debug(message) {
+        this.log("DEBUG", message);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
     info(message) {
         this.log("INFO", message);
     }
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    warn(message) {
+        this.log("WARN", message);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
     error(message) {
         this.log("ERROR", message);
     }
+    /**
+     * 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".
+     * 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
+     */
     log(level, message) {
-        // put string/number messages into message object
-        const actualMessage = typeof message == "object" ? message : { message: message };
         const logMessage = {
-            ...actualMessage,
-            ...{
-                level,
-                fileName: this.fileName,
-                lambdaName: this.lambdaName,
-                runtime: this.runtime,
-            },
+            ...message,
+            level,
+            fileName: message.fileName ?? this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
         };
         this.writeStream.write(JSON.stringify(logMessage) + "\n");
     }

package/dist/aws/runtime/environment.d.ts

@@ -1 +1,9 @@
+export declare enum EnvKeys {
+    AWS_REGION = "AWS_REGION",
+    SECRET_ID = "SECRET_ID",
+    SECRET_OVERRIDE_AWS_REGION = "SECRET_OVERRIDE_AWS_REGION"
+}
+/**
+ * @deprecated Use digitraffic/common/utils/utils#getEnvVariable
+ */
 export declare function envValue(key: string, defaultValue?: string): string;

package/dist/aws/runtime/environment.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.envValue = void 0;
+exports.envValue = exports.EnvKeys = void 0;
+var EnvKeys;
+(function (EnvKeys) {
+    EnvKeys["AWS_REGION"] = "AWS_REGION";
+    EnvKeys["SECRET_ID"] = "SECRET_ID";
+    EnvKeys["SECRET_OVERRIDE_AWS_REGION"] = "SECRET_OVERRIDE_AWS_REGION";
+})(EnvKeys = exports.EnvKeys || (exports.EnvKeys = {}));
+/**
+ * @deprecated Use digitraffic/common/utils/utils#getEnvVariable
+ */
 function envValue(key, defaultValue) {
     const value = process.env[key];
     if (value == null) {

package/dist/aws/runtime/secrets/dbsecret.d.ts

@@ -11,6 +11,6 @@ export declare enum RdsSecretKey {
     host = "host",
     ro_host = "ro_host"
 }
-export type RdsProxySecret = Record<RdsProxySecretKey, string>;
-export type RdsSecret = Record<RdsSecretKey, string>;
+export declare type RdsProxySecret = Record<RdsProxySecretKey, string>;
+export declare type RdsSecret = Record<RdsSecretKey, string>;
 export declare function checkExpectedSecretKeys<Secret extends GenericSecret>(keys: string[], secret: Secret): void;

package/dist/aws/runtime/secrets/secret-holder.d.ts

@@ -6,6 +6,10 @@ import { GenericSecret } from "./secret";
  * By default, secrets are cached for 5 minutes and then reread from the Secrets Manager(This can be overridden with configuration).
  *
  * Supports setting the database environment paramaters from the secret too.
+ *
+ * If you want secret manager to get values from different region than the lambda runtime is running, you can override this by
+ * setting the region with utils setSecretOverideAwsRegionEnv method.
+ *
  */
 export declare class SecretHolder<Secret extends GenericSecret> {
     private readonly secretId;

package/dist/aws/runtime/secrets/secret-holder.js

@@ -18,6 +18,10 @@ const DEFAULT_CONFIGURATION = {
  * By default, secrets are cached for 5 minutes and then reread from the Secrets Manager(This can be overridden with configuration).
  *
  * Supports setting the database environment paramaters from the secret too.
+ *
+ * If you want secret manager to get values from different region than the lambda runtime is running, you can override this by
+ * setting the region with utils setSecretOverideAwsRegionEnv method.
+ *
  */
 class SecretHolder {
     constructor(secretId, prefix = "", expectedKeys = [], configuration = DEFAULT_CONFIGURATION) {

package/dist/aws/runtime/secrets/secret.d.ts

@@ -1,2 +1,2 @@
-export type GenericSecret = Record<string, string>;
+export declare type GenericSecret = Record<string, string>;
 export declare function getSecret<Secret>(secretId: string, prefix?: string): Promise<Secret>;

package/dist/aws/runtime/secrets/secret.js

@@ -2,11 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSecret = void 0;
 const aws_sdk_1 = require("aws-sdk");
-const smClient = new aws_sdk_1.SecretsManager({
-    region: process.env.AWS_REGION,
-});
+const utils_1 = require("../../../utils/utils");
+const environment_1 = require("../environment");
+// SECRET_OVERRIDE_AWS_REGION might not have been set before import of
+// secret, so we need to lazy initialize SecretsManager
+let smClient;
+function getSmClient() {
+    if (!smClient) {
+        smClient = new aws_sdk_1.SecretsManager({
+            region: (0, utils_1.getEnvVariableOrElse)(environment_1.EnvKeys.SECRET_OVERRIDE_AWS_REGION, // this is override secret region
+            (0, utils_1.getEnvVariable)(environment_1.EnvKeys.AWS_REGION)),
+        });
+    }
+    return smClient;
+}
 async function getSecret(secretId, prefix = "") {
-    const secretObj = await smClient
+    const secretObj = await getSmClient()
         .getSecretValue({
         SecretId: secretId,
     })

package/dist/database/database.d.ts

@@ -6,8 +6,8 @@ export declare enum DatabaseEnvironmentKeys {
     DB_RO_URI = "DB_RO_URI",
     DB_APPLICATION = "DB_APPLICATION"
 }
-export type DTDatabase = IDatabase<unknown>;
-export type DTTransaction = ITask<unknown>;
+export declare type DTDatabase = IDatabase<unknown>;
+export declare type DTTransaction = ITask<unknown>;
 /**
  * Creates a non-pooling database connection primarily used by Lambdas.
  *

package/dist/test/asserter.d.ts

@@ -1,7 +1,7 @@
 /**
  * A simple asserter-class for writing canaries without dependency to testing-libraries.
  */
-type AssertedValue = string | number;
+declare type AssertedValue = string | number;
 export declare abstract class Asserter {
     static assertEquals(value: AssertedValue, expected: AssertedValue): void;
     static assertTrue(value: boolean): void;

package/dist/test/httpserver.d.ts

@@ -14,4 +14,4 @@ export declare class TestHttpServer {
     close(): void;
     private debuglog;
 }
-export type ListenProperties = Record<string, (url?: string, data?: string) => string>;
+export declare type ListenProperties = Record<string, (url?: string, data?: string) => string>;

package/dist/test/secrets-manager.js

@@ -26,6 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mockSecret = exports.stubSecretsManager = void 0;
 const AWS = require("aws-sdk");
 const sinon = __importStar(require("sinon"));
+const environment_1 = require("../aws/runtime/environment");
+const utils_1 = require("../utils/utils");
+(0, utils_1.setEnvVariable)(environment_1.EnvKeys.AWS_REGION, "eu-west-1");
 const secretValue = sinon.stub();
 /**
  * Stub Secrets Manager for tests.  You must call this
@@ -37,7 +40,7 @@ function stubSecretsManager() {
     const smStub = {
         getSecretValue: secretValue,
     };
-    sinon.stub(AWS, 'SecretsManager').returns(smStub);
+    sinon.stub(AWS, "SecretsManager").returns(smStub);
     return smStub.getSecretValue;
 }
 exports.stubSecretsManager = stubSecretsManager;

package/dist/types/aws-env.d.ts

@@ -0,0 +1,3 @@
+export interface AwsEnv {
+    readonly region: string;
+}

package/dist/types/aws-env.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=aws-env.js.map

package/dist/types/either.d.ts

@@ -6,4 +6,4 @@ export interface EitherError {
     result: "error";
     message: string;
 }
-export type Either<T> = EitherOk<T> | EitherError;
+export declare type Either<T> = EitherOk<T> | EitherError;

package/dist/types/urn.d.ts

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

package/dist/utils/logging.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/utils/logging.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logException = void 0;
+const axios_1 = require("axios");
+const utils_1 = require("./utils");
+const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME", "test");
+/**
+ * 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
+ */
+function logException(logger, error, includeStack = false) {
+    const message = error instanceof Error ? error.message : error;
+    const stack = error instanceof Error && includeStack ? error.stack : undefined;
+    const code = error instanceof axios_1.AxiosError ? error.code : undefined;
+    logger.error({
+        type: "Error",
+        method: `${functionName}.logException`,
+        message,
+        code,
+        stack,
+    });
+}
+exports.logException = logException;
+//# sourceMappingURL=logging.js.map

package/dist/utils/utils.d.ts

@@ -1,3 +1,5 @@
+import { AwsEnv } from "../types/aws-env";
+import { Either } from "../types/either";
 /**
  * Check if arrays have only elements that also exists also in other array.
  * Individual element count doesn't matter.
@@ -19,7 +21,6 @@
  * @param a first array to compare
  * @param b second array to compare
  */
-import { Either } from "../types/either";
 export declare function bothArraysHasSameValues(a: null | undefined | unknown[], b: null | undefined | unknown[]): boolean;
 /**
  * Returns the last item on the array.  If the array is empty, throws an error!
@@ -29,6 +30,14 @@ export declare function getLast<T>(array: T[], sortFunction?: (a: T) => number):
  * Returns the first item on the array.  If the array is empty, throws an error!
  */
 export declare function getFirst<T>(array: T[], sortFunction?: (a: T) => number): T;
+/**
+ * Gets basic AWS environment variables. Throws error if variables are not found.
+ *
+ * @param key Environment key
+ * @return string
+ * @See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
+ */
+export declare function getAwsEnv(): AwsEnv;
 /**
  * Gets environment variable. Throws error if variable is not found.
  *
@@ -44,6 +53,13 @@ export declare function getEnvVariable(key: string): string;
  * @return Either<string>
  */
 export declare function getEnvVariableSafe(key: string): Either<string>;
+/**
+ * Sets environment variable.
+ *
+ * @param key Environment key
+ * @param value Environment variable value
+ */
+export declare function setEnvVariable(key: string, value: string): void;
 /**
  * Gets environment variable. If environment variable is undefined, returns value of given function.
  *
@@ -59,3 +75,17 @@ export declare function getEnvVariableOr<T>(key: string, fn: () => T): string |
  * @param orElse Alternative value
  */
 export declare function getEnvVariableOrElse<T>(key: string, orElse: T): string | T;
+export declare function setSecretOverideAwsRegionEnv(region: string): void;
+/**
+ * ESLint won't allow to call Object.prototype builtin methods.
+ * To call hasOwnProperty we must use Object.prototype.hasOwnProperty.call()
+ * @param object to test for property
+ * @param propertyName property name to check
+ * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
+ */
+export declare function hasOwnPropertySafe(object: object, propertyName: string): boolean;
+/**
+ * Return an error message from the given object hat might be an Error object.
+ * @param maybeError
+ */
+export declare function getErrorMessage(maybeError: unknown): string;

package/dist/utils/utils.js

@@ -1,6 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvVariableOrElse = exports.getEnvVariableOr = exports.getEnvVariableSafe = exports.getEnvVariable = exports.getFirst = exports.getLast = exports.bothArraysHasSameValues = void 0;
+exports.getErrorMessage = exports.hasOwnPropertySafe = exports.setSecretOverideAwsRegionEnv = exports.getEnvVariableOrElse = exports.getEnvVariableOr = exports.setEnvVariable = exports.getEnvVariableSafe = exports.getEnvVariable = exports.getAwsEnv = exports.getFirst = exports.getLast = exports.bothArraysHasSameValues = void 0;
+const environment_1 = require("../aws/runtime/environment");
+/**
+ * Check if arrays have only elements that also exists also in other array.
+ * Individual element count doesn't matter.
+ * Function works only for primitive types and for other it just checks the reference to object.
+ *
+ * Some examples
+ * bothArraysHasSameValues( [a, b], [b, a] )    => true
+ * bothArraysHasSameValues( [a, a], [a, a, a] ) => true
+ * bothArraysHasSameValues( [a, b], [a] )       => false
+ *
+ * Object references:
+ * const o1 = { a: 1, b: 2};
+ * const o2 = { a: 1, b: 2};
+ * // Arrays has references to same objects
+ * bothArraysHasSameValues([o1], [o1]))         => true
+ * Arrays have references to different objects
+ * bothArraysHasSameValues([o1], [o2]))         => false
+ *
+ * @param a first array to compare
+ * @param b second array to compare
+ */
 function bothArraysHasSameValues(a, b) {
     if ((a && !b) || (!a && b)) {
         return false;
@@ -40,6 +62,19 @@ function getFirstOrLast(getFirst, array, sortFunction) {
     }
     return array[index];
 }
+/**
+ * Gets basic AWS environment variables. Throws error if variables are not found.
+ *
+ * @param key Environment key
+ * @return string
+ * @See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
+ */
+function getAwsEnv() {
+    return {
+        region: getEnvVariable("AWS_REGION"),
+    };
+}
+exports.getAwsEnv = getAwsEnv;
 /**
  * Gets environment variable. Throws error if variable is not found.
  *
@@ -72,6 +107,16 @@ function getEnvVariableSafe(key) {
     return { result: "ok", value };
 }
 exports.getEnvVariableSafe = getEnvVariableSafe;
+/**
+ * Sets environment variable.
+ *
+ * @param key Environment key
+ * @param value Environment variable value
+ */
+function setEnvVariable(key, value) {
+    process.env[key] = value;
+}
+exports.setEnvVariable = setEnvVariable;
 /**
  * Gets environment variable. If environment variable is undefined, returns value of given function.
  *
@@ -97,4 +142,30 @@ function getEnvVariableOrElse(key, orElse) {
     return getEnvVariableOr(key, () => orElse);
 }
 exports.getEnvVariableOrElse = getEnvVariableOrElse;
+function setSecretOverideAwsRegionEnv(region) {
+    setEnvVariable(environment_1.EnvKeys.SECRET_OVERRIDE_AWS_REGION, region);
+}
+exports.setSecretOverideAwsRegionEnv = setSecretOverideAwsRegionEnv;
+/**
+ * ESLint won't allow to call Object.prototype builtin methods.
+ * To call hasOwnProperty we must use Object.prototype.hasOwnProperty.call()
+ * @param object to test for property
+ * @param propertyName property name to check
+ * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
+ */
+function hasOwnPropertySafe(object, propertyName) {
+    return Object.prototype.hasOwnProperty.call(object, propertyName);
+}
+exports.hasOwnPropertySafe = hasOwnPropertySafe;
+/**
+ * Return an error message from the given object hat might be an Error object.
+ * @param maybeError
+ */
+function getErrorMessage(maybeError) {
+    if (maybeError instanceof Error) {
+        return maybeError.name + ": " + maybeError.message;
+    }
+    return String(maybeError);
+}
+exports.getErrorMessage = getErrorMessage;
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2023.03.10-1",
+  "version": "2023.3.21-1",
   "description": "",
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "axios": "^1.2.6",
     "change-case": "^4.1.2",
     "constructs": "^10.1.222",
-    "eslint": "^8.34.0",
+    "eslint": "~8.34.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-deprecation": "1.3.3",
     "geojson-validation": "^1.0.2",
@@ -62,7 +62,7 @@
     "rimraf": "^4.1.0",
     "sinon": "^15.0.1",
     "ts-jest": "^29.0.5",
-    "typescript": "^4.9.5"
+    "typescript": "~4.8.4"
   },
   "externals": [
     "aws-sdk",
@@ -75,6 +75,7 @@
     "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"
   }

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

@@ -1,3 +1,4 @@
+import { getEnvVariableOrElse } from "../../../utils/utils";
 import { DtLogger } from "../../runtime/dt-logger";
 import { LambdaResponse } from "../../types/lambda-response";
 
@@ -8,6 +9,8 @@ export type LoggingHandler = (
 
 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:
@@ -30,7 +33,7 @@ export class HandlerFactory {
             } finally {
                 console.info(
                     "method=%s.handler tookMs=%d",
-                    process.env.AWS_LAMBDA_FUNCTION_NAME,
+                    functionName,
                     Date.now() - start
                 );
             }
@@ -74,7 +77,10 @@ export function createJsonLoggingHandler(): LoggingHandler {
         try {
             return await method();
         } finally {
-            logger.info({ tookMs: Date.now() - start });
+            logger.info({
+                method: `${functionName}.handler`,
+                tookMs: Date.now() - start,
+            });
         }
     };
 }

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

@@ -0,0 +1,6 @@
+import { DtLogger } from "./dt-logger";
+
+/**
+ * You can use this for your logging needs or create one locally and configure it as you wish.
+ */
+export const logger = new DtLogger();

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

@@ -1,6 +1,6 @@
 import { Writable } from "stream";
 
-type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
 
 export interface LoggerConfiguration {
     lambdaName?: string;
@@ -9,11 +9,30 @@ export interface LoggerConfiguration {
     writeStream?: Writable;
 }
 
-export type LoggableType = string | number | Record<string, unknown>;
+export interface LoggableType {
+    /** name of method logging the message */
+    method: `${string}.${string}`;
+    /** message to log, optional */
+    message?: string;
+    /** type of message, optional */
+    type?: string;
+    /** stack trace, optional */
+    stack?: string;
+    /** 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;
+}
 
 /**
  * Helper class for json-logging.  Logged line will include
- * * log-level (see LOG_LEVEL)
+ * * log-level
  * * lambdaName (taken from process environment)
  * * runtime (taken from process environment)
  * * the actual message (as json or as string)
@@ -33,27 +52,62 @@ export class DtLogger {
         this.writeStream = config?.writeStream ?? process.stdout;
     }
 
-    info(message: LoggableType) {
+    /**
+     * Log given message with level DEBUG
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    debug(message: LoggableType): void {
+        this.log("DEBUG", message);
+    }
+
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    info(message: LoggableType): void {
         this.log("INFO", message);
     }
 
-    error(message: LoggableType) {
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    warn(message: LoggableType): void {
+        this.log("WARN", message);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Either a string or json-object
+     * @see log
+     */
+    error(message: LoggableType): void {
         this.log("ERROR", message);
     }
 
-    log(level: LOG_LEVEL, message: LoggableType) {
-        // put string/number messages into message object
-        const actualMessage =
-            typeof message == "object" ? message : { message: message };
-
+    /**
+     * 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".
+     * 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
+     */
+    log(level: LOG_LEVEL, message: LoggableType): void {
         const logMessage = {
-            ...actualMessage,
-            ...{
-                level,
-                fileName: this.fileName,
-                lambdaName: this.lambdaName,
-                runtime: this.runtime,
-            },
+            ...message,
+            level,
+            fileName: message.fileName ?? this.fileName,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
         };
 
         this.writeStream.write(JSON.stringify(logMessage) + "\n");

package/src/aws/runtime/environment.ts

@@ -1,3 +1,12 @@
+export enum EnvKeys {
+    AWS_REGION = "AWS_REGION",
+    SECRET_ID = "SECRET_ID",
+    SECRET_OVERRIDE_AWS_REGION = "SECRET_OVERRIDE_AWS_REGION",
+}
+
+/**
+ * @deprecated Use digitraffic/common/utils/utils#getEnvVariable
+ */
 export function envValue(key: string, defaultValue?: string): string {
     const value = process.env[key];
 

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

@@ -18,6 +18,10 @@ const DEFAULT_CONFIGURATION = {
  * By default, secrets are cached for 5 minutes and then reread from the Secrets Manager(This can be overridden with configuration).
  *
  * Supports setting the database environment paramaters from the secret too.
+ *
+ * If you want secret manager to get values from different region than the lambda runtime is running, you can override this by
+ * setting the region with utils setSecretOverideAwsRegionEnv method.
+ *
  */
 export class SecretHolder<Secret extends GenericSecret> {
     private readonly secretId: string;

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

@@ -1,8 +1,21 @@
 import { SecretsManager } from "aws-sdk";
-
-const smClient = new SecretsManager({
-    region: process.env.AWS_REGION,
-});
+import { getEnvVariable, getEnvVariableOrElse } from "../../../utils/utils";
+import { EnvKeys } from "../environment";
+
+// SECRET_OVERRIDE_AWS_REGION might not have been set before import of
+// secret, so we need to lazy initialize SecretsManager
+let smClient: SecretsManager | undefined;
+function getSmClient(): SecretsManager {
+    if (!smClient) {
+        smClient = new SecretsManager({
+            region: getEnvVariableOrElse<string>(
+                EnvKeys.SECRET_OVERRIDE_AWS_REGION, // this is override secret region
+                getEnvVariable(EnvKeys.AWS_REGION)
+            ),
+        });
+    }
+    return smClient;
+}
 
 export type GenericSecret = Record<string, string>;
 
@@ -10,7 +23,7 @@ export async function getSecret<Secret>(
     secretId: string,
     prefix = ""
 ): Promise<Secret> {
-    const secretObj = await smClient
+    const secretObj = await getSmClient()
         .getSecretValue({
             SecretId: secretId,
         })

package/src/test/secrets-manager.ts

@@ -1,6 +1,9 @@
-import AWS = require('aws-sdk');
+import AWS = require("aws-sdk");
 import * as sinon from "sinon";
+import { EnvKeys } from "../aws/runtime/environment";
+import { setEnvVariable } from "../utils/utils";
 
+setEnvVariable(EnvKeys.AWS_REGION, "eu-west-1");
 const secretValue = sinon.stub();
 
 /**
@@ -14,7 +17,7 @@ export function stubSecretsManager() {
         getSecretValue: secretValue,
     };
 
-    sinon.stub(AWS, 'SecretsManager').returns(smStub);
+    sinon.stub(AWS, "SecretsManager").returns(smStub);
 
     return smStub.getSecretValue;
 }

package/src/types/aws-env.ts

@@ -0,0 +1,3 @@
+export interface AwsEnv {
+    readonly region: string;
+}

package/src/utils/logging.ts

@@ -0,0 +1,41 @@
+import { AxiosError } from "axios";
+import { DtLogger } from "../aws/runtime/dt-logger";
+import { getEnvVariableOrElse } from "./utils";
+
+const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
+
+export function logException(
+    logger: DtLogger,
+    error: Error | string,
+    includeStack: boolean
+): void;
+export function logException(logger: DtLogger, error: AxiosError): 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 Include stack in the message, default false
+ * @see log
+ */
+export function logException(
+    logger: DtLogger,
+    error: Error | string | AxiosError,
+    includeStack = false
+) {
+    const message = error instanceof Error ? error.message : error;
+    const stack =
+        error instanceof Error && includeStack ? error.stack : undefined;
+    const code = error instanceof AxiosError ? error.code : undefined;
+
+    logger.error({
+        type: "Error",
+        method: `${functionName}.logException`,
+        message,
+        code,
+        stack,
+    });
+}

package/src/utils/utils.ts

@@ -1,3 +1,7 @@
+import { AwsEnv } from "../types/aws-env";
+import { Either } from "../types/either";
+import { EnvKeys } from "../aws/runtime/environment";
+
 /**
  * Check if arrays have only elements that also exists also in other array.
  * Individual element count doesn't matter.
@@ -19,8 +23,6 @@
  * @param a first array to compare
  * @param b second array to compare
  */
-import { Either } from "../types/either";
-
 export function bothArraysHasSameValues(
     a: null | undefined | unknown[],
     b: null | undefined | unknown[]
@@ -72,6 +74,19 @@ function getFirstOrLast<T>(
     return array[index];
 }
 
+/**
+ * Gets basic AWS environment variables. Throws error if variables are not found.
+ *
+ * @param key Environment key
+ * @return string
+ * @See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
+ */
+export function getAwsEnv(): AwsEnv {
+    return {
+        region: getEnvVariable("AWS_REGION"),
+    };
+}
+
 /**
  * Gets environment variable. Throws error if variable is not found.
  *
@@ -104,6 +119,16 @@ export function getEnvVariableSafe(key: string): Either<string> {
     return { result: "ok", value };
 }
 
+/**
+ * Sets environment variable.
+ *
+ * @param key Environment key
+ * @param value Environment variable value
+ */
+export function setEnvVariable(key: string, value: string) {
+    process.env[key] = value;
+}
+
 /**
  * Gets environment variable. If environment variable is undefined, returns value of given function.
  *
@@ -128,3 +153,32 @@ export function getEnvVariableOr<T>(key: string, fn: () => T): string | T {
 export function getEnvVariableOrElse<T>(key: string, orElse: T): string | T {
     return getEnvVariableOr(key, () => orElse);
 }
+
+export function setSecretOverideAwsRegionEnv(region: string) {
+    setEnvVariable(EnvKeys.SECRET_OVERRIDE_AWS_REGION, region);
+}
+
+/**
+ * ESLint won't allow to call Object.prototype builtin methods.
+ * To call hasOwnProperty we must use Object.prototype.hasOwnProperty.call()
+ * @param object to test for property
+ * @param propertyName property name to check
+ * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
+ */
+export function hasOwnPropertySafe(
+    object: object,
+    propertyName: string
+): boolean {
+    return Object.prototype.hasOwnProperty.call(object, propertyName);
+}
+
+/**
+ * Return an error message from the given object hat might be an Error object.
+ * @param maybeError
+ */
+export function getErrorMessage(maybeError: unknown) {
+    if (maybeError instanceof Error) {
+        return maybeError.name + ": " + maybeError.message;
+    }
+    return String(maybeError);
+}