@digitraffic/common 2024.1.24-3 → 2024.3.11-1

package/src/test/httpserver.mts

@@ -1,111 +0,0 @@
-import { Server, createServer } from "http";
-import { parse } from "url";
-
-export const ERROR_NO_MATCH = "NO MATCH";
-export const ERRORCODE_NOT_FOUND = 404;
-
-/**
- * A mock HTTP server created for testing connections from a Lambda to an outside integration
- */
-export class TestHttpServer {
-    private server?: Server;
-    private debug: boolean;
-
-    private messageStack: string[];
-
-    constructor() {
-        this.debug = false;
-        this.messageStack = [];
-    }
-
-    getCallCount(): number {
-        return this.messageStack.length;
-    }
-
-    getRequestBody(callNumber: number): string {
-        return this.messageStack[callNumber];
-    }
-
-    listen(
-        port: number,
-        props: ListenProperties,
-        debug = false,
-        statusCode = 200,
-    ) {
-        this.debug = debug;
-        this.messageStack = [];
-        this.debuglog(`Starting test server on port ${port}`);
-        this.server = createServer((req, res) => {
-            this.debuglog("Mapped urls: ");
-            Object.keys(props).forEach((k) => this.debuglog(k));
-
-            if (!req.url) {
-                throw new Error("Missing request url!");
-            }
-
-            this.debuglog(`Received request to url ${req.url} ..`);
-            const path = parse(req.url).pathname;
-
-            if (!path) {
-                throw new Error("Missing path from request!");
-            }
-
-            let dataStr = "";
-            req.on("data", (chunk) => {
-                if (chunk) {
-                    dataStr += chunk;
-                }
-            });
-
-            if (path in props) {
-                this.debuglog("..url matched");
-                res.setHeader("Access-Control-Allow-Origin", "*");
-                res.setHeader(
-                    "Access-Control-Allow-Headers",
-                    "Authorization,X-User-Id,X-Auth-Token",
-                );
-                res.writeHead(statusCode);
-
-                req.on("end", () => {
-                    // assume sent data is in JSON format
-                    this.messageStack[this.messageStack.length] = dataStr;
-                    res.end(props[path](req.url, dataStr));
-                });
-            } else {
-                this.debuglog(`..no match for ${path}`);
-                req.on("end", () => {
-                    // assume sent data is in JSON format
-                    this.messageStack[this.messageStack.length] =
-                        ERROR_NO_MATCH;
-                    res.writeHead(ERRORCODE_NOT_FOUND);
-                    res.end(ERROR_NO_MATCH);
-                });
-            }
-        });
-        this.server.listen(port);
-    }
-
-    close(): Promise<boolean> {
-        return new Promise((resolve, reject) => {
-            this.debuglog("Closing test server");
-            if (this.server !== undefined) {
-                this.server.close((error) =>
-                    error != null ? reject(false) : resolve(true),
-                );
-            } else {
-                resolve(true);
-            }
-        });
-    }
-
-    private debuglog(str: string) {
-        if (this.debug) {
-            console.debug(str);
-        }
-    }
-}
-
-export type ListenProperties = Record<
-    string,
-    (url?: string, data?: string) => string
->;

package/src/test/secrets-manager.mts

@@ -1,37 +0,0 @@
-import AWS from "aws-sdk";
-import * as sinon from "sinon";
-import { EnvKeys } from "../aws/runtime/environment.mjs";
-import { setEnvVariable } from "../utils/utils.mjs";
-
-setEnvVariable(EnvKeys.AWS_REGION, "eu-west-1");
-const secretValue = sinon.stub();
-
-/**
- * Stub Secrets Manager for tests.  You must call this
- * before you instantiate Secrets Manager(this might happen when you import the function that uses Secrets Manager).
- *
- * To mock the actual secret, call mockSecret()
- */
-export function stubSecretsManager() {
-    const smStub = {
-        getSecretValue: secretValue,
-    };
-
-    sinon.stub(AWS, "SecretsManager").returns(smStub);
-
-    return smStub.getSecretValue;
-}
-
-export function mockSecret<Secret>(secret: Secret) {
-    if (!secret) {
-        secretValue.returns({
-            promise: sinon.stub().returns({}),
-        });
-    } else {
-        secretValue.returns({
-            promise: sinon.stub().returns({
-                SecretString: JSON.stringify(secret),
-            }),
-        });
-    }
-}

