@digitraffic/common 2022.10.25-1 → 2022.10.31-1

package/src/utils/geometry.ts

@@ -0,0 +1,164 @@
+/**
+ * GeoJSON functions and tools
+ */
+import { Feature, FeatureCollection, Geometry, Position } from "geojson";
+import * as geoJsonValidator from "geojson-validation";
+
+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})`;
+    }
+
+    console.error("unsupported locationType=%s", 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 {
+    return geoJsonValidator.valid(json);
+}
+
+export function isFeatureCollection<T>(json: T): boolean {
+    return geoJsonValidator.isFeatureCollection(json);
+}
+
+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;
+}

package/src/utils/retry.ts

@@ -0,0 +1,49 @@
+export enum RetryLogError {
+    LOG_ALL_AS_ERRORS,
+    LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
+    NO_LOGGING
+}
+
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @return Promise return value
+ */
+export async function retry<T>(asyncFn: () => Promise<T>,
+    retries = 3,
+    logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS): Promise<T> {
+
+    if (!isFinite(retries)) {
+        throw new Error('Only finite numbers are supported');
+    }
+    if (retries > 100) {
+        throw new Error('Exceeded the maximum retry count of 100');
+    }
+    try {
+        return await asyncFn();
+    } catch (error) {
+        const remainingRetries = retries - 1;
+
+        const errorMessage = 'method=retry error';
+        if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
+            console.error(errorMessage, error);
+        } else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+            if (remainingRetries < 0) {
+                console.error(errorMessage, error);
+            } else {
+                console.warn(errorMessage, error);
+            }
+        }
+
+        if (remainingRetries < 0) {
+            console.warn('method=retry no retries left');
+            throw new Error('No retries left');
+        }
+        console.warn('method=retry invocation failed, retrying with remaining retries %d', remainingRetries);
+        return retry(asyncFn,
+            remainingRetries,
+            logError);
+    }
+}

package/src/utils/slack.ts

@@ -0,0 +1,22 @@
+import axios from "axios";
+
+export class SlackApi {
+
+    private readonly url: string;
+
+    constructor(url :string) {
+        this.url = url;
+    }
+
+    async notify(text: string) {
+        try {
+            console.info('method=notify Notifying Slack');
+            await axios.post(this.url, {
+                text,
+            });
+        } catch (error) {
+            console.error('method=notify Slack notify failed!');
+        }
+    }
+
+}

package/src/utils/utils.ts

@@ -0,0 +1,105 @@
+/**
+ * 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
+ */
+import { Either } from "../types/either";
+
+export function bothArraysHasSameValues(
+    a: null | undefined | unknown[],
+    b: null | undefined | unknown[]
+): boolean {
+    if ((a && !b) || (!a && b)) {
+        return false;
+    } else if (!a && !b) {
+        return true;
+    }
+    const aSet = new Set(a);
+    const bSet = new Set(b);
+    if (aSet.size !== bSet.size) {
+        return false;
+    }
+    return Array.from(aSet).every((value) => bSet.has(value));
+}
+
+/**
+ * Returns the last item on the array.  If the array is empty, throws an error!
+ */
+export function getLast<T>(array: T[], sortFunction?: (a: T) => number): T {
+    return getFirstOrLast(false, array, sortFunction);
+}
+
+/**
+ * Returns the first item on the array.  If the array is empty, throws an error!
+ */
+export function getFirst<T>(array: T[], sortFunction?: (a: T) => number): T {
+    return getFirstOrLast(true, array, sortFunction);
+}
+
+function getFirstOrLast<T>(
+    getFirst: boolean,
+    array: T[],
+    sortFunction?: (a: T) => number
+): T {
+    if (array.length == 0) {
+        throw new Error(
+            `can't get ${getFirst ? "first" : "last"} from empty array!`
+        );
+    }
+
+    const index = getFirst ? 0 : array.length - 1;
+
+    if (sortFunction) {
+        return array.sort(sortFunction)[index];
+    }
+
+    return array[index];
+}
+
+/**
+ * Gets environment variable. Throws error if variable is not found.
+ *
+ * @param key Environment key
+ * @return string
+ */
+export function getEnvVariable(key: string): string {
+    const either = getEnvVariableSafe(key);
+    if (either.result === "error") {
+        throw new Error(either.message);
+    }
+    return either.value;
+}
+
+/**
+ * Gets environment variable. Safe version returns object with either ok or error status.
+ * Easier to use for recovery than catching an error.
+ *
+ * @param key Environment key
+ * @return Either<string>
+ */
+export function getEnvVariableSafe(key: string): Either<string> {
+    const value = process.env[key];
+    if (value === undefined) {
+        return {
+            result: "error",
+            message: `Error: environment variable "${key}" is undefined.`,
+        };
+    }
+    return { result: "ok", value };
+}

