@digitraffic/common 2022.10.25-1 → 2022.10.28-2

package/src/marine/id_utils.ts

@@ -0,0 +1,30 @@
+export function isValidIMO(imo: number): boolean {
+    return imo >= 1000000 && imo <= 9999999 && imoChecksumIsValid(imo);
+}
+
+function imoChecksumIsValid(imo: number): boolean {
+    const imoStr = imo.toString();
+    const imoDigit1 = Number(imoStr[0]);
+    const imoDigit2 = Number(imoStr[1]);
+    const imoDigit3 = Number(imoStr[2]);
+    const imoDigit4 = Number(imoStr[3]);
+    const imoDigit5 = Number(imoStr[4]);
+    const imoDigit6 = Number(imoStr[5]);
+    const checkDigit = Number(imoStr[6]);
+    const checkCalculation = Number(((imoDigit1 * 7) + (imoDigit2 * 6) + (imoDigit3 * 5) + (imoDigit4 * 4) + (imoDigit5 * 3) + (imoDigit6 * 2)));
+    const checkResult = checkCalculation % 10 === checkDigit;
+    if (!checkResult) {
+        console.warn('method=imoChecksumIsValid IMO checksum failed %d', imo);
+    }
+    return checkResult;
+}
+
+export function isValidMMSI(mmsi: number): boolean {
+    return mmsi >= 100000000 && mmsi <= 999999999;
+}
+
+const LocodePattern = /^FI[A-Z]{3}$/i;
+
+export function isValidLOCODE(locode: string): boolean {
+    return LocodePattern.test(locode);
+}

package/src/marine/rtz.ts

@@ -0,0 +1,57 @@
+export type RtzPositionCoordinate = {
+    readonly $: {
+        readonly lat: number
+        readonly lon: number
+    }
+}
+
+export type RtzWaypointPosition = {
+    readonly position: RtzPositionCoordinate[]
+}
+
+export type RtzWaypoint = {
+    readonly waypoint: RtzWaypointPosition[]
+}
+
+export type RtzScheduleElement = {
+    readonly $: {
+        /**
+         * Date
+         */
+        readonly etd?: string
+        /**
+         * Date
+         */
+        readonly eta?: string
+    },
+}
+
+export type RtzSchedule = {
+    readonly scheduleElement: RtzScheduleElement[]
+}
+
+export type RtzScheduleWrapper = {
+    readonly manual?: RtzSchedule[]
+    readonly calculated?: RtzSchedule[]
+}
+
+export type RtzSchedules = {
+    readonly schedule: RtzScheduleWrapper[]
+}
+
+export type RtzRouteInfo = {
+    readonly $: {
+        readonly vesselMMSI: string
+        readonly vesselIMO: string
+    }
+}
+
+export type RtzRoute = {
+    readonly routeInfo: RtzRouteInfo[]
+    readonly waypoints: RtzWaypoint[]
+    readonly schedules: RtzSchedules[]
+}
+
+export type RtzVoyagePlan = {
+    readonly route: RtzRoute
+}

package/src/test/asserter.ts

@@ -0,0 +1,48 @@
+/**
+ * A simple asserter-class for writing canaries without dependency to testing-libraries.
+ */
+
+export abstract class Asserter {
+    static assertEquals<T>(value: T, expected: T) {
+        if (value != expected) {
+            throw new Error(`Given value ${value} was not expected ${expected}`);
+        }
+    }
+
+    static assertTrue<T>(value: T) {
+        if (!value) {
+            throw new Error(`Given value ${value} was not true`);
+        }
+    }
+
+    static assertLength<T>(data: T[], expected: number) {
+        if (!data) {
+            throw new Error("Given array was not defined");
+        }
+
+        if (data.length != expected) {
+            throw new Error(`Given array length ${data.length} was not expected ${expected}`);
+        }
+    }
+
+    static assertLengthGreaterThan<T>(data: T[], expected: number) {
+        if (!data) {
+            throw new Error("Given array was not defined");
+        }
+
+        if (data.length <= expected) {
+            throw new Error(`Given array length ${data.length} was not greater than ${expected}`);
+        }
+    }
+
+    static assertGreaterThan(value: number, expected: number) {
+        if (value <= expected) {
+            throw new Error(`Value ${value} was expected to be greater than ${expected}`);
+        }
+    }
+
+    static assertToBeCloseTo(value: number, expected: number, delta: number) {
+        expect(expected-value).toBeGreaterThanOrEqual(-1 * delta);
+        expect(expected-value).toBeLessThanOrEqual(delta);
+    }
+}