package/src/test/testutils.mts

@@ -1,39 +0,0 @@
-export function randomString() : string {
-    return Math.random().toString(36).substring(2);
-}
-
-export function getRandomNumber(min: number , max: number) : number {
-    return Math.random() * (max - min) + min;
-}
-
-export function getRandomNumberAsString(min: number , max: number) : string {
-    return getRandomNumber(min, max).toString();
-}
-
-export function getRandomInteger(min: number , max: number) : number {
-    return Math.round(getRandomNumber(min, max));
-}
-
-export function getRandomIntegerAsString(min: number , max: number) : string {
-    return Math.round(getRandomInteger(min, max)).toString();
-}
-
-export function getRandomBigInt(min: number , max: number) : bigint {
-    return BigInt(getRandomInteger(min, max));
-}
-
-export function randomBoolean(): boolean {
-    return Math.random() < 0.5;
-}
-
-/**
- * Returns a new copy of an array, shuffled using Math.random()
- * @param array Array
- */
-export function shuffle<T>(array: T[]): T[] {
-    // pretty fast way to copy an array, not necessarily the fastest
-    const newArray = array.slice(0);
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    newArray.sort((x) => 0.5 - Math.random());
-    return newArray;
-}

package/src/types/async-timeout-error.mts

@@ -1,5 +0,0 @@
-export class AsyncTimeoutError extends Error {
-    constructor() {
-        super("Async operation timed out");
-    }
-}

package/src/types/aws-env.mts

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

package/src/types/either.mts

@@ -1,9 +0,0 @@
-export interface EitherOk<T> {
-    result: "ok";
-    value: T;
-}
-export interface EitherError {
-    result: "error";
-    message: string;
-}
-export type Either<T> = EitherOk<T> | EitherError;

package/src/types/http-error.mts

@@ -1,8 +0,0 @@
-export class HttpError extends Error {
-    statusCode: number;
-
-    constructor(statusCode: number, message: string) {
-        super(message);
-        this.statusCode = statusCode;
-    }
-}

package/src/types/input-error.mts

@@ -1,2 +0,0 @@
-export class InputError extends Error {
-}

package/src/types/language.mts

@@ -1,3 +0,0 @@
-export enum Language {
-    FI = 'fi', EN = 'en', SV = 'sv'
-}

package/src/types/nullable.mts

@@ -1,21 +0,0 @@
-import { ValueOf } from "./util-types.mjs";
-
-/**
- * Adds `null` as an accepted type to all properties in given type.
- */
-export type Nullable<Obj> = { [Key in keyof Obj]: Obj[Key] | null };
-
-type RequiredKeys<Obj> = ValueOf<{
-    [Key in keyof Obj]-?: object extends { [K in Key]: Obj[Key] } ? never : Key;
-}>;
-type OptionalKeys<Obj> = ValueOf<{
-    [Key in keyof Obj]-?: object extends { [K in Key]: Obj[Key] } ? Key : never;
-}>;
-type RequiredProperties<Obj> = Pick<Obj, RequiredKeys<Obj>>;
-type OptionalProperties<Obj> = Pick<Obj, OptionalKeys<Obj>>;
-
-/**
- * Adds `null` as an accepted type to all optional properties in given type. Required properties remain unchanged.
- */
-export type NullableOptional<Obj> = RequiredProperties<Obj> &
-    Nullable<OptionalProperties<Obj>>;

package/src/types/traffictype.mts

@@ -1,8 +0,0 @@
-export enum TrafficType {
-    ROAD = 'Road',
-    MARINE = 'Marine',
-    RAIL = 'Rail',
-    AVIATION = 'Aviation',
-    MCP = 'MCP',
-    OTHER = 'Other'
-}

package/src/types/urn.mts

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

package/src/types/util-types.mts

