@digitraffic/common 2022.10.25-1 → 2022.10.31-1

package/dist/aws/runtime/secrets/secret.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSecretAndPrefix = exports.getSecret = exports.withSecret = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const smClient = new aws_sdk_1.SecretsManager({
+    region: process.env.AWS_REGION,
+});
+/**
+ @deprecated use SecretHolder & ProxyHolder
+ */
+async function withSecret(secretId, fn) {
+    return fn(await getSecret(secretId));
+}
+exports.withSecret = withSecret;
+async function getSecret(secretId, prefix = '') {
+    const secretObj = await smClient.getSecretValue({
+        SecretId: secretId,
+    }).promise();
+    if (!secretObj.SecretString) {
+        throw new Error('No secret found!');
+    }
+    const secret = JSON.parse(secretObj.SecretString);
+    if (prefix === '') {
+        return secret;
+    }
+    return parseSecret(secret, `${prefix}.`);
+}
+exports.getSecret = getSecret;
+function parseSecret(secret, prefix) {
+    const parsed = {};
+    const skip = prefix.length;
+    for (const key in secret) {
+        if (key.startsWith(prefix)) {
+            parsed[key.substring(skip)] = secret[key];
+        }
+    }
+    return parsed;
+}
+async function withSecretAndPrefix(secretId, prefix, fn) {
+    return fn(await getSecret(secretId, prefix));
+}
+exports.withSecretAndPrefix = withSecretAndPrefix;
+//# sourceMappingURL=secret.js.map

package/dist/aws/types/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.BAD_REQUEST_MESSAGE = exports.OK_MESSAGE = exports.ERROR_MESSAGE = exports.NOT_FOUND_MESSAGE = void 0;
+// DEPRECATED, remove these!
+exports.NOT_FOUND_MESSAGE = "NOT_FOUND";
+exports.ERROR_MESSAGE = "ERROR";
+exports.OK_MESSAGE = "OK";
+exports.BAD_REQUEST_MESSAGE = "BAD REQUEST";
+class ValidationError extends Error {
+    constructor(statusCode, body) {
+        super(body);
+        this.statusCode = statusCode;
+    }
+}
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=errors.js.map

package/dist/aws/types/lambda-response.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaResponse = void 0;
+class LambdaResponse {
+    constructor(status, body, fileName) {
+        this.status = status;
+        this.body = body;
+        this.fileName = fileName;
+    }
+    static ok(body, fileName) {
+        return this.create(200, body, fileName);
+    }
+    static okJson(json, fileName) {
+        return this.create(200, JSON.stringify(json, null, 2), fileName);
+    }
+    static badRequest(body) {
+        return this.create(400, body);
+    }
+    static notFound() {
+        return this.create(404, "Not found");
+    }
+    static internalError() {
+        return this.create(500, "Internal error");
+    }
+    static notImplemented() {
+        return this.create(501, "Not implemented");
+    }
+    static create(status, body, fileName) {
+        return Promise.resolve(new LambdaResponse(status, body, fileName));
+    }
+}
+exports.LambdaResponse = LambdaResponse;
+//# sourceMappingURL=lambda-response.js.map

package/dist/aws/types/mediatypes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaType = void 0;
+// charset=UTF-8 is deprecated but mobile applications sometimes needs it
+var MediaType;
+(function (MediaType) {
+    MediaType["APPLICATION_JSON"] = "application/json;charset=UTF-8";
+    MediaType["APPLICATION_XML"] = "application/xml";
+    MediaType["APPLICATION_GEOJSON"] = "application/geo+json;charset=UTF-8";
+    MediaType["IMAGE_SVG"] = "image/svg+xml";
+    MediaType["IMAGE_JPEG"] = "image/jpeg";
+    MediaType["TEXT_PLAIN"] = "text/plain";
+    MediaType["TEXT_HTML"] = "text/html";
+    MediaType["TEXT_CSV"] = "text/csv";
+})(MediaType = exports.MediaType || (exports.MediaType = {}));
+//# sourceMappingURL=mediatypes.js.map

package/dist/aws/types/model-with-reference.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model-with-reference.js.map

package/dist/aws/types/proxytypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=proxytypes.js.map

package/dist/aws/types/tags.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_V1_TAGS = exports.BETA_TAGS = void 0;
+// DEPRECATED! This must be replaced with new application specific tags
+exports.BETA_TAGS = ['Beta'];
+exports.DATA_V1_TAGS = ['Data v1'];
+//# sourceMappingURL=tags.js.map

