@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

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

@@ -0,0 +1,117 @@
+import type { Writable } from "node:stream";
+/** Logging level */
+export type LOG_LEVEL = "DEBUG" | "INFO" | "WARN" | "ERROR";
+export type LoggerMethodType = `${string}.${string}`;
+/**
+ * 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;
+}
+/**
+ * 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 | bigint | 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: LoggerMethodType;
+    /** Message to log, optional */
+    message?: string;
+    /** Type of message, optional */
+    type?: string;
+    /** Stack trace, optional */
+    stack?: string | undefined;
+    /** Amount of time some operation took in milliseconds, optional */
+    tookMs?: number;
+    /** Pass error object, which will be stringified before logging */
+    error?: unknown;
+}
+/**
+ * Helper class for json-logging.
+ *
+ * Logged line will include:
+ * * log-level
+ * * lambdaName (taken from process environment)
+ * * runtime (taken from process environment)
+ * * the actual message (as json or as string)
+ */
+export declare class DtLogger {
+    readonly lambdaName?: 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);
+    /**
+     * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
+     *
+     * @param message anything
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    debug(message: unknown): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    info(message: LoggableType): void;
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    warn(message: LoggableType): void;
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    error(message: LoggableType): void;
+    /**
+     * 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
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     */
+    private log;
+    private appendMessageFieldsToMessage;
+}

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

@@ -0,0 +1,159 @@
+import { lowerFirst, mapKeys } from "es-toolkit";
+import { getEnvVariableOrElse } from "../../utils/utils.js";
+/**
+ * Helper class for json-logging.
+ *
+ * Logged line will include:
+ * * log-level
+ * * lambdaName (taken from process environment)
+ * * runtime (taken from process environment)
+ * * the actual message (as json or as string)
+ */
+export class DtLogger {
+    lambdaName;
+    runtime;
+    writeStream;
+    /**
+     * Create a new Logger instance.
+     * @constructor
+     * @param {LoggerConfiguration?} [config] - Accepts configuration options @see {@link LoggerConfiguration}
+     */
+    constructor(config) {
+        this.lambdaName =
+            config?.lambdaName ??
+                getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "unknown lambda name");
+        this.runtime =
+            config?.runTime ??
+                getEnvVariableOrElse("AWS_EXECUTION_ENV", "unknown runtime");
+        this.writeStream = config?.writeStream ?? process.stdout;
+    }
+    /**
+     * Log given message with level DEBUG.  This will not be forwarded to centralized logging system!.
+     *
+     * @param message anything
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    debug(message) {
+        const logMessage = {
+            message,
+            level: "DEBUG",
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
+        };
+        this.writeStream.write(`${JSON.stringify(logMessage)}\n`);
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    info(message) {
+        this.log({ ...message, level: "INFO" });
+    }
+    /**
+     * Log given message with level WARN
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    warn(message) {
+        this.log({ ...message, level: "WARN" });
+    }
+    /**
+     * Log given message with level INFO
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     * @see {@link DtLogger.log}
+     */
+    error(message) {
+        this.log({
+            ...message,
+            level: "ERROR",
+        });
+    }
+    /**
+     * 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
+     *
+     * @param message Json-object to log
+     * @see {@link LoggableType}
+     */
+    log(message) {
+        // Append always method to message
+        if (!message.message ||
+            !message.message.length ||
+            !message.message.includes(message.method)) {
+            message.message = `${message.method} ${message.message ?? ""}`;
+        }
+        const error = message.error
+            ? message.error instanceof Error
+                ? `${message.error.name}: ${message.error.message}`
+                : typeof message.error === "string"
+                    ? message.error
+                    : JSON.stringify(message.error)
+            : undefined;
+        const stack = message.stack
+            ? message.stack
+            : message.error
+                ? message.error instanceof Error
+                    ? message.error.stack
+                    : undefined
+                : undefined;
+        const messageFields = removePrefix("custom", message);
+        messageFields.message = this.appendMessageFieldsToMessage(messageFields);
+        const logMessage = {
+            ...messageFields,
+            error,
+            stack,
+            lambdaName: this.lambdaName,
+            runtime: this.runtime,
+        };
+        this.writeStream.write(`${JSON.stringify(logMessage)}\n`);
+    }
+    appendMessageFieldsToMessage(message) {
+        // The order is not guaranteed to be alphabetical etc.
+        const fielValuePairs = Object.entries(message)
+            // Remove fields not logged in message field
+            .filter(([key]) => {
+            return (!["message", "level", "method", "stack", "error"].includes(key) &&
+                !(message.message ?? "").includes(`${key}=`));
+        })
+            // Map value to string
+            .map(([key, value]) => `${key}=${valueToString(value)}`)
+            .join(" ");
+        return `${message.message ?? ""}${fielValuePairs ? ` ${fielValuePairs}` : ""}`;
+    }
+}
+/**
+ * Removes given prefixes from the keys of the object.
+ */
+function removePrefix(prefix, loggable) {
+    return mapKeys(loggable, (_index, key) => key.startsWith(prefix) ? lowerFirst(key.replace(prefix, "")) : key);
+}
+function valueToString(value) {
+    if (value === undefined) {
+        return "undefined";
+    }
+    else if (value === null) {
+        return "null";
+    }
+    else if (value instanceof Date) {
+        return value.toISOString();
+    }
+    else if (typeof value !== "string") {
+        return JSON.stringify(value);
+    }
+    else if (value.includes("=")) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+//# sourceMappingURL=dt-logger.js.map

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

@@ -0,0 +1,5 @@
+export declare enum EnvKeys {
+    AWS_REGION = "AWS_REGION",
+    SECRET_ID = "SECRET_ID",
+    SECRET_OVERRIDE_AWS_REGION = "SECRET_OVERRIDE_AWS_REGION"
+}

package/dist/aws/runtime/environment.js

@@ -0,0 +1,7 @@
+export var EnvKeys;
+(function (EnvKeys) {
+    EnvKeys["AWS_REGION"] = "AWS_REGION";
+    EnvKeys["SECRET_ID"] = "SECRET_ID";
+    EnvKeys["SECRET_OVERRIDE_AWS_REGION"] = "SECRET_OVERRIDE_AWS_REGION";
+})(EnvKeys || (EnvKeys = {}));
+//# sourceMappingURL=environment.js.map

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

@@ -0,0 +1,3 @@
+import type { ObjectCannedACL, S3Client } from "@aws-sdk/client-s3";
+import type { NodeJsRuntimeStreamingBlobPayloadInputTypes } from "@smithy/types";
+export declare function uploadToS3(s3: S3Client, bucketName: string, body: NodeJsRuntimeStreamingBlobPayloadInputTypes, objectName: string, cannedAcl?: ObjectCannedACL, contentType?: string): Promise<void>;

package/dist/aws/runtime/s3.js

@@ -0,0 +1,21 @@
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+import { logger } from "./dt-logger-default.js";
+export async function uploadToS3(s3, bucketName, body, objectName, cannedAcl, contentType) {
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: objectName,
+        Body: body,
+        ACL: cannedAcl,
+        ContentType: contentType,
+    });
+    try {
+        await s3.send(command);
+    }
+    catch (_error) {
+        logger.error({
+            method: "s3.uploadToS3",
+            message: `upload failed to bucket ${bucketName}`,
+        });
+    }
+}
+//# sourceMappingURL=s3.js.map

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