@@ -1,10 +0,0 @@
-export type ValueOf<Obj> = Obj[keyof Obj];
-
-/**
- * Type-level conversion from readonly object to mutable object. Use with caution!
- *
- * Only converts in the type-level. Caution must be used, as the typescript cannot enforce readonly-ness at
- * runtime. This is only useful for type-checking and especially in cases where 3rd party code requires
- * mutable even though it is not needed.
- */
-export type Writable<T> = { -readonly [P in keyof T]: T[P] };

package/src/types/validator.mts

@@ -1,10 +0,0 @@
-export const MIN_YEAR = 1900;
-export const MAX_YEAR = 2100;
-
-export function validateYear(year: number, minYear = MIN_YEAR, maxYear = MAX_YEAR) {
-    return year >= minYear && year <= maxYear;
-}
-
-export function validateMonth(month: number) {
-    return month > 0 && month < 13;
-}

package/src/utils/api-model.mts

@@ -1,133 +0,0 @@
-import {
-    RestApi,
-    Model,
-    JsonSchema,
-    RequestValidator,
-    JsonSchemaType,
-    JsonSchemaVersion,
-} from 'aws-cdk-lib/aws-apigateway';
-import {ModelWithReference} from "../aws/types/model-with-reference.mjs";
-
-/**
- * Get a reference to an OpenAPI model object in a REST API.
- * Can be used to supply a reference to properties of a GeoJSON feature.
- * @param modelId Id of the referenced object
- * @param restApiId Id of the REST API
- */
-export function getModelReference(modelId: string, restApiId: string) {
-    return `https://apigateway.amazonaws.com/restapis/${restApiId}/models/${modelId}`;
-}
-
-/**
- * Adds a request validator to a REST API to enforce request parameters/body requirements.
- * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html
- * @param api REST API
- */
-export function addDefaultValidator(api: RestApi): RequestValidator {
-    return api.addRequestValidator('DefaultValidator', {
-        validateRequestParameters: true,
-        validateRequestBody: true,
-    });
-}
-
-/**
- * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
- * This method adds a schema for _a single object._
- * @param name Name of the model
- * @param api REST API
- * @param schema JSON Schema
- * @return ModelWithReference A model object with a reference to an API Gateway model object.
- */
-export function addServiceModel(modelName: string, api: RestApi, schema: JsonSchema): ModelWithReference {
-    const mwr = api.addModel(modelName, {
-        contentType: 'application/json',
-        modelName,
-        schema,
-    }) as ModelWithReference;
-    mwr.modelReference = getModelReference(mwr.modelId, api.restApiId);
-    return mwr;
-}
-
-/**
- * Add an empty JSON schema model to an API Gateway API.
- * Usable for example if the incoming data is in XML format but some template transformation is necessary.
- * @param modelName
- * @param api
- * @param contentType
- */
-export function addSimpleServiceModel(modelName: string, api: RestApi, contentType = 'application/xml'): Model {
-    return api.addModel(modelName, {
-        contentType,
-        modelName,
-        schema: {},
-    });
-}
-
-/**
- * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
- * This method adds a schema for _an array._
- * @param model
- * @param api
- */
-export function createArraySchema(model: Model, api: RestApi): JsonSchema {
-    return {
-        type: JsonSchemaType.ARRAY,
-        items: {
-            ref: getModelReference(model.modelId, api.restApiId),
-        },
-    };
-}
-
-/**
- * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.
- * @param modelReference Reference to a model object
- */
-export function featureSchema(modelReference: string) {
-    return {
-        schema: JsonSchemaVersion.DRAFT4,
-        type: JsonSchemaType.OBJECT,
-        description: 'GeoJson Feature',
-        required: ['type', 'properties', 'geometry'],
-        properties: {
-            type: {
-                type: JsonSchemaType.STRING,
-                description: 'Feature',
-                enum: ['Feature'],
-            },
-            properties: {
-                ref: modelReference,
-            },
-            geometry: {
-                type: JsonSchemaType.OBJECT,
-                description: 'GeoJSON geometry',
-            },
-        },
-    };
-}
-
-/**
- *
- * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.
- * @param modelReference Reference to a model object, in this case Features.
- */
-export function geojsonSchema(modelReference: string) {
-    return {
-        schema: JsonSchemaVersion.DRAFT4,
-        type: JsonSchemaType.OBJECT,
-        description: 'GeoJson FeatureCollection',
-        required: ['type', 'features'],
-        properties: {
-            type: {
-                type: JsonSchemaType.STRING,
-                description: 'FeatureCollection',
-                enum: ['FeatureCollection'],
-            },
-            features: {
-                type: JsonSchemaType.ARRAY,
-                items: {
-                    ref: modelReference,
-                },
-            },
-        },
-    };
-}

