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

package/dist/database/database.js

@@ -0,0 +1,95 @@
+import pgpImport, {} from "pg-promise";
+import { logger } from "../aws/runtime/dt-logger-default.js";
+import { logException } from "../utils/logging.js";
+import { getEnvVariable, getEnvVariableOrElse } from "../utils/utils.js";
+export var DatabaseEnvironmentKeys;
+(function (DatabaseEnvironmentKeys) {
+    DatabaseEnvironmentKeys["DB_USER"] = "DB_USER";
+    DatabaseEnvironmentKeys["DB_PASS"] = "DB_PASS";
+    DatabaseEnvironmentKeys["DB_URI"] = "DB_URI";
+    DatabaseEnvironmentKeys["DB_RO_URI"] = "DB_RO_URI";
+    DatabaseEnvironmentKeys["DB_APPLICATION"] = "DB_APPLICATION";
+})(DatabaseEnvironmentKeys || (DatabaseEnvironmentKeys = {}));
+// pg-promise initialization options
+// https://vitaly-t.github.io/pg-promise/global.html#event:receive
+const pgpPromiseInitOptions = {
+    receive(e) {
+        if (e.data) {
+            convertNullColumnsToUndefined(e.data);
+        }
+    },
+};
+function initPgp(pgpPromiseInitOptions) {
+    const pgp = pgpPromiseInitOptions
+        ? pgpImport(pgpPromiseInitOptions)
+        : pgpImport();
+    // convert numeric types to number instead of string
+    pgp.pg.types.setTypeParser(pgp.pg.types.builtins.INT8, (value) => {
+        return parseInt(value, 10);
+    });
+    pgp.pg.types.setTypeParser(pgp.pg.types.builtins.FLOAT8, (value) => {
+        return parseFloat(value);
+    });
+    pgp.pg.types.setTypeParser(pgp.pg.types.builtins.NUMERIC, (value) => {
+        return parseFloat(value);
+    });
+    return pgp;
+}
+/**
+ * Creates a non-pooling database connection primarily used by Lambdas.
+ *
+ * Note! Using this method opens a new RDS connection on every invocation. It is advised to
+ * use RDS proxy to pool connections transparently.
+ * https://docs.amazonaws.cn/en_us/AmazonRDS/latest/AuroraUserGuide/rds-proxy.html
+ * @param username Username
+ * @param password Password
+ * @param applicationName name of application
+ * @param url Connection URL
+ * @param convertNullsToUndefined if true null values in query results will be converted to undefined, Default false.
+ * @param options pg-promise options
+ */
+export function initDbConnection(username, password, applicationName, url, convertNullsToUndefined, options) {
+    const finalUrl = `postgresql://${username}:${password}@${url}?application_name=${applicationName}`;
+    return initPgp(convertNullsToUndefined ? pgpPromiseInitOptions : undefined)(finalUrl, options);
+}
+// noinspection JSUnusedGlobalSymbols
+export function inTransaction(fn, convertNullsToUndefined = false) {
+    return inDatabase((db) => db.tx((t) => fn(t)), convertNullsToUndefined);
+}
+export function inDatabase(fn, convertNullsToUndefined = false) {
+    return doInDatabase(false, fn, convertNullsToUndefined);
+}
+export function inDatabaseReadonly(fn, convertNullsToUndefined = false) {
+    return doInDatabase(true, fn, convertNullsToUndefined);
+}
+async function doInDatabase(readonly, fn, convertNullsToUndefined) {
+    const db_application = getEnvVariableOrElse(DatabaseEnvironmentKeys.DB_APPLICATION, "unknown-cdk-application");
+    const db_uri = readonly
+        ? getEnvVariable(DatabaseEnvironmentKeys.DB_RO_URI)
+        : getEnvVariable(DatabaseEnvironmentKeys.DB_URI);
+    const db = initDbConnection(getEnvVariable(DatabaseEnvironmentKeys.DB_USER), getEnvVariable(DatabaseEnvironmentKeys.DB_PASS), db_application, db_uri, convertNullsToUndefined);
+    try {
+        // deallocate all prepared statements to allow for connection pooling
+        // DISCARD instead of DEALLOCATE as it didn't always clean all prepared statements
+        await db.none("DISCARD ALL");
+        return await fn(db);
+    }
+    catch (e) {
+        logException(logger, e);
+        throw e;
+    }
+    finally {
+        await db.$pool.end();
+    }
+}
+function convertNullColumnsToUndefined(rows) {
+    rows.forEach((row) => {
+        for (const column in row) {
+            const columnValue = row[column];
+            if (columnValue === null) {
+                row[column] = undefined;
+            }
+        }
+    });
+}
+//# sourceMappingURL=database.js.map

package/dist/database/last-updated.d.ts