@@ -0,0 +1,16 @@
+import type { GenericSecret } from "./secret.js";
+export declare enum RdsProxySecretKey {
+    username = "username",
+    password = "password",
+    proxy_host = "proxy_host",
+    proxy_ro_host = "proxy_ro_host"
+}
+export declare enum RdsSecretKey {
+    username = "username",
+    password = "password",
+    host = "host",
+    ro_host = "ro_host"
+}
+export type RdsProxySecret = Record<RdsProxySecretKey, string>;
+export type RdsSecret = Record<RdsSecretKey, string>;
+export declare function checkExpectedSecretKeys<Secret extends GenericSecret>(keys: string[], secret: Secret): void;

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

@@ -0,0 +1,26 @@
+import { logger } from "../dt-logger-default.js";
+export var RdsProxySecretKey;
+(function (RdsProxySecretKey) {
+    RdsProxySecretKey["username"] = "username";
+    RdsProxySecretKey["password"] = "password";
+    RdsProxySecretKey["proxy_host"] = "proxy_host";
+    RdsProxySecretKey["proxy_ro_host"] = "proxy_ro_host";
+})(RdsProxySecretKey || (RdsProxySecretKey = {}));
+export var RdsSecretKey;
+(function (RdsSecretKey) {
+    RdsSecretKey["username"] = "username";
+    RdsSecretKey["password"] = "password";
+    RdsSecretKey["host"] = "host";
+    RdsSecretKey["ro_host"] = "ro_host";
+})(RdsSecretKey || (RdsSecretKey = {}));
+export function checkExpectedSecretKeys(keys, secret) {
+    const missingKeys = keys.filter((key) => !(key in secret));
+    if (missingKeys.length) {
+        logger.error({
+            method: "dbsecret.checkExpectedSecretKeys",
+            message: `secret didn't contain the key(s) ${missingKeys.toString()}`,
+        });
+        throw new Error("Expected keys were not found");
+    }
+}
+//# sourceMappingURL=dbsecret.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Holds credentials for RDS Proxy access.
+ */
+export declare class ProxyHolder {
+    private readonly secretHolder;
+    constructor(secretId: string);
+    static create(): ProxyHolder;
+    setCredentials(): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+import { DatabaseEnvironmentKeys } from "../../../database/database.js";
+import { getEnvVariable, setEnvVariable } from "../../../utils/utils.js";
+import { RdsProxySecretKey } from "./dbsecret.js";
+import { SecretHolder } from "./secret-holder.js";
+const RDS_PROXY_SECRET_KEYS = Object.values(RdsProxySecretKey);
+/**
+ * Holds credentials for RDS Proxy access.
+ */
+export class ProxyHolder {
+    secretHolder;
+    constructor(secretId) {
+        this.secretHolder = new SecretHolder(secretId, "", RDS_PROXY_SECRET_KEYS);
+    }
+    static create() {
+        return new ProxyHolder(getEnvVariable("SECRET_ID"));
+    }
+    async setCredentials() {
+        const secret = await this.secretHolder.get();
+        setEnvVariable(DatabaseEnvironmentKeys.DB_USER, secret.username);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_PASS, secret.password);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_URI, secret.proxy_host);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_RO_URI, secret.proxy_ro_host);
+    }
+}
+//# sourceMappingURL=proxy-holder.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Holds credentials for RDS access.
+ */
+export declare class RdsHolder {
+    private readonly secretHolder;
+    constructor(secretId: string);
+    static create(): RdsHolder;
+    setCredentials(): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+import { DatabaseEnvironmentKeys } from "../../../database/database.js";
+import { getEnvVariable, setEnvVariable } from "../../../utils/utils.js";
+import { RdsSecretKey } from "./dbsecret.js";
+import { SecretHolder } from "./secret-holder.js";
+const RDS_SECRET_KEYS = Object.values(RdsSecretKey);
+/**
+ * Holds credentials for RDS access.
+ */
+export class RdsHolder {
+    secretHolder;
+    constructor(secretId) {
+        this.secretHolder = new SecretHolder(secretId, "", RDS_SECRET_KEYS);
+    }
+    static create() {
+        return new RdsHolder(getEnvVariable("SECRET_ID"));
+    }
+    async setCredentials() {
+        const secret = await this.secretHolder.get();
+        setEnvVariable(DatabaseEnvironmentKeys.DB_USER, secret.username);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_PASS, secret.password);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_URI, secret.host);
+        setEnvVariable(DatabaseEnvironmentKeys.DB_RO_URI, secret.ro_host);
+    }
+}
+//# sourceMappingURL=rds-holder.js.map

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