package/test/marine/id_utils.test.ts

@@ -0,0 +1,57 @@
+import * as IdUtils from '../../src/marine/id_utils';
+import {getRandomNumber} from "../../src/test/testutils";
+
+describe('IdUtils tests', () => {
+
+    test('isValidLOCODE - success', () => {
+        expect(IdUtils.isValidLOCODE('FILOL')).toBe(true);
+    });
+
+    test('isValidLOCODE - fail with non-finnish prefix', () => {
+        expect(IdUtils.isValidLOCODE('SEABS')).toBe(false);
+    });
+
+    test('isValidLOCODE - fail with numbers', () => {
+        expect(IdUtils.isValidLOCODE('FIAA1')).toBe(false);
+    });
+
+    test('isValidIMO - successful checksum - ship TRANSMAR', () => {
+        expect(IdUtils.isValidIMO(9167332)).toBe(true);
+    });
+
+    test('isValidIMO - successful checksum - ship ANNIKA B', () => {
+        expect(IdUtils.isValidIMO(9213715)).toBe(true);
+    });
+
+    test('isValidIMO - successful checksum - ship X PRESS ELBE', () => {
+        expect(IdUtils.isValidIMO(9483669)).toBe(true);
+    });
+
+    test('isValidIMO - successful checksum - ship SILVERFORS', () => {
+        expect(IdUtils.isValidIMO(8322765)).toBe(true);
+    });
+
+    test('isValidIMO - invalid checksum', () => {
+        expect(IdUtils.isValidIMO(8322766)).toBe(false);
+    });
+
+    test('isValidIMO - fail with number smaller than 1000000', () => {
+        expect(IdUtils.isValidIMO(getRandomNumber(0, 1000000 - 1))).toBe(false);
+    });
+
+    test('isValidIMO - fail with number larger than 9999999', () => {
+        expect(IdUtils.isValidIMO(getRandomNumber(9999999 + 1, 99999999))).toBe(false);
+    });
+
+    test('isValidMMSI - success', () => {
+        expect(IdUtils.isValidMMSI(230927000)).toBe(true);
+    });
+
+    test('isValidMMSI - fail with number smaller than 100000000', () => {
+        expect(IdUtils.isValidMMSI(getRandomNumber(0, 100000000 - 1))).toBe(false);
+    });
+
+    test('isValidMMSI - fail with number larger than 999999999', () => {
+        expect(IdUtils.isValidMMSI(getRandomNumber(999999999 + 1, 9999999999))).toBe(false);
+    });
+});

package/test/promise/promise.test.ts

