@digitraffic/common 2022.10.28-2 → 2022.10.31-1

package/.editorconfig

@@ -0,0 +1,9 @@
+[*]
+charset=utf-8
+end_of_line=lf
+insert_final_newline=true
+indent_style=space
+indent_size=4
+
+[{*.json,*.yml,*.yaml}]
+indent_size=2

package/.eslintignore

@@ -0,0 +1,4 @@
+*.js
+cdk.out
+dist
+output

package/.eslintrc.json

@@ -0,0 +1,27 @@
+{
+  "env": {
+    "browser": false,
+    "commonjs": true,
+    "es2021": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": ["./tsconfig.eslint.json"]
+  },
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    //    "plugin:@typescript-eslint/recommended-requiring-type-checking",
+    //    "plugin:@typescript-eslint/strict",
+    "prettier"
+  ],
+  "rules": {
+    "@typescript-eslint/no-extraneous-class": "off",
+    "@typescript-eslint/no-non-null-assertion": "error",
+    "@typescript-eslint/non-nullable-type-assertion-style": "error",
+    "@typescript-eslint/no-throw-literal": "error",
+    "@typescript-eslint/no-explicit-any": "error"
+  }
+}

package/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# These owners will be the default owners for everything in the repo.
+* @teijosol @jouniso @teemu-solita @jkhaak-solita @solita-ijunnone @mattihe

package/.github/workflows/build.yml

@@ -0,0 +1,36 @@
+name: Build
+on: [push]
+jobs:
+  build:
+    if: github.event.repo.name != 'tmfg/digitraffic-common'
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - name: Compile
+        run: |
+          yarn
+          yarn build
+      - name: Run tests
+        run: |
+          yarn test >> $GITHUB_STEP_SUMMARY
+      - name: Test Report
+        uses: dorny/test-reporter@v1
+        if: success() || failure()
+        with:
+          name: Jest test report
+          reporter: jest-junit
+          path: junit.xml
+      - name: Notify Slack
+        if: failure()
+        uses: 8398a7/action-slack@v3
+        with:
+          status: failure
+          text: FAILED digitraffic-common build
+          fields: repo, job, took
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

package/.github/workflows/eslint.yml

@@ -0,0 +1,38 @@
+name: ESLint
+
+on: [push]
+
+jobs:
+  lint:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "14"
+
+      - name: Install packages
+        run: yarn install --frozen-lock
+
+      - name: Create ESLint reports for affected projects
+        id: report
+        run: yarn eslint-report -- -o ${{ github.ref_name }}/report.html
+        continue-on-error: true
+
+      - name: Publish report
+        id: publish-reports
+        uses: tmfg/digitraffic-actions@gh-pages-publish/v1
+        with:
+          GH_PAGES_BRANCH: gh-pages
+          FILE_PATH: ${{ github.ref_name }}/report.html
+          COMMIT_MESSAGE: ESLint report in branch $CURRENT_BRANCH
+          LINK_TEXT: ESLint report
+
+      - name: Fail on ESLint errors
+        run: |
+          if [[ "${{ steps.report.outcome }}" == "failure" || "${{ steps.report-affected.outcome }}" == "failure" ]]; then exit 1; else exit 0; fi

package/.github/workflows/mirror.yml

@@ -0,0 +1,15 @@
+name: 'Mirror repo to public'
+on:
+  push:
+    branches:
+      - master
+jobs:
+  Mirror-action:
+    if: github.repository != 'tmfg/digitraffic-common'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Mirror
+        uses: tmfg/digitraffic-actions@mirror/v1
+        with:
+          mirror-repo: git@github.com:tmfg/digitraffic-common.git
+          ssh-private-key: ${{ secrets.SSH_MIRROR_KEY }}

package/.gitignore

@@ -0,0 +1,29 @@
+*
+
+!.husky/
+!.husky/pre-commit
+!/.editorconfig
+!/.eslintignore
+!/.eslintrc.json
+!/.gitignore
+!/.prettierrc.json
+!/jest.config.js
+!/LICENSE
+!/package.json
+!/README.md
+!/tsconfig.json
+!/tsconfig.eslint.json
+!/yarn.lock
+
+!src/
+!src/**/
+!src/**/*.ts
+
+!test/
+!test/**/
+!test/**/*.ts
+
+!.github/
+!.github/**/
+!.github/workflows/**/**.yml
+!.github/CODEOWNERS

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn lint-staged

package/.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "overrides": [
+    {
+      "files": ["*.json", "*.yml", "*.yaml"],
+      "options": {
+        "tabWidth": 2
+      }
+    }
+  ]
+}

package/dist/aws/infra/stack/lambda-configs.js