@@ -0,0 +1,30 @@
+import type { GenericSecret } from "./secret.js";
+declare const DEFAULT_CONFIGURATION: {
+    readonly ttl: number;
+};
+/**
+ * Utility class for getting secrets from Secret Manager.
+ * Supports prefix for secrets, checking of expected keys and ttl-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 declare class SecretHolder<Secret extends GenericSecret> {
+    private readonly secretId;
+    private readonly prefix;
+    private readonly expectedKeys;
+    private cachedSecret?;
+    private expirationTime;
+    private readonly ttl;
+    constructor(secretId: string, prefix?: string, expectedKeys?: string[], configuration?: typeof DEFAULT_CONFIGURATION);
+    private initSecret;
+    static create<S extends GenericSecret>(prefix?: string, expectedKeys?: string[]): SecretHolder<S>;
+    get(): Promise<Secret>;
+    private parseSecret;
+    private getSecret;
+}
+export {};

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

@@ -0,0 +1,81 @@
+import { getEnvVariable } from "../../../utils/utils.js";
+import { logger } from "../dt-logger-default.js";
+import { checkExpectedSecretKeys } from "./dbsecret.js";
+import { getSecret } from "./secret.js";
+const DEFAULT_PREFIX = "";
+const DEFAULT_CONFIGURATION = {
+    ttl: 5 * 60, // timeout secrets in 5 minutes
+};
+/**
+ * Utility class for getting secrets from Secret Manager.
+ * Supports prefix for secrets, checking of expected keys and ttl-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 {
+    secretId;
+    prefix;
+    expectedKeys;
+    cachedSecret;
+    expirationTime;
+    ttl; // seconds
+    constructor(secretId, prefix = "", expectedKeys = [], configuration = DEFAULT_CONFIGURATION) {
+        this.secretId = secretId;
+        this.prefix = prefix;
+        this.expectedKeys = expectedKeys;
+        this.expirationTime = new Date(0);
+        this.ttl = configuration.ttl;
+    }
+    async initSecret() {
+        const secretValue = await getSecret(this.secretId);
+        logger.info({
+            method: "SecretHolder.initSecret",
+            message: `Refreshing secret ${this.secretId}`,
+        });
+        this.cachedSecret = secretValue;
+        this.expirationTime = new Date(Date.now() + this.ttl * 1000);
+    }
+    static create(prefix = DEFAULT_PREFIX, expectedKeys = []) {
+        return new SecretHolder(getEnvVariable("SECRET_ID"), prefix, expectedKeys);
+    }
+    async get() {
+        const secret = await this.getSecret();
+        const parsedSecret = this.prefix === DEFAULT_PREFIX
+            ? secret
+            : this.parseSecret(secret, `${this.prefix}.`);
+        if (this.expectedKeys.length > 0) {
+            checkExpectedSecretKeys(this.expectedKeys, parsedSecret);
+        }
+        return parsedSecret;
+    }
+    parseSecret(secret, prefix) {
+        const parsed = {};
+        const skip = prefix.length;
+        for (const key in secret) {
+            if (key.startsWith(prefix)) {
+                const withoutPrefix = key.substring(skip);
+                // skip undefined values
+                if (!secret[key]) {
+                    continue;
+                }
+                parsed[withoutPrefix] = secret[key];
+            }
+        }
+        return parsed;
+    }
+    async getSecret() {
+        if (this.expirationTime.getTime() < Date.now()) {
+            await this.initSecret();
+        }
+        if (this.cachedSecret === undefined) {
+            throw new Error("SecretHolder in illegal state");
+        }
+        return this.cachedSecret;
+    }
+}
+//# sourceMappingURL=secret-holder.js.map

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

@@ -0,0 +1,8 @@
+export type GenericSecret = Record<string, string>;
+export declare function getSecret<Secret>(secretId: string, prefix?: string): Promise<Secret>;
+/**
+ * Gets variable from environment or from an AWS Secrets Manager secret if not found in the environment.
+ * @param Environment key
+ * @param Secret id in Secrets Manager
+ */
+export declare function getFromEnvOrSecret(key: string, secretId: string): Promise<string>;

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