@@ -0,0 +1,15 @@
+import type { DTDatabase, DTTransaction } from "./database.js";
+export declare enum DataType {
+    VS_DATEX2 = "VS_DATEX2",
+    COUNTING_SITES_DATA = "COUNTING_SITES_DATA",
+    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"
+}
+export declare function getLastUpdated(db: DTDatabase, datatype: DataType): Promise<Date | null>;
+export declare function getLastUpdatedWithSubtype(db: DTDatabase, datatype: DataType, subtype: string): Promise<Date | null>;
+export declare function updateLastUpdated(db: DTDatabase | DTTransaction, datatype: DataType, updated: Date): Promise<null>;
+export declare function updateLastUpdatedWithSubtype(db: DTDatabase | DTTransaction, datatype: DataType, subtype: string, updated: Date): Promise<null>;
+export declare function getUpdatedTimestamp(db: DTDatabase, datatype: string): Promise<Date | null>;
+export declare function updateUpdatedTimestamp(db: DTDatabase | DTTransaction, datatype: string, date: Date, by?: string): Promise<null>;

package/dist/database/last-updated.js

@@ -0,0 +1,46 @@
+export var DataType;
+(function (DataType) {
+    DataType["VS_DATEX2"] = "VS_DATEX2";
+    DataType["COUNTING_SITES_DATA"] = "COUNTING_SITES_DATA";
+    DataType["COUNTING_SITES_METADATA_CHECK"] = "COUNTING_SITES_METADATA_CHECK";
+    DataType["MAINTENANCE_TRACKING_DATA_CHECKED"] = "MAINTENANCE_TRACKING_DATA_CHECKED";
+    DataType["PERMIT_DATA"] = "PERMIT_DATA";
+    DataType["PERMIT_DATA_CHECK"] = "PERMIT_DATA_CHECK";
+})(DataType || (DataType = {}));
+const UNSET_SUBTYPE = "-";
+export function getLastUpdated(db, datatype) {
+    return db.oneOrNone("select updated from data_updated where data_type=$(datatype) and subtype=$(subtype)", {
+        datatype: datatype,
+        subtype: UNSET_SUBTYPE,
+    }, (x) => x?.updated ?? null);
+}
+export function getLastUpdatedWithSubtype(db, datatype, subtype) {
+    return db.oneOrNone("SELECT updated FROM data_updated WHERE data_type=$(datatype) AND subtype=$(subtype)", {
+        datatype: datatype,
+        subtype: subtype,
+    }, (x) => x?.updated ?? null);
+}
+export function updateLastUpdated(db, datatype, updated) {
+    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 });
+}
+export function updateLastUpdatedWithSubtype(db, datatype, subtype, updated) {
+    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 });
+}
+export function getUpdatedTimestamp(db, datatype) {
+    return db.oneOrNone("select updated_time as updated from updated_timestamp where updated_name=$(datatype)", {
+        datatype: datatype,
+    }, (x) => x?.updated ?? null);
+}
+export function updateUpdatedTimestamp(db, datatype, date, by = "") {
+    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 });
+}
+//# sourceMappingURL=last-updated.js.map

package/dist/database/models.d.ts

@@ -0,0 +1,6 @@
+export interface Countable {
+    count: number;
+}
+export interface Identifiable<T> {
+    id: T;
+}

package/dist/database/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { DigitrafficStackLike } from "./aws/infra/stack/stack.js";
+export { DigitrafficStack } from "./aws/infra/stack/stack.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { DigitrafficStack } from "./aws/infra/stack/stack.js";
+//# sourceMappingURL=index.js.map

package/dist/marine/id_utils.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidIMO(imo: number): boolean;
+export declare function isValidMMSI(mmsi: number): boolean;
+export declare function isValidLOCODE(locode: string): boolean;

package/dist/marine/id_utils.js

@@ -0,0 +1,36 @@
+import { logger } from "../aws/runtime/dt-logger-default.js";
+export function isValidIMO(imo) {
+    return imo >= 1000000 && imo <= 9999999 && imoChecksumIsValid(imo);
+}
+function imoChecksumIsValid(imo) {
+    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) {
+        logger.warn({
+            method: "idUtils.imoChecksumIsValid",
+            message: `IMO checksum failed ${imo}`,
+        });
+    }
+    return checkResult;
+}
+export function isValidMMSI(mmsi) {
+    return mmsi >= 100000000 && mmsi <= 999999999;
+}
+const LocodePattern = /^FI[A-Z]{3}$/i;
+export function isValidLOCODE(locode) {
+    return LocodePattern.test(locode);
+}
+//# sourceMappingURL=id_utils.js.map

package/dist/marine/rtz.d.ts

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

package/dist/marine/rtz.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rtz.js.map

package/dist/types/async-timeout-error.d.ts

@@ -0,0 +1,3 @@
+export declare class AsyncTimeoutError extends Error {
+    constructor();
+}

package/dist/types/async-timeout-error.js

@@ -0,0 +1,6 @@
+export class AsyncTimeoutError extends Error {
+    constructor() {
+        super("Async operation timed out");
+    }
+}
+//# sourceMappingURL=async-timeout-error.js.map