package/dist/database/cached.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonFromCache = exports.updateCachedJson = exports.JSON_CACHE_KEY = void 0;
+const pg_promise_1 = require("pg-promise");
+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
+    where cache_id = $1`;
+const PS_UPDATE_CACHE_VALUE = new pg_promise_1.PreparedStatement({
+    name: 'update-cache-value',
+    text: SQL_UPDATE_CACHE_VALUE,
+});
+const PS_GET_CACHE_VALUE = new pg_promise_1.PreparedStatement({
+    name: 'get-cache-value',
+    text: SQL_GET_CACHE_VALUE,
+});
+var JSON_CACHE_KEY;
+(function (JSON_CACHE_KEY) {
+    JSON_CACHE_KEY["NAUTICAL_WARNINGS_ACTIVE"] = "nautical-warnings-active";
+    JSON_CACHE_KEY["NAUTICAL_WARNINGS_ARCHIVED"] = "nautical-warnings-archived";
+})(JSON_CACHE_KEY = exports.JSON_CACHE_KEY || (exports.JSON_CACHE_KEY = {}));
+function updateCachedJson(db, cacheKey, value) {
+    return db.none(PS_UPDATE_CACHE_VALUE, [cacheKey, value]);
+}
+exports.updateCachedJson = updateCachedJson;
+function getJsonFromCache(db, cacheKey) {
+    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]).then(value => value?.content ?? null);
+}
+exports.getJsonFromCache = getJsonFromCache;
+//# sourceMappingURL=cached.js.map

package/dist/database/database.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inDatabaseReadonly = exports.inDatabase = exports.inTransaction = exports.initDbConnection = void 0;
+const dbsecret_1 = require("../aws/runtime/secrets/dbsecret");
+const utils_1 = require("../utils/utils");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pgp = require("pg-promise")();
+// convert numeric types to number instead of string
+pgp.pg.types.setTypeParser(pgp.pg.types.builtins.INT8, (value) => {
+    return parseInt(value);
+});
+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);
+});
+/**
+ * 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 options pg-promise options
+ */
+function initDbConnection(username, password, applicationName, url, options) {
+    const finalUrl = `postgresql://${username}:${password}@${url}?application_name=${applicationName}`;
+    return pgp(finalUrl, options);
+}
+exports.initDbConnection = initDbConnection;
+function inTransaction(fn) {
+    return inDatabase((db) => db.tx((t) => fn(t)));
+}
+exports.inTransaction = inTransaction;
+function inDatabase(fn) {
+    return doInDatabase(false, fn);
+}
+exports.inDatabase = inDatabase;
+function inDatabaseReadonly(fn) {
+    return doInDatabase(true, fn);
+}
+exports.inDatabaseReadonly = inDatabaseReadonly;
+async function doInDatabase(readonly, fn) {
+    const db_application = (0, utils_1.getEnvVariableSafe)(dbsecret_1.DatabaseEnvironmentKeys.DB_APPLICATION);
+    const db_ro_uri = (0, utils_1.getEnvVariableSafe)(dbsecret_1.DatabaseEnvironmentKeys.DB_RO_URI);
+    const db_uri = db_ro_uri.result === "ok"
+        ? db_ro_uri.value
+        : (0, utils_1.getEnvVariable)(dbsecret_1.DatabaseEnvironmentKeys.DB_URI);
+    const db = initDbConnection((0, utils_1.getEnvVariable)(dbsecret_1.DatabaseEnvironmentKeys.DB_USER), (0, utils_1.getEnvVariable)(dbsecret_1.DatabaseEnvironmentKeys.DB_PASS), db_application.result === "ok"
+        ? db_application.value
+        : "unknown-cdk-application", db_uri);
+    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) {
+        console.error("Error in db:", e);
+        throw e;
+    }
+    finally {
+        db.$pool.end();
+    }
+}
+//# sourceMappingURL=database.js.map

package/dist/database/last-updated.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateUpdatedTimestamp = exports.getUpdatedTimestamp = exports.updateLastUpdatedWithSubtype = exports.updateLastUpdated = exports.getLastUpdatedWithSubtype = exports.getLastUpdated = exports.DataType = void 0;
+var DataType;
+(function (DataType) {
+    DataType["VS_DATEX2"] = "VS_DATEX2";
+    DataType["COUNTING_SITES_DATA"] = "COUNTING_SITES_DATA";
+    DataType["COUNTING_SITES_METADATA"] = "COUNTING_SITES_METADATA";
+    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 = exports.DataType || (exports.DataType = {}));
+const UNSET_SUBTYPE = '-';
+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);
+}
+exports.getLastUpdated = getLastUpdated;
+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);
+}
+exports.getLastUpdatedWithSubtype = getLastUpdatedWithSubtype;
+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 });
+}
+exports.updateLastUpdated = updateLastUpdated;
+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 });
+}
+exports.updateLastUpdatedWithSubtype = updateLastUpdatedWithSubtype;
+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);
+}
+exports.getUpdatedTimestamp = getUpdatedTimestamp;
+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 });
+}
+exports.updateUpdatedTimestamp = updateUpdatedTimestamp;
+//# sourceMappingURL=last-updated.js.map