@@ -0,0 +1,143 @@
+import {getRandomInteger} from "../../src/test/testutils";
+import {retry, RetryLogError} from "../../src/utils/retry";
+
+describe('Promise utils tests', () => {
+
+    test('retry - no retries', async () => {
+        const fn = jest.fn().mockResolvedValue(1);
+
+        const ret = await retry(fn, 0, RetryLogError.NO_LOGGING);
+
+        expect(ret).toBe(1);
+        expect(fn.mock.calls.length).toBe(1);
+    });
+
+    test('retry - error with n+1 retries', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+        const retries = getRandomInteger(1, 10);
+
+        try {
+            await retry(fn, retries, RetryLogError.NO_LOGGING);
+        } catch {
+            // ignore
+        } finally {
+            expect(fn.mock.calls.length).toBe(retries + 1);
+        }
+    });
+
+    test('retry - no error with n+1 retries', async () => {
+        const fn = jest.fn().mockResolvedValue(1);
+        const retries = getRandomInteger(1, 10);
+
+        const ret = await retry(fn, retries, RetryLogError.NO_LOGGING);
+
+        expect(ret).toBe(1);
+        expect(fn.mock.calls.length).toBe(1);
+    });
+
+    test('retry - errors with no error logging', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+        const consoleErrorSpy = jest.spyOn(global.console, 'error').mockImplementation();
+
+        try {
+            await retry(fn, getRandomInteger(0, 10), RetryLogError.NO_LOGGING);
+        } catch {
+            // ignore
+        } finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(0);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+
+    test('retry - no retries with error logging', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+        const consoleErrorSpy = jest.spyOn(global.console, 'error').mockImplementation();
+
+        try {
+            await retry(fn, 0, RetryLogError.LOG_ALL_AS_ERRORS);
+        } catch {
+            // ignore
+        } finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+
+    test('retry - retries with error logging', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+        const retries = getRandomInteger(1, 10);
+        const consoleErrorSpy = jest.spyOn(global.console, 'error').mockImplementation();
+
+        try {
+            await retry(fn, retries, RetryLogError.LOG_ALL_AS_ERRORS);
+        } catch {
+            // ignore
+        } finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(retries + 1);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+
+    test('retry - exceeded retry count throws error', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+
+        await expect(() => retry(fn, 3, RetryLogError.LOG_ALL_AS_ERRORS)).rejects.toThrow();
+    });
+
+    test('retry - defaults', async () => {
+        const fn = jest.fn().mockRejectedValue('error');
+        const consoleErrorSpy = jest.spyOn(global.console, 'error').mockImplementation();
+
+        try {
+            await retry(fn);
+        } catch {
+            // ignore
+        } finally {
+            expect(fn.mock.calls.length).toBe(3 + 1);
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1); // last retry
+        }
+    });
+
+    test('retry - NaN throws error', async () => {
+        const fn = jest.fn();
+
+        await expect(() => retry(fn, NaN, RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+
+    test('retry - Infinity throws error', async () => {
+        const fn = jest.fn();
+
+        await expect(() => retry(fn, Infinity, RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+
+    test('retry - exceeded maximum retry count throws error', async () => {
+        const fn = jest.fn();
+
+        await expect(() => retry(fn, getRandomInteger(101, 1000000), RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+
+    test('retry - use without mocks without retry', async () => {
+        const val = 1;
+        const fn = () => Promise.resolve(val);
+
+        const ret = await retry(fn);
+
+        expect(ret).toBe(val);
+    });
+
+    test('retry - use without mocks with retry', async () => {
+        let i = 0;
+        const val = 1;
+        const fn = () => {
+            if (i < 3) {
+                i++;
+                throw new Error('not yet');
+            }
+            return Promise.resolve(val);
+        };
+
+        const ret = await retry(fn);
+
+        expect(ret).toBe(val);
+    });
+});

package/test/secrets/dbsecret.test.ts

@@ -0,0 +1,59 @@
+import {mockSecret, stubSecretsManager} from "../../src/test/secrets-manager";
+
+import * as sinon from 'sinon';
+
+const SECRET_ID = "test_secret";
+const SECRET_WITH_PREFIX = {
+    "prefix.value" : "value",
+    "prefix.name" : "name",
+    "wrong.value" : "value",
+};
+const SECRET_EMPTY = {};
+
+stubSecretsManager();
+
+import {GenericSecret, withSecret, withSecretAndPrefix} from "../../src/aws/runtime/secrets/secret";
+
+describe('secret - test', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    test('getSecret - no secret', async () => {
+        mockSecret(null);
+
+        await expect(async () => {
+            await withSecret(SECRET_ID, () => {
+                // do nothing
+            });
+        }).rejects.toThrowError("No secret found!");
+    });
+
+    test('getSecret - empty secret', async () => {
+        mockSecret(SECRET_EMPTY);
+
+        await withSecret(SECRET_ID,  (secret: GenericSecret) => {
+            expect(secret).toEqual(SECRET_EMPTY);
+        });
+    });
+
+    test('getSecret - no prefix', async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        await withSecret(SECRET_ID,  (secret: GenericSecret) => {
+            expect(secret).toEqual(SECRET_WITH_PREFIX);
+        });
+    });
+
+    test('getSecret - with prefix', async () => {
+        mockSecret(SECRET_WITH_PREFIX);
+
+        await withSecretAndPrefix(SECRET_ID, 'prefix',  (secret: GenericSecret) => {
+            expect(secret).toEqual({
+                value: "value",
+                name: "name",
+            });
+        });
+
+    });
+});