package/src/utils/base64.mts

@@ -1,16 +0,0 @@
-/**
- * Decode given string from base64 to ascii
- * @param str string
- */
-export function decodeBase64ToAscii(str: string) {
-    return decodeBase64(str, 'ascii');
-}
-
-/**
- * Decode given string from base64 to given encoding
- * @param str
- * @param encoding
- */
-export function decodeBase64(str: string, encoding: BufferEncoding) {
-    return Buffer.from(str, 'base64').toString(encoding);
-}

package/src/utils/date-utils.mts

@@ -1,53 +0,0 @@
-import { formatInTimeZone } from "date-fns-tz";
-
-/**
- * Constant for the 1970-01-01T00:00:00Z epoch Date.
- */
-export const EPOCH = new Date(Date.UTC(1970, 0, 1));
-
-export const UTC = "UTC";
-
-export const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
-
-/**
- * Counts difference in milliseconds between dates.
- * @param start
- * @param end
- */
-export function countDiffMs(start: Date, end: Date): number {
-    return end.getTime() - start.getTime();
-}
-
-/**
- * Counts difference in seconds between dates.
- * @param start
- * @param end
- */
-export function countDiffInSeconds(start: Date, end: Date): number {
-    return countDiffMs(start, end) / 1000;
-}
-
-/**
- * Converts ISO 8601 date-time -string to Date object
- * @param isoString to convert
- */
-export function dateFromIsoString(isoString: string): Date {
-    const parsed = new Date(isoString);
-    if (!isValidDate(parsed)) {
-        throw new Error(
-            `Could not parse iso date-time string: "${isoString}" to date`
-        );
-    }
-    return parsed;
-}
-
-function isValidDate(d: unknown) {
-    return d instanceof Date && !isNaN(d.getTime());
-}
-
-/**
- * Formats a date in UTC in the given format, regardless of system time zone
- */
-export function dateToUTCString(date: Date, format: string): string {
-    return formatInTimeZone(date, UTC, format);
-}

package/src/utils/geojson-types.mts

@@ -1,22 +0,0 @@
-/**
- * GeoJSON types
- */
-import {LineString, Point, Position} from "geojson";
-
-export class GeoJsonPoint implements Point {
-    readonly type = "Point";
-    readonly coordinates: Position;
-
-    constructor(coordinates: Position) {
-        this.coordinates = coordinates;
-    }
-}
-
-export class GeoJsonLineString implements LineString {
-    readonly type = "LineString";
-    readonly coordinates: Position[];
-
-    constructor(coordinates: Position[]) {
-        this.coordinates = coordinates;
-    }
-}

package/src/utils/geometry.mts