package/dist/database/models.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=models.js.map

package/dist/marine/id_utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidLOCODE = exports.isValidMMSI = exports.isValidIMO = void 0;
+function isValidIMO(imo) {
+    return imo >= 1000000 && imo <= 9999999 && imoChecksumIsValid(imo);
+}
+exports.isValidIMO = isValidIMO;
+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) {
+        console.warn('method=imoChecksumIsValid IMO checksum failed %d', imo);
+    }
+    return checkResult;
+}
+function isValidMMSI(mmsi) {
+    return mmsi >= 100000000 && mmsi <= 999999999;
+}
+exports.isValidMMSI = isValidMMSI;
+const LocodePattern = /^FI[A-Z]{3}$/i;
+function isValidLOCODE(locode) {
+    return LocodePattern.test(locode);
+}
+exports.isValidLOCODE = isValidLOCODE;
+//# sourceMappingURL=id_utils.js.map

package/dist/marine/rtz.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=rtz.js.map

package/dist/test/asserter.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * A simple asserter-class for writing canaries without dependency to testing-libraries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asserter = void 0;
+class Asserter {
+    static assertEquals(value, expected) {
+        if (value != expected) {
+            throw new Error(`Given value ${value} was not expected ${expected}`);
+        }
+    }
+    static assertTrue(value) {
+        if (!value) {
+            throw new Error(`Given value ${value} was not true`);
+        }
+    }
+    static assertLength(data, expected) {
+        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(data, expected) {
+        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, expected) {
+        if (value <= expected) {
+            throw new Error(`Value ${value} was expected to be greater than ${expected}`);
+        }
+    }
+    static assertToBeCloseTo(value, expected, delta) {
+        expect(expected - value).toBeGreaterThanOrEqual(-1 * delta);
+        expect(expected - value).toBeLessThanOrEqual(delta);
+    }
+}
+exports.Asserter = Asserter;
+//# sourceMappingURL=asserter.js.map

package/dist/test/db-testutils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbTestBase = void 0;
+const database_1 = require("../database/database");
+const dbsecret_1 = require("../aws/runtime/secrets/dbsecret");
+function dbTestBase(fn, truncateFn, dbUser, dbPass, dbUri) {
+    const theDbUri = process.env.DB_URI ?? dbUri;
+    console.log(`Test database URI: ${theDbUri}`);
+    return () => {
+        const db = (0, database_1.initDbConnection)(dbUser, dbPass, "test", theDbUri, {
+            noWarnings: true, // ignore duplicate connection warning for tests
+        });
+        beforeAll(async () => {
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_USER] = dbUser;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_PASS] = dbPass;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_URI] = theDbUri;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_RO_URI] = theDbUri;
+            await truncateFn(db);
+        });
+        afterAll(async () => {
+            await truncateFn(db);
+            await db.$pool.end();
+        });
+        beforeEach(async () => {
+            await truncateFn(db);
+        });
+        fn(db);
+    };
+}
+exports.dbTestBase = dbTestBase;
+//# sourceMappingURL=db-testutils.js.map

package/dist/test/httpserver.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestHttpServer = exports.ERRORCODE_NOT_FOUND = exports.ERROR_NO_MATCH = void 0;
+const http_1 = require("http");
+exports.ERROR_NO_MATCH = "NO MATCH";
+exports.ERRORCODE_NOT_FOUND = 404;
+/**
+ * A mock HTTP server created for testing connections from a Lambda to an outside integration
+ */
+class TestHttpServer {
+    constructor() {
+        this.debug = false;
+        this.messageStack = [];
+    }
+    getCallCount() {
+        return this.messageStack.length;
+    }
+    getRequestBody(callNumber) {
+        return this.messageStack[callNumber];
+    }
+    listen(port, props, debug = false, statusCode = 200) {
+        this.debug = debug;
+        this.messageStack = [];
+        this.debuglog(`Starting test server on port ${port}`);
+        this.server = (0, http_1.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] =
+                        exports.ERROR_NO_MATCH;
+                    res.writeHead(exports.ERRORCODE_NOT_FOUND);
+                    res.end(exports.ERROR_NO_MATCH);
+                });
+            }
+        });
+        this.server.listen(port);
+    }
+    close() {
+        this.debuglog("Closing test server");
+        if (this.server !== undefined) {
+            this.server.close();
+        }
+    }
+    debuglog(str) {
+        if (this.debug) {
+            console.debug(str);
+        }
+    }
+}
+exports.TestHttpServer = TestHttpServer;
+//# sourceMappingURL=httpserver.js.map

