@digitraffic/common 2022.12.1-1 → 2022.12.22-1

package/src/aws/types/proxytypes.ts

@@ -3,11 +3,11 @@
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaResponse = {
-    readonly statusCode: number
-    readonly body: string
-    readonly headers?: Record<string, string>
-    readonly multiValueHeaders?: Record<string, string[]>
+export interface ProxyLambdaResponse {
+    readonly statusCode: number;
+    readonly body: string;
+    readonly headers?: Record<string, string>;
+    readonly multiValueHeaders?: Record<string, string[]>;
 }
 
 /**
@@ -15,13 +15,13 @@ export type ProxyLambdaResponse = {
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaRequest = {
-    readonly resource: string
-    readonly path: string
-    readonly httpMethod: string
-    readonly headers: Record<string, string>
-    readonly multiValueHeaders: Record<string, string[]>
-    readonly queryStringParameters: Record<string, string>
-    readonly multiValueQueryStringParameters: Record<string, string[]>
-    readonly body?: string
+export interface ProxyLambdaRequest {
+    readonly resource: string;
+    readonly path: string;
+    readonly httpMethod: string;
+    readonly headers: Record<string, string>;
+    readonly multiValueHeaders: Record<string, string[]>;
+    readonly queryStringParameters: Record<string, string>;
+    readonly multiValueQueryStringParameters: Record<string, string[]>;
+    readonly body?: string;
 }

package/src/database/cached.ts

@@ -1,35 +1,54 @@
-import {PreparedStatement} from "pg-promise";
-import {DTDatabase, DTTransaction} from "./database";
+import { PreparedStatement } from "pg-promise";
+import { DTDatabase, DTTransaction } from "./database";
 
-const SQL_UPDATE_CACHE_VALUE =
-    `insert into cached_json(cache_id, content, last_updated)
+export interface CachedValue<T> {
+    content: T;
+    last_updated: Date;
+}
+
+const SQL_UPDATE_CACHE_VALUE = `insert into cached_json(cache_id, content, last_updated)
     values ($1, $2, now())
     on conflict(cache_id) do
     update set content = $2, last_updated = now()`;
 
-const SQL_GET_CACHE_VALUE =
-    `select content, last_updated from cached_json
+const SQL_GET_CACHE_VALUE = `select content, last_updated from cached_json
     where cache_id = $1`;
 
 const PS_UPDATE_CACHE_VALUE = new PreparedStatement({
-    name: 'update-cache-value',
+    name: "update-cache-value",
     text: SQL_UPDATE_CACHE_VALUE,
 });
 
 const PS_GET_CACHE_VALUE = new PreparedStatement({
-    name: 'get-cache-value',
+    name: "get-cache-value",
     text: SQL_GET_CACHE_VALUE,
 });
 
 export enum JSON_CACHE_KEY {
-    NAUTICAL_WARNINGS_ACTIVE = 'nautical-warnings-active',
-    NAUTICAL_WARNINGS_ARCHIVED = 'nautical-warnings-archived'
+    NAUTICAL_WARNINGS_ACTIVE = "nautical-warnings-active",
+    NAUTICAL_WARNINGS_ARCHIVED = "nautical-warnings-archived",
 }
 
-export function updateCachedJson<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY, value: T): Promise<null> {
+export function updateCachedJson<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY,
+    value: T
+): Promise<null> {
     return db.none(PS_UPDATE_CACHE_VALUE, [cacheKey, value]);
 }
 
-export function getJsonFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<T | null> {
-    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]).then(value => value?.content ?? null);
+export function getJsonFromCache<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY
+): Promise<T | null> {
+    return db
+        .oneOrNone<CachedValue<T>>(PS_GET_CACHE_VALUE, [cacheKey])
+        .then((value) => value?.content ?? null);
+}
+
+export function getFromCache<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY
+): Promise<CachedValue<T> | null> {
+    return db.oneOrNone<CachedValue<T>>(PS_GET_CACHE_VALUE, [cacheKey]);
 }

package/src/database/last-updated.ts

@@ -1,59 +1,103 @@
-import {DTDatabase, DTTransaction} from "./database";
+import { DTDatabase, DTTransaction } from "./database";
 
 export enum DataType {
-    VS_DATEX2="VS_DATEX2",
-    COUNTING_SITES_DATA="COUNTING_SITES_DATA",
-    COUNTING_SITES_METADATA="COUNTING_SITES_METADATA",
-    COUNTING_SITES_METADATA_CHECK="COUNTING_SITES_METADATA_CHECK",
-    MAINTENANCE_TRACKING_DATA_CHECKED="MAINTENANCE_TRACKING_DATA_CHECKED",
-    PERMIT_DATA="PERMIT_DATA",
-    PERMIT_DATA_CHECK="PERMIT_DATA_CHECK",
+    VS_DATEX2 = "VS_DATEX2",
+    COUNTING_SITES_DATA = "COUNTING_SITES_DATA",
+    COUNTING_SITES_METADATA = "COUNTING_SITES_METADATA",
+    COUNTING_SITES_METADATA_CHECK = "COUNTING_SITES_METADATA_CHECK",
+    MAINTENANCE_TRACKING_DATA_CHECKED = "MAINTENANCE_TRACKING_DATA_CHECKED",
+    PERMIT_DATA = "PERMIT_DATA",
+    PERMIT_DATA_CHECK = "PERMIT_DATA_CHECK",
 }
 
-const UNSET_SUBTYPE = '-';
+const UNSET_SUBTYPE = "-";
 
 type UpdatedTimestamp = {
-    updated: Date
+    updated: Date;
 } | null;
 
-export function getLastUpdated(db: DTDatabase, datatype: DataType): Promise<Date | null> {
-    return db.oneOrNone("select updated from data_updated where data_type=$(datatype) and subtype=$(subtype)", {
-        datatype: datatype, subtype: UNSET_SUBTYPE,
-    }, (x: UpdatedTimestamp) => x?.updated || null);
+export function getLastUpdated(
+    db: DTDatabase,
+    datatype: DataType
+): Promise<Date | null> {
+    return db.oneOrNone(
+        "select updated from data_updated where data_type=$(datatype) and subtype=$(subtype)",
+        {
+            datatype: datatype,
+            subtype: UNSET_SUBTYPE,
+        },
+        (x: UpdatedTimestamp) => x?.updated ?? null
+    );
 }
 
-export function getLastUpdatedWithSubtype(db: DTDatabase, datatype: DataType, subtype: string): Promise<Date | null> {
-    return db.oneOrNone("SELECT updated FROM data_updated WHERE data_type=$(datatype) AND subtype=$(subtype)", {
-        datatype: datatype, subtype: subtype,
-    }, (x: UpdatedTimestamp) => x?.updated || null);
+export function getLastUpdatedWithSubtype(
+    db: DTDatabase,
+    datatype: DataType,
+    subtype: string
+): Promise<Date | null> {
+    return db.oneOrNone(
+        "SELECT updated FROM data_updated WHERE data_type=$(datatype) AND subtype=$(subtype)",
+        {
+            datatype: datatype,
+            subtype: subtype,
+        },
+        (x: UpdatedTimestamp) => x?.updated ?? null
+    );
 }
 
-export function updateLastUpdated(db: DTDatabase | DTTransaction, datatype: DataType, updated: Date): Promise<null> {
-    return db.none(`insert into data_updated(id, data_type, updated)
+export function updateLastUpdated(
+    db: DTDatabase | DTTransaction,
+    datatype: DataType,
+    updated: Date
+): Promise<null> {
+    return db.none(
+        `insert into data_updated(id, data_type, updated)
  values(nextval('seq_data_updated'), $(datatype), $(updated))
  on conflict (data_type, subtype)
  do update set updated = $(updated)`,
-    { updated, datatype });
+        { updated, datatype }
+    );
 }
 
-export function updateLastUpdatedWithSubtype(db: DTDatabase | DTTransaction, datatype: DataType, subtype: string, updated: Date): Promise<null> {
-    return db.none(`insert into data_updated(id, data_type, subtype, updated)
+export function updateLastUpdatedWithSubtype(
+    db: DTDatabase | DTTransaction,
+    datatype: DataType,
+    subtype: string,
+    updated: Date
+): Promise<null> {
+    return db.none(
+        `insert into data_updated(id, data_type, subtype, updated)
  values(nextval('seq_data_updated'), $(datatype), $(subtype), $(updated))
  on conflict (data_type, subtype)
  do update set updated = $(updated)`,
-    { updated, subtype, datatype });
+        { updated, subtype, datatype }
+    );
 }
 
-export function getUpdatedTimestamp(db: DTDatabase, datatype: string): Promise<Date | null> {
-    return db.oneOrNone("select updated_time as updated from updated_timestamp where updated_name=$(datatype)", {
-        datatype: datatype,
-    }, (x: UpdatedTimestamp) => x?.updated || null);
+export function getUpdatedTimestamp(
+    db: DTDatabase,
+    datatype: string
+): Promise<Date | null> {
+    return db.oneOrNone(
+        "select updated_time as updated from updated_timestamp where updated_name=$(datatype)",
+        {
+            datatype: datatype,
+        },
+        (x: UpdatedTimestamp) => x?.updated ?? null
+    );
 }
 
-export function updateUpdatedTimestamp(db: DTDatabase | DTTransaction, datatype: string, date: Date, by = ''): Promise<null> {
-    return db.none(`insert into updated_timestamp(updated_name, updated_time, updated_by)
+export function updateUpdatedTimestamp(
+    db: DTDatabase | DTTransaction,
+    datatype: string,
+    date: Date,
+    by = ""
+): Promise<null> {
+    return db.none(
+        `insert into updated_timestamp(updated_name, updated_time, updated_by)
 values($(datatype), $(date), $(by))
 on conflict (updated_name)
 do update set updated_time = $(date), updated_by = $(by)`,
-    { date, datatype, by });
+        { date, datatype, by }
+    );
 }

package/src/marine/rtz.ts

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

package/src/test/asserter.ts

@@ -2,47 +2,57 @@
  * A simple asserter-class for writing canaries without dependency to testing-libraries.
  */
 
+type AssertedValue = string | number;
+
 export abstract class Asserter {
-    static assertEquals<T>(value: T, expected: T) {
+    static assertEquals(value: AssertedValue, expected: AssertedValue) {
         if (value != expected) {
-            throw new Error(`Given value ${value} was not expected ${expected}`);
+            throw new Error(
+                `Given value ${value} was not expected ${expected}`
+            );
         }
     }
 
-    static assertTrue<T>(value: T) {
+    static assertTrue(value: boolean) {
         if (!value) {
-            throw new Error(`Given value ${value} was not true`);
+            throw new Error(`Given value was not true`);
         }
     }
 
-    static assertLength<T>(data: T[], expected: number) {
+    static assertLength<T>(data: T[] | undefined, 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}`);
+            throw new Error(
+                `Given array length ${data.length} was not expected ${expected}`
+            );
         }
     }
 
-    static assertLengthGreaterThan<T>(data: T[], expected: number) {
+    static assertLengthGreaterThan<T>(data: T[] | undefined, 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}`);
+            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}`);
+            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);
+        expect(expected - value).toBeGreaterThanOrEqual(-1 * delta);
+        expect(expected - value).toBeLessThanOrEqual(delta);
     }
 }

package/src/test/httpserver.ts

@@ -1,4 +1,5 @@
 import { Server, createServer } from "http";
+import { parse } from "url";
 
 export const ERROR_NO_MATCH = "NO MATCH";
 export const ERRORCODE_NOT_FOUND = 404;
@@ -36,11 +37,18 @@ export class TestHttpServer {
         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;
+
+            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) => {
@@ -64,7 +72,7 @@ export class TestHttpServer {
                     res.end(props[path](req.url, dataStr));
                 });
             } else {
-                this.debuglog("..no match for %" + path);
+                this.debuglog(`..no match for ${path}`);
                 req.on("end", () => {
                     // assume sent data is in JSON format
                     this.messageStack[this.messageStack.length] =
@@ -91,6 +99,7 @@ export class TestHttpServer {
     }
 }
 
-export interface ListenProperties {
-    [key: string]: (url?: string, data?: string) => string;
-}
+export type ListenProperties = Record<
+    string,
+    (url?: string, data?: string) => string
+>;

package/src/types/either.ts

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