@@ -0,0 +1,61 @@
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+import { getEnvVariable, getEnvVariableOrElse, getEnvVariableSafe, } from "../../../utils/utils.js";
+import { EnvKeys } from "../environment.js";
+// 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 SecretsManager({
+            region: getEnvVariableOrElse(EnvKeys.SECRET_OVERRIDE_AWS_REGION, // this is override secret region
+            getEnvVariable(EnvKeys.AWS_REGION)),
+        });
+    }
+    return smClient;
+}
+export async function getSecret(secretId, prefix = "") {
+    const secretObj = await getSmClient().getSecretValue({
+        SecretId: secretId,
+    });
+    if (!secretObj.SecretString) {
+        throw new Error("No secret found!");
+    }
+    const secret = JSON.parse(secretObj.SecretString);
+    if (!prefix) {
+        return secret;
+    }
+    return parseSecret(secret, `${prefix}.`);
+}
+function parseSecret(secret, prefix) {
+    const parsed = {};
+    const skip = prefix.length;
+    for (const key in secret) {
+        if (key.startsWith(prefix)) {
+            const withoutPrefix = key.substring(skip);
+            // skip undefined values
+            if (!secret[key]) {
+                continue;
+            }
+            parsed[withoutPrefix] = secret[key];
+        }
+    }
+    return parsed;
+}
+/**
+ * Gets variable from environment or from an AWS Secrets Manager secret if not found in the environment.
+ * @param Environment key
+ * @param Secret id in Secrets Manager
+ */
+export async function getFromEnvOrSecret(key, secretId) {
+    const envValue = getEnvVariableSafe(key);
+    if (envValue.result === "ok") {
+        return envValue.value;
+    }
+    const secret = await getSecret(secretId);
+    const secretValue = secret[key];
+    if (secretValue !== undefined) {
+        return secretValue;
+    }
+    throw new Error(`Cannot get value with key ${key} from env or secret`);
+}
+//# sourceMappingURL=secret.js.map

package/dist/aws/types/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const NOT_FOUND_MESSAGE = "NOT_FOUND";
+export declare const ERROR_MESSAGE = "ERROR";
+export declare const OK_MESSAGE = "OK";
+export declare const BAD_REQUEST_MESSAGE = "BAD REQUEST";
+export declare class ValidationError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, body: string);
+}

package/dist/aws/types/errors.js

@@ -0,0 +1,13 @@
+// DEPRECATED, remove these!
+export const NOT_FOUND_MESSAGE = "NOT_FOUND";
+export const ERROR_MESSAGE = "ERROR";
+export const OK_MESSAGE = "OK";
+export const BAD_REQUEST_MESSAGE = "BAD REQUEST";
+export class ValidationError extends Error {
+    statusCode;
+    constructor(statusCode, body) {
+        super(body);
+        this.statusCode = statusCode;
+    }
+}
+//# sourceMappingURL=errors.js.map