package/dist/test/secret.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptySecretFunction = exports.createSecretFunction = void 0;
+const EMPTY_DB_SECRET = {
+    username: '',
+    password: '',
+    host: '',
+    // eslint-disable-next-line camelcase
+    ro_host: '',
+};
+function createSecretFunction(secret) {
+    // eslint-disable-next-line require-await
+    return async (secretId, fn) => {
+        return fn(secret);
+    };
+}
+exports.createSecretFunction = createSecretFunction;
+function createEmptySecretFunction() {
+    // eslint-disable-next-line require-await
+    return async (secretId, fn) => {
+        return fn(EMPTY_DB_SECRET);
+    };
+}
+exports.createEmptySecretFunction = createEmptySecretFunction;
+//# sourceMappingURL=secret.js.map

package/dist/test/secrets-manager.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockSecret = exports.stubSecretsManager = void 0;
+const AWS = require("aws-sdk");
+const sinon = __importStar(require("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()
+ */
+function stubSecretsManager() {
+    const smStub = {
+        getSecretValue: secretValue,
+    };
+    sinon.stub(AWS, 'SecretsManager').returns(smStub);
+    return smStub.getSecretValue;
+}
+exports.stubSecretsManager = stubSecretsManager;
+function mockSecret(secret) {
+    if (!secret) {
+        secretValue.returns({
+            promise: sinon.stub().returns({}),
+        });
+    }
+    else {
+        secretValue.returns({
+            promise: sinon.stub().returns({
+                SecretString: JSON.stringify(secret),
+            }),
+        });
+    }
+}
+exports.mockSecret = mockSecret;
+//# sourceMappingURL=secrets-manager.js.map

package/dist/test/testutils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = exports.randomBoolean = exports.getRandomBigInt = exports.getRandomIntegerAsString = exports.getRandomInteger = exports.getRandomNumberAsString = exports.getRandomNumber = exports.randomString = void 0;
+function randomString() {
+    return Math.random().toString(36).substring(2);
+}
+exports.randomString = randomString;
+function getRandomNumber(min, max) {
+    return Math.random() * (max - min) + min;
+}
+exports.getRandomNumber = getRandomNumber;
+function getRandomNumberAsString(min, max) {
+    return getRandomNumber(min, max).toString();
+}
+exports.getRandomNumberAsString = getRandomNumberAsString;
+function getRandomInteger(min, max) {
+    return Math.round(getRandomNumber(min, max));
+}
+exports.getRandomInteger = getRandomInteger;
+function getRandomIntegerAsString(min, max) {
+    return Math.round(getRandomInteger(min, max)).toString();
+}
+exports.getRandomIntegerAsString = getRandomIntegerAsString;
+function getRandomBigInt(min, max) {
+    return BigInt(getRandomInteger(min, max));
+}
+exports.getRandomBigInt = getRandomBigInt;
+function randomBoolean() {
+    return Math.random() < 0.5;
+}
+exports.randomBoolean = randomBoolean;
+/**
+ * Returns a new copy of an array, shuffled using Math.random()
+ * @param array Array
+ */
+function shuffle(array) {
+    // 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;
+}
+exports.shuffle = shuffle;
+//# sourceMappingURL=testutils.js.map

package/dist/types/either.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=either.js.map

package/dist/types/input-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputError = void 0;
+class InputError extends Error {
+}
+exports.InputError = InputError;
+//# sourceMappingURL=input-error.js.map

package/dist/types/language.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Language = void 0;
+var Language;
+(function (Language) {
+    Language["FI"] = "fi";
+    Language["EN"] = "en";
+    Language["SV"] = "sv";
+})(Language = exports.Language || (exports.Language = {}));
+//# sourceMappingURL=language.js.map

package/dist/types/traffictype.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficType = void 0;
+var TrafficType;
+(function (TrafficType) {
+    TrafficType["ROAD"] = "Road";
+    TrafficType["MARINE"] = "Marine";
+    TrafficType["RAIL"] = "Rail";
+    TrafficType["AVIATION"] = "Aviation";
+    TrafficType["MCP"] = "MCP";
+    TrafficType["OTHER"] = "Other";
+})(TrafficType = exports.TrafficType || (exports.TrafficType = {}));
+//# sourceMappingURL=traffictype.js.map