@@ -1,171 +0,0 @@
-/**
- * GeoJSON functions and tools
- */
-import { Feature, FeatureCollection, Geometry, Position } from "geojson";
-import * as geoJsonValidator from "geojson-validation";
-import { logger } from "../aws/runtime/dt-logger-default.mjs";
-
-export const SRID_WGS84 = 4326;
-
-/**
- * Creates WKT geometry from GeoJSON geometry
- * @param geometry GeoJson geometry to convert to WKT
- */
-export function createGeometry(geometry: Geometry): string {
-    if (geometry.type === "LineString") {
-        const coordinates = linestring(geometry.coordinates);
-
-        return `LINESTRING(${coordinates})`;
-    } else if (geometry.type === "Point") {
-        const coordinates = coordinatePair(geometry.coordinates);
-
-        return `POINT(${coordinates})`;
-    } else if (geometry.type === "Polygon") {
-        const coordinates = polygon(geometry.coordinates);
-
-        return `POLYGON(${coordinates})`;
-    } else if (geometry.type === "MultiPolygon") {
-        const coordinates = multiPolygon(geometry.coordinates);
-
-        return `MULTIPOLYGON(${coordinates})`;
-    }
-
-    logger.error({
-        method: "Geometry.createGeometry",
-        message: "Unsupported locationType " + geometry.type,
-    });
-
-    return "POLYGON EMPTY";
-}
-
-function linestring(coordinates: Position[]): string {
-    return coordinates.map((c: Position) => coordinatePair(c)).join(",");
-}
-
-function polygon(coordinates: Position[][]): string {
-    const list = coordinates.map((c: Position[]) => linestring(c)).join(",");
-    return `(${list})`;
-}
-
-function multiPolygon(coordinates: Position[][][]): string {
-    const list = coordinates.map((c: Position[][]) => polygon(c)).join(",");
-    return `(${list})`;
-}
-
-function coordinatePair(coordinate: Position): string {
-    return `${coordinate[0]} ${coordinate[1]}`;
-}
-
-/**
- * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property
- * @param features List of Features
- * @param lastUpdated Last updated date
- */
-export function createFeatureCollection(
-    features: Feature[],
-    lastUpdated: Date | null
-): FeatureCollection {
-    return {
-        type: "FeatureCollection",
-        lastUpdated: lastUpdated,
-        features: features,
-    } as FeatureCollection;
-}
-
-export function isValidGeoJson<T>(json: T): boolean {
-    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
-    return geoJsonValidator.valid(json) as unknown as boolean;
-}
-
-export function isFeatureCollection<T>(json: T): boolean {
-    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
-    return geoJsonValidator.isFeatureCollection(json) as unknown as boolean;
-}
-
-const DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180
-const EARTH_RADIUS_KM = 6371;
-
-/**
- * Returns the distance between this and given GeoJSON point in kilometers. Doesn't take in account altitude.
- * Based on the following Stack Overflow question:
- * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
- * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
- */
-function distanceBetweenWGS84PointsInKm(
-    fromXLon: number,
-    fromYLat: number,
-    toXLon: number,
-    toYLat: number
-): number {
-    const diffLat = toRadians(toYLat - fromYLat);
-    const diffLon = toRadians(toXLon - fromXLon);
-
-    const a =
-        Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +
-        Math.cos(toRadians(fromYLat)) *
-            Math.cos(toRadians(toYLat)) *
-            Math.sin(diffLon / 2) *
-            Math.sin(diffLon / 2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    return EARTH_RADIUS_KM * c;
-}
-
-/**
- * Calculates distance between two GeoJSON points (WGS84)
- * @param pos1
- * @param pos2
- */
-export function distanceBetweenPositionsInKm(pos1: Position, pos2: Position) {
-    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);
-}
-
-export function areDistinctPositions(previous: Position, next: Position) {
-    return previous[0] !== next[0] || previous[1] !== next[1];
-}
-
-/**
- * Calculates distance between two GeoJSON points (WGS84)
- * @param pos1
- * @param pos2
- */
-export function distanceBetweenPositionsInM(pos1: Position, pos2: Position) {
-    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
-}
-
-export function createGmlLineString(geometry: Geometry, srsName = "EPSG:4326") {
-    const posList = createPosList(geometry);
-
-    return {
-        srsName,
-        posList,
-    };
-}
-
-function createPosList(geometry: Geometry) {
-    if (geometry.type === "Point") {
-        return positionToList(geometry.coordinates);
-    } else if (geometry.type === "LineString") {
-        return lineStringToList(geometry.coordinates);
-    } else if (geometry.type === "Polygon") {
-        return polygonToList(geometry.coordinates);
-    }
-
-    throw new Error("unknown geometry type " + JSON.stringify(geometry));
-}
-
-function polygonToList(positions: Position[][], precision = 8) {
-    return positions.map((p) => lineStringToList(p, precision)).join(" ");
-}
-
-function lineStringToList(positions: Position[], precision = 8) {
-    return positions.map((p) => positionToList(p, precision)).join(" ");
-}
-
-export function positionToList(position: Position, precision = 8) {
-    return position.map((n) => n.toPrecision(precision)).join(" ");
-}
-
-// Converts numeric degrees to radians
-function toRadians(angdeg: number) {
-    return angdeg * DEGREES_TO_RADIANS;
-}