@@ -22,22 +22,22 @@ function databaseFunctionProps(stack, environment, lambdaName, simpleLambdaName,
 exports.databaseFunctionProps = databaseFunctionProps;
 function lambdaFunctionProps(stack, environment, lambdaName, simpleLambdaName, config) {
     return {
-        runtime: config?.runtime || aws_lambda_1.Runtime.NODEJS_14_X,
-        architecture: config?.architecture || aws_lambda_1.Architecture.ARM_64,
-        memorySize: config?.memorySize || 128,
+        runtime: config?.runtime ?? aws_lambda_1.Runtime.NODEJS_14_X,
+        architecture: config?.architecture ?? aws_lambda_1.Architecture.ARM_64,
+        memorySize: config?.memorySize ?? 128,
         functionName: lambdaName,
         role: config?.role,
-        timeout: aws_cdk_lib_1.Duration.seconds(config?.timeout || 60),
+        timeout: aws_cdk_lib_1.Duration.seconds(config?.timeout ?? 60),
         logRetention: aws_logs_1.RetentionDays.ONE_YEAR,
-        reservedConcurrentExecutions: config?.reservedConcurrentExecutions || 2,
-        code: getAssetCode(simpleLambdaName, config),
+        reservedConcurrentExecutions: config?.reservedConcurrentExecutions ?? 2,
+        code: getAssetCode(simpleLambdaName, config?.singleLambda ?? false),
         handler: `${simpleLambdaName}.handler`,
         environment,
     };
 }
 exports.lambdaFunctionProps = lambdaFunctionProps;
-function getAssetCode(simpleLambdaName, config) {
-    const lambdaPath = config?.singleLambda
+function getAssetCode(simpleLambdaName, isSingleLambda) {
+    const lambdaPath = isSingleLambda
         ? `dist/lambda/`
         : `dist/lambda/${simpleLambdaName}`;
     return new aws_lambda_1.AssetCode(lambdaPath);

package/jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+    roots: [
+        '<rootDir>/test',
+    ],
+    testMatch: [
+        '**/*.test.ts',
+    ],
+    testResultsProcessor: 'jest-junit',
+    preset: 'ts-jest',
+    coverageThreshold: {
+        global: {
+            lines: 70,
+        },
+    },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2022.10.28-2",
+  "version": "2022.10.31-1",
   "description": "",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
     "src/**/*.ts"
   ],
   "dependencies": {
-    "@aws-cdk/aws-synthetics-alpha": "2.46.0-alpha.0",
+    "@aws-cdk/aws-synthetics-alpha": "2.47.0-alpha.0",
     "@types/geojson": "^7946.0.10",
-    "aws-cdk-lib": "2.46.0",
-    "aws-sdk": "2.1232.0",
+    "aws-cdk-lib": "2.47.0",
+    "aws-sdk": "2.1241.0",
     "axios": "^0.21.1",
     "change-case": "4.1.2",
     "constructs": "10.1.131",

package/src/aws/infra/stack/lambda-configs.ts

@@ -44,7 +44,7 @@ export function databaseFunctionProps(
     environment: LambdaEnvironment,
     lambdaName: string,
     simpleLambdaName: string,
-    config?: FunctionParameters
+    config?: Partial<FunctionParameters>
 ): FunctionProps {
     const vpcSubnets = stack.vpc
         ? {
@@ -73,18 +73,18 @@ export function lambdaFunctionProps(
     environment: LambdaEnvironment,
     lambdaName: string,
     simpleLambdaName: string,
-    config?: FunctionParameters
+    config?: Partial<FunctionParameters>
 ): FunctionProps {
     return {
-        runtime: config?.runtime || Runtime.NODEJS_14_X,
-        architecture: config?.architecture || Architecture.ARM_64,
-        memorySize: config?.memorySize || 128,
+        runtime: config?.runtime ?? Runtime.NODEJS_14_X,
+        architecture: config?.architecture ?? Architecture.ARM_64,
+        memorySize: config?.memorySize ?? 128,
         functionName: lambdaName,
         role: config?.role,
-        timeout: Duration.seconds(config?.timeout || 60),
+        timeout: Duration.seconds(config?.timeout ?? 60),
         logRetention: RetentionDays.ONE_YEAR,
-        reservedConcurrentExecutions: config?.reservedConcurrentExecutions || 2,
-        code: getAssetCode(simpleLambdaName, config),
+        reservedConcurrentExecutions: config?.reservedConcurrentExecutions ?? 2,
+        code: getAssetCode(simpleLambdaName, config?.singleLambda ?? false),
         handler: `${simpleLambdaName}.handler`,
         environment,
     };
@@ -92,9 +92,9 @@ export function lambdaFunctionProps(
 
 function getAssetCode(
     simpleLambdaName: string,
-    config?: FunctionParameters
+    isSingleLambda: boolean
 ): AssetCode {
-    const lambdaPath = config?.singleLambda
+    const lambdaPath = isSingleLambda
         ? `dist/lambda/`
         : `dist/lambda/${simpleLambdaName}`;
 
@@ -190,7 +190,7 @@ export interface FunctionParameters {
     singleLambda?: boolean;
 }
 
-export type MonitoredFunctionParameters = {
+export type MonitoredFunctionParameters = FunctionParameters & {
     readonly memorySize?: number;
     readonly timeout?: number;
     readonly functionName?: string;
@@ -204,4 +204,4 @@ export type MonitoredFunctionParameters = {
     readonly durationWarningProps?: MonitoredFunctionAlarmProps;
     readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
     readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
-} & FunctionParameters;
+};

package/src/aws/infra/stack/monitoredfunction.ts

@@ -75,7 +75,7 @@ export class MonitoredFunction extends Function {
         stack: DigitrafficStack,
         id: string,
         functionProps: FunctionProps,
-        props?: MonitoredFunctionProps
+        props?: Partial<MonitoredFunctionProps>
     ): MonitoredFunction {
         if (
             props === MonitoredFunction.DISABLE_ALARMS &&
@@ -112,7 +112,7 @@ export class MonitoredFunction extends Function {
         stack: DigitrafficStack,
         name: string,
         environment: LambdaEnvironment,
-        functionParameters?: MonitoredFunctionParameters
+        functionParameters?: Partial<MonitoredFunctionParameters>
     ): MonitoredFunction {
         const functionName =
             functionParameters?.functionName ||
@@ -310,7 +310,7 @@ export class MonitoredDBFunction {
         stack: DigitrafficStack,
         name: string,
         environment?: LambdaEnvironment,
-        functionParameters?: MonitoredFunctionParameters
+        functionParameters?: Partial<MonitoredFunctionParameters>
     ): MonitoredFunction {
         const functionName =
             functionParameters?.functionName ||

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",
+            });
+        });
+
+    });
+});