package/dist/types/either.d.ts

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

package/dist/types/either.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=either.js.map

package/dist/types/geojson.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const CoordinatesSchema: z.ZodArray<z.ZodNumber>;
+export declare const PointSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Point">;
+    coordinates: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const MultiPointSchema: z.ZodObject<{
+    type: z.ZodLiteral<"MultiPoint">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const LineStringSchema: z.ZodObject<{
+    type: z.ZodLiteral<"LineString">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const MultiLineStringSchema: z.ZodObject<{
+    type: z.ZodLiteral<"MultiLineString">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+export declare const PolygonSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+}, z.core.$strip>;
+export declare const MultiPolygonSchema: z.ZodObject<{
+    type: z.ZodLiteral<"MultiPolygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber>>>>;
+}, z.core.$strip>;
+export type Point = z.infer<typeof PointSchema>;
+export type Geometry = z.infer<typeof PointSchema> | z.infer<typeof MultiPointSchema> | z.infer<typeof LineStringSchema> | z.infer<typeof MultiLineStringSchema> | z.infer<typeof PolygonSchema> | z.infer<typeof MultiPolygonSchema> | {
+    type: "GeometryCollection";
+    geometries: Geometry[];
+};
+export declare const GeometrySchema: z.ZodType<Geometry>;
+export declare const FeatureSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Feature">;
+    geometry: z.ZodType<Geometry, unknown, z.core.$ZodTypeInternals<Geometry, unknown>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export declare const FeatureCollectionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"FeatureCollection">;
+    features: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"Feature">;
+        geometry: z.ZodType<Geometry, unknown, z.core.$ZodTypeInternals<Geometry, unknown>>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/types/geojson.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export const CoordinatesSchema = z.array(z.number()).min(2).max(3);
+export const PointSchema = z.object({
+    type: z.literal("Point"),
+    coordinates: CoordinatesSchema,
+});
+export const MultiPointSchema = z.object({
+    type: z.literal("MultiPoint"),
+    coordinates: z.array(CoordinatesSchema),
+});
+export const LineStringSchema = z.object({
+    type: z.literal("LineString"),
+    coordinates: z.array(CoordinatesSchema).min(2),
+});
+export const MultiLineStringSchema = z.object({
+    type: z.literal("MultiLineString"),
+    coordinates: z.array(z.array(CoordinatesSchema).min(2)),
+});
+export const PolygonSchema = z.object({
+    type: z.literal("Polygon"),
+    coordinates: z.array(z.array(CoordinatesSchema).min(4)),
+});
+export const MultiPolygonSchema = z.object({
+    type: z.literal("MultiPolygon"),
+    coordinates: z.array(z.array(z.array(CoordinatesSchema).min(4))),
+});
+// --- Recursive GeometrySchema ---
+export const GeometrySchema = z.lazy(() => z.union([
+    PointSchema,
+    MultiPointSchema,
+    LineStringSchema,
+    MultiLineStringSchema,
+    PolygonSchema,
+    MultiPolygonSchema,
+    // GeometryCollection is recursive, so we need to use z.lazy
+    z.object({
+        type: z.literal("GeometryCollection"),
+        geometries: z.array(GeometrySchema),
+    }),
+]));
+export const FeatureSchema = z.object({
+    type: z.literal("Feature"),
+    geometry: GeometrySchema,
+    properties: z.record(z.string(), z.any()).optional(),
+    id: z.union([z.string(), z.number()]).optional(),
+});
+export const FeatureCollectionSchema = z.object({
+    type: z.literal("FeatureCollection"),
+    features: z.array(FeatureSchema),
+});
+//# sourceMappingURL=geojson.js.map

package/dist/types/http-error.d.ts

@@ -0,0 +1,4 @@
+export declare class HttpError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}

package/dist/types/http-error.js

@@ -0,0 +1,8 @@
+export class HttpError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+//# sourceMappingURL=http-error.js.map

package/dist/types/input-error.d.ts

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

package/dist/types/input-error.js

@@ -0,0 +1,3 @@
+export class InputError extends Error {
+}
+//# sourceMappingURL=input-error.js.map

package/dist/types/language.d.ts

@@ -0,0 +1,5 @@
+export declare enum Language {
+    FI = "fi",
+    EN = "en",
+    SV = "sv"
+}

package/dist/types/language.js

@@ -0,0 +1,7 @@
+export var Language;
+(function (Language) {
+    Language["FI"] = "fi";
+    Language["EN"] = "en";
+    Language["SV"] = "sv";
+})(Language || (Language = {}));
+//# sourceMappingURL=language.js.map

package/dist/types/nullable.d.ts

@@ -0,0 +1,24 @@
+import type { ValueOf } from "./util-types.js";
+/**
+ * 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>>;
+export {};

package/dist/types/nullable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nullable.js.map