package/src/test/db-testutils.ts

@@ -0,0 +1,44 @@
+import { DTDatabase, initDbConnection } from "../database/database";
+import { DatabaseEnvironmentKeys } from "../aws/runtime/secrets/dbsecret";
+
+export function dbTestBase(
+    fn: (db: DTDatabase) => void,
+    truncateFn: (db: DTDatabase) => Promise<void>,
+    dbUser: string,
+    dbPass: string,
+    dbUri: string
+): () => void {
+    const theDbUri = process.env.DB_URI ?? dbUri;
+    console.log(`Test database URI: ${theDbUri}`);
+
+    return () => {
+        const db: DTDatabase = initDbConnection(
+            dbUser,
+            dbPass,
+            "test",
+            theDbUri,
+            {
+                noWarnings: true, // ignore duplicate connection warning for tests
+            }
+        );
+
+        beforeAll(async () => {
+            process.env[DatabaseEnvironmentKeys.DB_USER] = dbUser;
+            process.env[DatabaseEnvironmentKeys.DB_PASS] = dbPass;
+            process.env[DatabaseEnvironmentKeys.DB_URI] = theDbUri;
+            process.env[DatabaseEnvironmentKeys.DB_RO_URI] = theDbUri;
+            await truncateFn(db);
+        });
+
+        afterAll(async () => {
+            await truncateFn(db);
+            await db.$pool.end();
+        });
+
+        beforeEach(async () => {
+            await truncateFn(db);
+        });
+
+        fn(db);
+    };
+}

package/src/test/httpserver.ts

@@ -0,0 +1,96 @@
+import { Server, createServer } from "http";
+
+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));
+            this.debuglog("Received request to url " + req.url + "..");
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const path = require("url").parse(req.url).pathname;
+
+            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() {
+        this.debuglog("Closing test server");
+        if (this.server !== undefined) {
+            this.server.close();
+        }
+    }
+
+    private debuglog(str: string) {
+        if (this.debug) {
+            console.debug(str);
+        }
+    }
+}
+
+export interface ListenProperties {
+    [key: string]: (url?: string, data?: string) => string;
+}

package/src/test/secret.ts

@@ -0,0 +1,23 @@
+import {DbSecret, EmptySecretFunction, SecretFunction, SecretToPromiseFunction} from "../aws/runtime/secrets/dbsecret";
+
+const EMPTY_DB_SECRET: DbSecret = {
+    username: '',
+    password: '',
+    host: '',
+    // eslint-disable-next-line camelcase
+    ro_host: '',
+};
+
+export function createSecretFunction<Secret, Response>(secret: Secret): SecretFunction<Secret, Response> {
+    // eslint-disable-next-line require-await
+    return async (secretId: string, fn: SecretToPromiseFunction<Secret, Response>) => {
+        return fn(secret);
+    };
+}
+
+export function createEmptySecretFunction<Response>(): EmptySecretFunction<Response> {
+    // eslint-disable-next-line require-await
+    return async (secretId: string, fn: SecretToPromiseFunction<DbSecret, Response>) => {
+        return fn(EMPTY_DB_SECRET);
+    };
+}

package/src/test/secrets-manager.ts

@@ -0,0 +1,34 @@
+import AWS = require('aws-sdk');
+import * as sinon from "sinon";
+
+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.ts

@@ -0,0 +1,39 @@
+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/either.ts

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

package/src/types/input-error.ts

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

package/src/types/language.ts

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

package/src/types/traffictype.ts

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

package/src/types/validator.ts

@@ -0,0 +1,10 @@
+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.ts

@@ -0,0 +1,133 @@
+import {
+    RestApi,
+    Model,
+    JsonSchema,
+    RequestValidator,
+    JsonSchemaType,
+    JsonSchemaVersion,
+} from 'aws-cdk-lib/aws-apigateway';
+import {ModelWithReference} from "../aws/types/model-with-reference";
+
+/**
+ * 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.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.ts

@@ -0,0 +1,30 @@
+
+/**
+ * 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 (!(parsed instanceof Date) || isNaN(parsed.getTime())) {
+        throw new Error(`Invalid ISO-DATE -string: ${isoString}`);
+    }
+    return parsed;
+}

package/src/utils/geojson-types.ts

@@ -0,0 +1,22 @@
+/**
+ * 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;
+    }
+}