@digitraffic/common 2024.3.22-2 → 2024.4.4-1

package/dist/__test__/imports.test.mjs

@@ -3,321 +3,317 @@ test("index import ok?", () => {
     const index = import("../index.mjs");
     return expect(index).resolves.toBeDefined();
 });
-test('database import ok?', () => {
+test("database import ok?", () => {
     const database = import("../database/database.mjs");
     return expect(database).resolves.toBeDefined();
 });
-test('cached import ok?', () => {
+test("cached import ok?", () => {
     const cached = import("../database/cached.mjs");
     return expect(cached).resolves.toBeDefined();
 });
-test('models import ok?', () => {
+test("models import ok?", () => {
     const models = import("../database/models.mjs");
     return expect(models).resolves.toBeDefined();
 });
-test('lastUpdated import ok?', () => {
+test("lastUpdated import ok?", () => {
     const lastUpdated = import("../database/last-updated.mjs");
     return expect(lastUpdated).resolves.toBeDefined();
 });
-test('urn import ok?', () => {
+test("urn import ok?", () => {
     const urn = import("../types/urn.mjs");
     return expect(urn).resolves.toBeDefined();
 });
-test('utilTypes import ok?', () => {
+test("utilTypes import ok?", () => {
     const utilTypes = import("../types/util-types.mjs");
     return expect(utilTypes).resolves.toBeDefined();
 });
-test('either import ok?', () => {
+test("either import ok?", () => {
     const either = import("../types/either.mjs");
     return expect(either).resolves.toBeDefined();
 });
-test('validator import ok?', () => {
+test("validator import ok?", () => {
     const validator = import("../types/validator.mjs");
     return expect(validator).resolves.toBeDefined();
 });
-test('nullable import ok?', () => {
+test("nullable import ok?", () => {
     const nullable = import("../types/nullable.mjs");
     return expect(nullable).resolves.toBeDefined();
 });
-test('awsEnv import ok?', () => {
+test("awsEnv import ok?", () => {
     const awsEnv = import("../types/aws-env.mjs");
     return expect(awsEnv).resolves.toBeDefined();
 });
-test('asyncTimeoutError import ok?', () => {
+test("asyncTimeoutError import ok?", () => {
     const asyncTimeoutError = import("../types/async-timeout-error.mjs");
     return expect(asyncTimeoutError).resolves.toBeDefined();
 });
-test('inputError import ok?', () => {
+test("inputError import ok?", () => {
     const inputError = import("../types/input-error.mjs");
     return expect(inputError).resolves.toBeDefined();
 });
-test('httpError import ok?', () => {
+test("httpError import ok?", () => {
     const httpError = import("../types/http-error.mjs");
     return expect(httpError).resolves.toBeDefined();
 });
-test('language import ok?', () => {
+test("language import ok?", () => {
     const language = import("../types/language.mjs");
     return expect(language).resolves.toBeDefined();
 });
-test('traffictype import ok?', () => {
+test("traffictype import ok?", () => {
     const traffictype = import("../types/traffictype.mjs");
     return expect(traffictype).resolves.toBeDefined();
 });
-test('testutils import ok?', () => {
+test("testutils import ok?", () => {
     const testutils = import("../test/testutils.mjs");
     return expect(testutils).resolves.toBeDefined();
 });
-test('dbTestutils import ok?', () => {
+test("dbTestutils import ok?", () => {
     const dbTestutils = import("../test/db-testutils.mjs");
     return expect(dbTestutils).resolves.toBeDefined();
 });
-test('httpserver import ok?', () => {
+test("httpserver import ok?", () => {
     const httpserver = import("../test/httpserver.mjs");
     return expect(httpserver).resolves.toBeDefined();
 });
-test('asserter import ok?', () => {
+test("asserter import ok?", () => {
     const asserter = import("../test/asserter.mjs");
     return expect(asserter).resolves.toBeDefined();
 });
-test('rtz import ok?', () => {
+test("rtz import ok?", () => {
     const rtz = import("../marine/rtz.mjs");
     return expect(rtz).resolves.toBeDefined();
 });
-test('idUtils import ok?', () => {
+test("idUtils import ok?", () => {
     const idUtils = import("../marine/id_utils.mjs");
     return expect(idUtils).resolves.toBeDefined();
 });
-test('apiModel import ok?', () => {
+test("apiModel import ok?", () => {
     const apiModel = import("../utils/api-model.mjs");
     return expect(apiModel).resolves.toBeDefined();
 });
-test('logging import ok?', () => {
+test("logging import ok?", () => {
     const logging = import("../utils/logging.mjs");
     return expect(logging).resolves.toBeDefined();
 });
-test('base64 import ok?', () => {
+test("base64 import ok?", () => {
     const base64 = import("../utils/base64.mjs");
     return expect(base64).resolves.toBeDefined();
 });
-test('dateUtils import ok?', () => {
+test("dateUtils import ok?", () => {
     const dateUtils = import("../utils/date-utils.mjs");
     return expect(dateUtils).resolves.toBeDefined();
 });
-test('geojsonTypes import ok?', () => {
+test("geojsonTypes import ok?", () => {
     const geojsonTypes = import("../utils/geojson-types.mjs");
     return expect(geojsonTypes).resolves.toBeDefined();
 });
-test('slack import ok?', () => {
+test("slack import ok?", () => {
     const slack = import("../utils/slack.mjs");
     return expect(slack).resolves.toBeDefined();
 });
-test('utils import ok?', () => {
+test("utils import ok?", () => {
     const utils = import("../utils/utils.mjs");
     return expect(utils).resolves.toBeDefined();
 });
-test('retry import ok?', () => {
+test("retry import ok?", () => {
     const retry = import("../utils/retry.mjs");
     return expect(retry).resolves.toBeDefined();
 });
-test('geometry import ok?', () => {
+test("geometry import ok?", () => {
     const geometry = import("../utils/geometry.mjs");
     return expect(geometry).resolves.toBeDefined();
 });
-test('sqsIntegration import ok?', () => {
+test("sqsIntegration import ok?", () => {
     const sqsIntegration = import("../aws/infra/sqs-integration.mjs");
     return expect(sqsIntegration).resolves.toBeDefined();
 });
-test('networkStack import ok?', () => {
+test("networkStack import ok?", () => {
     const networkStack = import("../aws/infra/stacks/network-stack.mjs");
     return expect(networkStack).resolves.toBeDefined();
 });
-test('dbStack import ok?', () => {
+test("dbStack import ok?", () => {
     const dbStack = import("../aws/infra/stacks/db-stack.mjs");
     return expect(dbStack).resolves.toBeDefined();
 });
-test('dbProxyStack import ok?', () => {
+test("dbProxyStack import ok?", () => {
     const dbProxyStack = import("../aws/infra/stacks/db-proxy-stack.mjs");
     return expect(dbProxyStack).resolves.toBeDefined();
 });
-test('intraStackConfiguration import ok?', () => {
+test("intraStackConfiguration import ok?", () => {
     const intraStackConfiguration = import("../aws/infra/stacks/intra-stack-configuration.mjs");
     return expect(intraStackConfiguration).resolves.toBeDefined();
 });
-test('dbDnsStack import ok?', () => {
+test("dbDnsStack import ok?", () => {
     const dbDnsStack = import("../aws/infra/stacks/db-dns-stack.mjs");
     return expect(dbDnsStack).resolves.toBeDefined();
 });
-test('documentation import ok?', () => {
+test("documentation import ok?", () => {
     const documentation = import("../aws/infra/documentation.mjs");
     return expect(documentation).resolves.toBeDefined();
 });
-test('usagePlans import ok?', () => {
+test("usagePlans import ok?", () => {
     const usagePlans = import("../aws/infra/usage-plans.mjs");
     return expect(usagePlans).resolves.toBeDefined();
 });
-test('scheduler import ok?', () => {
+test("scheduler import ok?", () => {
     const scheduler = import("../aws/infra/scheduler.mjs");
     return expect(scheduler).resolves.toBeDefined();
 });
-test('importUtil import ok?', () => {
+test("importUtil import ok?", () => {
     const importUtil = import("../aws/infra/import-util.mjs");
     return expect(importUtil).resolves.toBeDefined();
 });
-test('sqsQueue import ok?', () => {
+test("sqsQueue import ok?", () => {
     const sqsQueue = import("../aws/infra/sqs-queue.mjs");
     return expect(sqsQueue).resolves.toBeDefined();
 });
-test('response import ok?', () => {
+test("response import ok?", () => {
     const response = import("../aws/infra/api/response.mjs");
     return expect(response).resolves.toBeDefined();
 });
-test('staticIntegration import ok?', () => {
+test("staticIntegration import ok?", () => {
     const staticIntegration = import("../aws/infra/api/static-integration.mjs");
     return expect(staticIntegration).resolves.toBeDefined();
 });
-test('responses import ok?', () => {
+test("responses import ok?", () => {
     const responses = import("../aws/infra/api/responses.mjs");
     return expect(responses).resolves.toBeDefined();
 });
-test('handlerFactory import ok?', () => {
+test("handlerFactory import ok?", () => {
     const handlerFactory = import("../aws/infra/api/handler-factory.mjs");
     return expect(handlerFactory).resolves.toBeDefined();
 });
-test('integration import ok?', () => {
+test("integration import ok?", () => {
     const integration = import("../aws/infra/api/integration.mjs");
     return expect(integration).resolves.toBeDefined();
 });
-test('stackCheckingAspect import ok?', () => {
+test("stackCheckingAspect import ok?", () => {
     const stackCheckingAspect = import("../aws/infra/stack/stack-checking-aspect.mjs");
     return expect(stackCheckingAspect).resolves.toBeDefined();
 });
-test('restApis import ok?', () => {
+test("restApis import ok?", () => {
     const restApis = import("../aws/infra/stack/rest_apis.mjs");
     return expect(restApis).resolves.toBeDefined();
 });
-test('lambdaConfigs import ok?', () => {
+test("lambdaConfigs import ok?", () => {
     const lambdaConfigs = import("../aws/infra/stack/lambda-configs.mjs");
     return expect(lambdaConfigs).resolves.toBeDefined();
 });
-test('monitoredfunction import ok?', () => {
+test("monitoredfunction import ok?", () => {
     const monitoredfunction = import("../aws/infra/stack/monitoredfunction.mjs");
     return expect(monitoredfunction).resolves.toBeDefined();
 });
-test('subscription import ok?', () => {
+test("subscription import ok?", () => {
     const subscription = import("../aws/infra/stack/subscription.mjs");
     return expect(subscription).resolves.toBeDefined();
 });
-test('parameters import ok?', () => {
+test("parameters import ok?", () => {
     const parameters = import("../aws/infra/stack/parameters.mjs");
     return expect(parameters).resolves.toBeDefined();
 });
-test('stack import ok?', () => {
+test("stack import ok?", () => {
     const stack = import("../aws/infra/stack/stack.mjs");
     return expect(stack).resolves.toBeDefined();
 });
-test('securityRule import ok?', () => {
+test("securityRule import ok?", () => {
     const securityRule = import("../aws/infra/security-rule.mjs");
     return expect(securityRule).resolves.toBeDefined();
 });
-test('canary import ok?', () => {
+test("canary import ok?", () => {
     const canary = import("../aws/infra/canaries/canary.mjs");
     return expect(canary).resolves.toBeDefined();
 });
-test('databaseCanary import ok?', () => {
+test("databaseCanary import ok?", () => {
     const databaseCanary = import("../aws/infra/canaries/database-canary.mjs");
     return expect(databaseCanary).resolves.toBeDefined();
 });
-test('canaryAlarm import ok?', () => {
+test("canaryAlarm import ok?", () => {
     const canaryAlarm = import("../aws/infra/canaries/canary-alarm.mjs");
     return expect(canaryAlarm).resolves.toBeDefined();
 });
-test('canaryRole import ok?', () => {
+test("canaryRole import ok?", () => {
     const canaryRole = import("../aws/infra/canaries/canary-role.mjs");
     return expect(canaryRole).resolves.toBeDefined();
 });
-test('urlCanary import ok?', () => {
+test("urlCanary import ok?", () => {
     const urlCanary = import("../aws/infra/canaries/url-canary.mjs");
     return expect(urlCanary).resolves.toBeDefined();
 });
-test('canaryParameters import ok?', () => {
+test("canaryParameters import ok?", () => {
     const canaryParameters = import("../aws/infra/canaries/canary-parameters.mjs");
     return expect(canaryParameters).resolves.toBeDefined();
 });
-test('canaryKeys import ok?', () => {
+test("canaryKeys import ok?", () => {
     const canaryKeys = import("../aws/infra/canaries/canary-keys.mjs");
     return expect(canaryKeys).resolves.toBeDefined();
 });
-test('proxytypes import ok?', () => {
+test("proxytypes import ok?", () => {
     const proxytypes = import("../aws/types/proxytypes.mjs");
     return expect(proxytypes).resolves.toBeDefined();
 });
-test('tags import ok?', () => {
+test("tags import ok?", () => {
     const tags = import("../aws/types/tags.mjs");
     return expect(tags).resolves.toBeDefined();
 });
-test('mediatypes import ok?', () => {
+test("mediatypes import ok?", () => {
     const mediatypes = import("../aws/types/mediatypes.mjs");
     return expect(mediatypes).resolves.toBeDefined();
 });
-test('modelWithReference import ok?', () => {
+test("modelWithReference import ok?", () => {
     const modelWithReference = import("../aws/types/model-with-reference.mjs");
     return expect(modelWithReference).resolves.toBeDefined();
 });
-test('errors import ok?', () => {
+test("errors import ok?", () => {
     const errors = import("../aws/types/errors.mjs");
     return expect(errors).resolves.toBeDefined();
 });
-test('lambdaResponse import ok?', () => {
+test("lambdaResponse import ok?", () => {
     const lambdaResponse = import("../aws/types/lambda-response.mjs");
     return expect(lambdaResponse).resolves.toBeDefined();
 });
-test('dtLoggerDefault import ok?', () => {
+test("dtLoggerDefault import ok?", () => {
     const dtLoggerDefault = import("../aws/runtime/dt-logger-default.mjs");
     return expect(dtLoggerDefault).resolves.toBeDefined();
 });
-test('secret import ok?', () => {
+test("secret import ok?", () => {
     const secret = import("../aws/runtime/secrets/secret.mjs");
     return expect(secret).resolves.toBeDefined();
 });
-test('proxyHolder import ok?', () => {
+test("proxyHolder import ok?", () => {
     const proxyHolder = import("../aws/runtime/secrets/proxy-holder.mjs");
     return expect(proxyHolder).resolves.toBeDefined();
 });
-test('dbsecret import ok?', () => {
+test("dbsecret import ok?", () => {
     const dbsecret = import("../aws/runtime/secrets/dbsecret.mjs");
     return expect(dbsecret).resolves.toBeDefined();
 });
-test('rdsHolder import ok?', () => {
+test("rdsHolder import ok?", () => {
     const rdsHolder = import("../aws/runtime/secrets/rds-holder.mjs");
     return expect(rdsHolder).resolves.toBeDefined();
 });
-test('secretHolder import ok?', () => {
+test("secretHolder import ok?", () => {
     const secretHolder = import("../aws/runtime/secrets/secret-holder.mjs");
     return expect(secretHolder).resolves.toBeDefined();
 });
-test('dtLogger import ok?', () => {
+test("dtLogger import ok?", () => {
     const dtLogger = import("../aws/runtime/dt-logger.mjs");
     return expect(dtLogger).resolves.toBeDefined();
 });
-test('s3 import ok?', () => {
+test("s3 import ok?", () => {
     const s3 = import("../aws/runtime/s3.mjs");
     return expect(s3).resolves.toBeDefined();
 });
-test('messaging import ok?', () => {
-    const messaging = import("../aws/runtime/messaging.mjs");
-    return expect(messaging).resolves.toBeDefined();
-});
 /*
 temporary disable, enable after sdk v2 is kicked out
 test('apikey import ok?', () => {
   const apikey = import("../aws/runtime/apikey.mjs");
   return expect(apikey).resolves.toBeDefined();
 });*/
-test('environment import ok?', () => {
+test("environment import ok?", () => {
     const environment = import("../aws/runtime/environment.mjs");
     return expect(environment).resolves.toBeDefined();
 });
-test('digitrafficIntegrationResponse import ok?', () => {
+test("digitrafficIntegrationResponse import ok?", () => {
     const digitrafficIntegrationResponse = import("../aws/runtime/digitraffic-integration-response.mjs");
     return expect(digitrafficIntegrationResponse).resolves.toBeDefined();
 });

package/dist/__test__/infra/acl-builder.test.mjs

@@ -0,0 +1,25 @@
+import { AclBuilder } from "../../aws/infra/acl-builder.mjs";
+import { App, Stack } from "aws-cdk-lib";
+describe("acl-builder tests", () => {
+    function createBuilder() {
+        const app = new App();
+        const stack = new Stack(app);
+        return new AclBuilder(stack);
+    }
+    test("no rules", () => {
+        expect(() => createBuilder().build()).toThrow();
+    });
+    test("default rules", () => {
+        const acl = createBuilder().withAWSManagedRules().build();
+        expect(acl.rules).toHaveLength(4);
+    });
+    test("two aws rules", () => {
+        const acl = createBuilder().withAWSManagedRules(["CommonRuleSet", "AmazonIpReputationList"]).build();
+        expect(acl.rules).toHaveLength(2);
+    });
+    test("ip restriction", () => {
+        const acl = createBuilder().withIpRestrictionRule(["1.2.3.4", "1.2.6.6"]).build();
+        expect(acl.rules).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=acl-builder.test.mjs.map

package/dist/__test__/{api → infra/api}/handler-factory.test.mjs

@@ -1,6 +1,6 @@
-import { HandlerFactory } from "../../aws/infra/api/handler-factory.mjs";
-import { DtLogger } from "../../aws/runtime/dt-logger.mjs";
-import { LambdaResponse } from "../../aws/types/lambda-response.mjs";
+import { HandlerFactory } from "../../../aws/infra/api/handler-factory.mjs";
+import { DtLogger } from "../../../aws/runtime/dt-logger.mjs";
+import { LambdaResponse } from "../../../aws/types/lambda-response.mjs";
 import { jest } from "@jest/globals";
 const logger = new DtLogger();
 describe("handler-factory tests", () => {

package/dist/__test__/{api → infra/api}/response.test.mjs

@@ -1,4 +1,4 @@
-import { RESPONSE_DEFAULT_LAMBDA } from "../../aws/infra/api/response.mjs";
+import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.mjs";
 import etag from "etag";
 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
 //const velocity = require("velocityjs");

package/dist/__test__/infra/api/static-integration.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/{api → infra/api}/static-integration.test.mjs

@@ -1,5 +1,5 @@
-import { DigitrafficStaticIntegration } from "../../aws/infra/api/static-integration.mjs";
-import { MediaType } from "../../aws/types/mediatypes.mjs";
+import { DigitrafficStaticIntegration } from "../../../aws/infra/api/static-integration.mjs";
+import { MediaType } from "../../../aws/types/mediatypes.mjs";
 describe("response tests", () => {
     it("createIntegrationResponse works", () => {
         const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse("FakeResource", MediaType.APPLICATION_JSON, { "test-header": "test-value" });

package/dist/__test__/infra/documentation.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/documentation.test.mjs

@@ -0,0 +1,37 @@
+import { DocumentationPart } from "../../aws/infra/documentation.mjs";
+const METHOD_NAME = "test";
+const SUMMARY = "summary";
+const PARAMETER_NAME = "parameter";
+const DESCRIPTION = "description";
+const DEPRECATION_NOTE = "note";
+describe("DocumentationPart tests", () => {
+    test("method", () => {
+        const part = DocumentationPart.method([], METHOD_NAME, SUMMARY);
+        expect(part.type).toEqual("METHOD");
+        expect(part.parameterName).toEqual(METHOD_NAME);
+        expect(part.documentationProperties.summary).toEqual(SUMMARY);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+    test("method - deprecated", () => {
+        const part = DocumentationPart.method([], METHOD_NAME, SUMMARY).deprecated(DEPRECATION_NOTE);
+        expect(part.type).toEqual("METHOD");
+        expect(part.parameterName).toEqual(METHOD_NAME);
+        expect(part.documentationProperties.summary).toEqual(`${SUMMARY}. ${DEPRECATION_NOTE}`);
+        expect(part.documentationProperties.deprecated).toBeTruthy();
+    });
+    test("queryparameter", () => {
+        const part = DocumentationPart.queryParameter(PARAMETER_NAME, DESCRIPTION);
+        expect(part.type).toEqual("QUERY_PARAMETER");
+        expect(part.parameterName).toEqual(PARAMETER_NAME);
+        expect(part.documentationProperties.description).toEqual(DESCRIPTION);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+    test("pathparameter", () => {
+        const part = DocumentationPart.pathParameter(PARAMETER_NAME, DESCRIPTION);
+        expect(part.type).toEqual("PATH_PARAMETER");
+        expect(part.parameterName).toEqual(PARAMETER_NAME);
+        expect(part.documentationProperties.description).toEqual(DESCRIPTION);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+});
+//# sourceMappingURL=documentation.test.mjs.map

package/dist/__test__/infra/scheduler.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/scheduler.test.mjs

@@ -0,0 +1,22 @@
+import { App, Stack } from "aws-cdk-lib";
+import { Scheduler } from "../../aws/infra/scheduler.mjs";
+import { Template } from "aws-cdk-lib/assertions";
+describe("scheduler tests", () => {
+    function expectRate(createScheduler, expectedRate) {
+        const app = new App();
+        const stack = new Stack(app);
+        createScheduler(stack);
+        const template = Template.fromStack(stack);
+        template.hasResource("AWS::Events::Rule", {
+            Properties: {
+                ScheduleExpression: expectedRate,
+                State: "ENABLED"
+            }
+        });
+    }
+    test("everyMinute", () => expectRate((stack) => Scheduler.everyMinute(stack, "test"), "rate(1 minute)"));
+    test("everyMinutes", () => expectRate((stack) => Scheduler.everyMinutes(stack, "test", 12), "rate(12 minutes)"));
+    test("everyHour", () => expectRate((stack) => Scheduler.everyHour(stack, "test"), "rate(1 hour)"));
+    test("everyDay", () => expectRate((stack) => Scheduler.everyDay(stack, "test"), "rate(1 day)"));
+});
+//# sourceMappingURL=scheduler.test.mjs.map

package/dist/__test__/infra/security-rule.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/security-rule.test.mjs

@@ -0,0 +1,20 @@
+import { App, Stack } from "aws-cdk-lib";
+import { Template } from "aws-cdk-lib/assertions";
+import { DigitrafficSecurityRule } from "../../aws/infra/security-rule.mjs";
+import { Topic } from "aws-cdk-lib/aws-sns";
+describe("security-rule tests", () => {
+    test("create", () => {
+        const app = new App();
+        const stack = new Stack(app);
+        const topic = new Topic(stack, "test");
+        new DigitrafficSecurityRule(stack, topic);
+        const template = Template.fromStack(stack);
+        template.hasResource("AWS::Events::Rule", {
+            Properties: {
+                EventPattern: {},
+                State: "ENABLED"
+            }
+        });
+    });
+});
+//# sourceMappingURL=security-rule.test.mjs.map

package/dist/aws/infra/acl-builder.d.mts

@@ -0,0 +1,21 @@
+import { CfnWebACL } from "aws-cdk-lib/aws-wafv2";
+import type { Construct } from "constructs";
+export type AWSManagedWafRule = "CommonRuleSet" | "AmazonIpReputationList" | "KnownBadInputsRuleSet" | "SQLiRuleSet";
+/**
+ * Builder class for building CfnWebACL.
+ *
+ * Currently supports:
+ * * Some AWS managed WAF rules
+ * * IP blacklisting
+ */
+export declare class AclBuilder {
+    readonly _construct: Construct;
+    readonly _rules: CfnWebACL.RuleProperty[];
+    _scope: string;
+    _name: string;
+    constructor(construct: Construct);
+    isRuleDefined(rules: AWSManagedWafRule[] | "all", rule: AWSManagedWafRule): boolean;
+    withAWSManagedRules(rules?: AWSManagedWafRule[] | "all"): AclBuilder;
+    withIpRestrictionRule(addresses: string[]): AclBuilder;
+    build(): CfnWebACL;
+}

package/dist/aws/infra/acl-builder.mjs

@@ -0,0 +1,136 @@
+import { CfnIPSet, CfnWebACL } from "aws-cdk-lib/aws-wafv2";
+/**
+ * Builder class for building CfnWebACL.
+ *
+ * Currently supports:
+ * * Some AWS managed WAF rules
+ * * IP blacklisting
+ */
+export class AclBuilder {
+    _construct;
+    _rules = [];
+    _scope = "CLOUDFRONT";
+    _name = "WebACL";
+    constructor(construct) {
+        this._construct = construct;
+    }
+    isRuleDefined(rules, rule) {
+        return rules === "all" || rules.includes(rule);
+    }
+    withAWSManagedRules(rules = "all") {
+        if (this.isRuleDefined(rules, "CommonRuleSet")) {
+            this._rules.push(createAWSCommonRuleSet());
+        }
+        if (this.isRuleDefined(rules, "AmazonIpReputationList")) {
+            this._rules.push(createAWSReputationList());
+        }
+        if (this.isRuleDefined(rules, "KnownBadInputsRuleSet")) {
+            this._rules.push(createAWSKnownBadInput());
+        }
+        if (this.isRuleDefined(rules, "SQLiRuleSet")) {
+            this._rules.push(createAWSAntiSQLInjection());
+        }
+        return this;
+    }
+    withIpRestrictionRule(addresses) {
+        const blocklistIpSet = new CfnIPSet(this._construct, "BlocklistIpSet", {
+            ipAddressVersion: "IPV4",
+            scope: this._scope,
+            addresses,
+        });
+        this._rules.push({
+            name: "IpBlocklist",
+            priority: 10,
+            action: { block: {} },
+            statement: {
+                ipSetReferenceStatement: {
+                    arn: blocklistIpSet.attrArn,
+                },
+            },
+            visibilityConfig: {
+                sampledRequestsEnabled: false,
+                cloudWatchMetricsEnabled: true,
+                metricName: "IpBlocklist",
+            },
+        });
+        return this;
+    }
+    build() {
+        if (this._rules.length === 0) {
+            throw new Error("No rules defined for WebACL");
+        }
+        const acl = new CfnWebACL(this._construct, this._name, {
+            defaultAction: { allow: {} },
+            scope: this._scope,
+            visibilityConfig: {
+                cloudWatchMetricsEnabled: true,
+                metricName: "WAF-Blocked",
+                sampledRequestsEnabled: false
+            },
+            rules: this._rules,
+            //            customResponseBodies
+        });
+        return acl;
+    }
+}
+function createAWSCommonRuleSet() {
+    return createRuleProperty("AWS-AWSManagedRulesCommonRuleSet", 70, {
+        statement: {
+            managedRuleGroupStatement: {
+                vendorName: "AWS",
+                name: "AWSManagedRulesCommonRuleSet",
+                excludedRules: [
+                    { name: "NoUserAgent_HEADER" },
+                    { name: "SizeRestrictions_BODY" },
+                    { name: "GenericRFI_BODY" }
+                ]
+            }
+        }
+    });
+}
+function createAWSReputationList() {
+    return createRuleProperty("AWS-AWSManagedRulesAmazonIpReputationList", 80, {
+        statement: {
+            managedRuleGroupStatement: {
+                vendorName: "AWS",
+                name: "AWSManagedRulesAmazonIpReputationList"
+            }
+        }
+    });
+}
+function createAWSKnownBadInput() {
+    return createRuleProperty("AWS-AWSManagedRulesKnownBadInputsRuleSet", 90, {
+        statement: {
+            managedRuleGroupStatement: {
+                vendorName: "AWS",
+                name: "AWSManagedRulesKnownBadInputsRuleSet"
+            }
+        }
+    });
+}
+function createAWSAntiSQLInjection() {
+    return createRuleProperty("AWS-AWSManagedRulesSQLiRuleSet", 100, {
+        statement: {
+            managedRuleGroupStatement: {
+                vendorName: "AWS",
+                name: "AWSManagedRulesSQLiRuleSet"
+            }
+        }
+    });
+}
+function createRuleProperty(name, priority, rule, overrideAction = true) {
+    return {
+        ...{
+            name,
+            priority,
+            visibilityConfig: {
+                sampledRequestsEnabled: true,
+                cloudWatchMetricsEnabled: true,
+                metricName: name
+            }
+        },
+        ...rule,
+        ...(overrideAction ? { overrideAction: { none: {} } } : {})
+    };
+}
+//# sourceMappingURL=acl-builder.mjs.map

package/dist/aws/infra/security-rule.mjs

@@ -9,11 +9,11 @@ import { SnsTopic } from "aws-cdk-lib/aws-events-targets";
  */
 export class DigitrafficSecurityRule extends Rule {
     constructor(scope, topic) {
-        const ruleName = 'SecurityHubRule';
+        const ruleName = "SecurityHubRule";
         super(scope, ruleName, {
             ruleName,
             eventPattern: {
-                source: ['aws.securityhub'],
+                source: ["aws.securityhub"],
                 detailType: ["Security Hub Findings - Imported"],
                 detail: {
                     findings: {

package/dist/aws/infra/sqs-queue.mjs

@@ -7,10 +7,10 @@ import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { ComparisonOperator, TreatMissingData } from "aws-cdk-lib/aws-cloudwatch";
 import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
-import { S3, S3Client } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
 import { DigitrafficStack } from "./stack/stack.mjs";
 import { MonitoredFunction } from "./stack/monitoredfunction.mjs";
+import { ObjectCannedACL, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { logger } from "../runtime/dt-logger-default.mjs";
 /**
  * Construct for creating SQS-queues.
  *
@@ -83,36 +83,25 @@ function addDLQAlarm(stack, dlqName, dlq) {
 function getDlqCode(Bucket) {
     const functionBody = DLQ_LAMBDA_CODE.replace("__bucketName__", Bucket)
         .replace("__upload__", uploadToS3.toString())
-        .replace("__doUpload__", doUpload.toString())
         .replace("__handler__", createHandler().toString().substring(23)); // remove function handler() from signature
     return new InlineCode(functionBody);
 }
-async function uploadToS3(s3, Bucket, Body, Key) {
+async function uploadToS3(s3, bucketName, body, objectName, cannedAcl, contentType) {
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: objectName,
+        Body: body,
+        ACL: cannedAcl,
+        ContentType: contentType,
+    });
     try {
-        console.info("writing %s to %s", Key, Bucket);
-        await doUpload(s3, Bucket, Body, Key);
+        await s3.send(command);
     }
     catch (error) {
-        console.warn(error);
-        console.warn("method=uploadToS3 retrying upload to bucket %s", Bucket);
-        try {
-            await doUpload(s3, Bucket, Body, Key);
-        }
-        catch (e2) {
-            console.error("method=uploadToS3 failed retrying upload to bucket %s", Bucket);
-        }
-    }
-}
-async function doUpload(s3, Bucket, Body, Key) {
-    try {
-        const upload = new Upload({
-            client: s3,
-            params: { Bucket, Key, Body },
+        logger.error({
+            method: "s3.uploadToS3",
+            message: `upload failed to bucket ${bucketName}`,
         });
-        await upload.done();
-    }
-    catch (error) {
-        console.error(error);
     }
 }
 // bucketName is unused, will be overridden in the actual lambda code below
@@ -120,16 +109,22 @@ const bucketName = "";
 function createHandler() {
     return async function handler(event) {
         const millis = new Date().getTime();
-        await Promise.all(event.Records.map((e, idx) => uploadToS3(new S3(), bucketName, e.body, `dlq-${millis}-${idx}.json`)));
+        const s3 = new S3Client({});
+        await Promise.all(event.Records.map((e, idx) => {
+            uploadToS3(s3, bucketName, e.body, `dlq-${millis}-${idx}.json`);
+        }));
     };
 }
 const DLQ_LAMBDA_CODE = `
-import { S3, S3Client } from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
+import type { ObjectCannedACL } from "@aws-sdk/client-s3";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { type NodeJsRuntimeStreamingBlobPayloadInputTypes } from "@smithy/types";
+import { logger } from "./dt-logger-default.mjs";
+
+
 const bucketName = "__bucketName__";
 
 __upload__
-__doUpload__
 
 exports.handler = async (event) => __handler__
 `;

package/dist/aws/runtime/s3.d.mts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ObjectCannedACL } from "@aws-sdk/client-s3";
-import { Readable } from "node:stream";
-export declare function uploadToS3(bucketName: string, body: Readable, objectName: string, cannedAcl?: ObjectCannedACL, contentType?: string): Promise<void>;
+import { S3Client } from "@aws-sdk/client-s3";
+import { type NodeJsRuntimeStreamingBlobPayloadInputTypes } from "@smithy/types";
+export declare function uploadToS3(s3: S3Client, bucketName: string, body: NodeJsRuntimeStreamingBlobPayloadInputTypes, objectName: string, cannedAcl?: ObjectCannedACL, contentType?: string): Promise<void>;

package/dist/aws/runtime/s3.mjs

@@ -1,31 +1,22 @@
-import { Upload } from "@aws-sdk/lib-storage";
-import { S3 } from "@aws-sdk/client-s3";
-import { Readable } from "node:stream";
-export async function uploadToS3(bucketName, body, objectName, cannedAcl, contentType) {
-    const s3 = new S3();
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import {} from "@smithy/types";
+import { logger } from "./dt-logger-default.mjs";
+export async function uploadToS3(s3, bucketName, body, objectName, cannedAcl, contentType) {
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: objectName,
+        Body: body,
+        ACL: cannedAcl,
+        ContentType: contentType,
+    });
     try {
-        await doUpload(s3, bucketName, body, objectName, cannedAcl, contentType);
+        await s3.send(command);
     }
     catch (error) {
-        console.warn("method=uploadToS3 retrying upload to bucket %s", bucketName);
-        try {
-            await doUpload(s3, bucketName, body, objectName, cannedAcl, contentType);
-        }
-        catch (e2) {
-            console.error("method=uploadToS3 failed retrying upload to bucket %s", bucketName);
-        }
+        logger.error({
+            method: "s3.uploadToS3",
+            message: `upload failed to bucket ${bucketName}`,
+        });
     }
 }
-function doUpload(s3, bucketName, body, filename, cannedAcl, contentType) {
-    return new Upload({
-        client: s3,
-        params: {
-            Bucket: bucketName,
-            Body: body,
-            Key: filename,
-            ACL: cannedAcl,
-            ContentType: contentType,
-        },
-    }).done();
-}
 //# sourceMappingURL=s3.mjs.map

package/dist/marine/id_utils.mjs

@@ -1,3 +1,4 @@
+import { logger } from "../aws/runtime/dt-logger-default.mjs";
 export function isValidIMO(imo) {
     return imo >= 1000000 && imo <= 9999999 && imoChecksumIsValid(imo);
 }
@@ -10,10 +11,10 @@ function imoChecksumIsValid(imo) {
     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 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);
+        logger.warn({ method: "idUtils.imoChecksumIsValid", message: `IMO checksum failed ${imo}` });
     }
     return checkResult;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2024.3.22-2",
+  "version": "2024.4.4-1",
   "description": "",
   "type": "module",
   "repository": {
@@ -56,6 +56,7 @@
     "./dist/aws/infra/stacks/db-proxy-stack": "./dist/aws/infra/stacks/db-proxy-stack.mjs",
     "./dist/aws/infra/stacks/intra-stack-configuration": "./dist/aws/infra/stacks/intra-stack-configuration.mjs",
     "./dist/aws/infra/stacks/db-dns-stack": "./dist/aws/infra/stacks/db-dns-stack.mjs",
+    "./dist/aws/infra/acl-builder": "./dist/aws/infra/acl-builder.mjs",
     "./dist/aws/infra/documentation": "./dist/aws/infra/documentation.mjs",
     "./dist/aws/infra/usage-plans": "./dist/aws/infra/usage-plans.mjs",
     "./dist/aws/infra/scheduler": "./dist/aws/infra/scheduler.mjs",
@@ -97,44 +98,44 @@
     "./dist/aws/runtime/secrets/secret-holder": "./dist/aws/runtime/secrets/secret-holder.mjs",
     "./dist/aws/runtime/dt-logger": "./dist/aws/runtime/dt-logger.mjs",
     "./dist/aws/runtime/s3": "./dist/aws/runtime/s3.mjs",
-    "./dist/aws/runtime/messaging": "./dist/aws/runtime/messaging.mjs",
     "./dist/aws/runtime/apikey": "./dist/aws/runtime/apikey.mjs",
     "./dist/aws/runtime/environment": "./dist/aws/runtime/environment.mjs",
     "./dist/aws/runtime/digitraffic-integration-response": "./dist/aws/runtime/digitraffic-integration-response.mjs"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.533.0",
-    "@aws-sdk/lib-storage": "^3.533.0",
-    "@aws-sdk/client-secrets-manager": "^3.533.0",
-    "@aws-sdk/client-api-gateway": "^3.533.0",
-    "@aws-sdk/client-sns": "^3.533.0",
+    "@aws-sdk/client-s3": "^3.540.0",
+    "@aws-sdk/lib-storage": "^3.540.0",
+    "@aws-sdk/client-secrets-manager": "^3.540.0",
+    "@aws-sdk/client-api-gateway": "^3.540.0",
+    "@aws-sdk/client-sns": "^3.540.0",
     "@types/geojson": "^7946.0.14",
-    "aws-cdk-lib": "^2.133.0",
+    "aws-cdk-lib": "^2.134.0",
     "change-case": "5.0.0",
     "constructs": "^10.3.0",
     "date-fns": "~2.30.0",
     "date-fns-tz": "~2.0.0",
     "etag": "^1.8.1",
     "geojson-validation": "^1.0.2",
-    "ky": "^1.2.2",
+    "ky": "^1.2.3",
     "lodash": "~4.17.21",
     "node-ttl": "^0.2.0",
     "pg-native": "^3.0.1",
     "pg-promise": "^11.5.4"
   },
   "devDependencies": {
-    "aws-sdk": "2.1577.0",
-    "@aws-sdk/client-s3": "3.533.0",
-    "@aws-sdk/lib-storage": "3.533.0",
-    "@aws-sdk/client-secrets-manager": "3.533.0",
-    "@aws-sdk/client-api-gateway": "3.533.0",
-    "@aws-sdk/client-sns": "3.533.0",
+    "aws-sdk": "2.1586.0",
+    "@aws-sdk/client-s3": "3.540.0",
+    "@aws-sdk/lib-storage": "3.540.0",
+    "@aws-sdk/client-secrets-manager": "3.540.0",
+    "@aws-sdk/client-api-gateway": "3.540.0",
+    "@aws-sdk/client-sns": "3.540.0",
     "@jest/globals": "^29.7.0",
     "@rushstack/eslint-config": "^3.6.4",
     "@rushstack/heft": "^0.66.0",
     "@rushstack/heft-jest-plugin": "^0.11.21",
     "@rushstack/heft-lint-plugin": "^0.3.20",
     "@rushstack/heft-typescript-plugin": "^0.3.20",
+    "@smithy/types": "2.12.0",
     "@types/aws-lambda": "8.10.136",
     "@types/etag": "1.8.3",
     "@types/geojson": "^7946.0.14",
@@ -142,10 +143,9 @@
     "@types/jest": "29.5.12",
     "@types/lodash": "4.14.202",
     "@types/node": "20.11.27",
-    "@types/sinon": "17.0.3",
     "@typescript-eslint/eslint-plugin": "~6.18.1",
     "@typescript-eslint/parser": "^6.20.0",
-    "aws-cdk-lib": "^2.133.0",
+    "aws-cdk-lib": "^2.134.0",
     "change-case": "5.3.0",
     "constructs": "10.3.0",
     "date-fns": "~2.30.0",
@@ -157,13 +157,12 @@
     "geojson-validation": "^1.0.2",
     "jest": "^29.7.0",
     "jest-junit": "^16.0.0",
-    "ky": "^1.2.2",
+    "ky": "^1.2.3",
     "lodash": "~4.17.21",
     "node-ttl": "^0.2.0",
     "pg-promise": "^11.5.4",
     "prettier": "^3.2.5",
     "rimraf": "^5.0.5",
-    "sinon": "17.0.1",
     "ts-jest": "^29.1.2",
     "typescript": "~5.3.3",
     "velocityjs": "2.0.6"

package/dist/aws/runtime/messaging.d.mts

@@ -1,10 +0,0 @@
-import { SNS as SNSType } from "@aws-sdk/client-sns";
-/**
- * Utility function for publishing SNS messages.
- * Made because using *await* with AWS APIs doesn't require calling promise() but nothing works if it isn't called.
- * Retries a single time in case of failure.
- * @param message
- * @param topicArn
- * @param sns
- */
-export declare function snsPublish(message: string, topicArn: string, sns: SNSType): Promise<void>;

package/dist/aws/runtime/messaging.mjs

@@ -1,28 +0,0 @@
-import { SNS as SNSType } from "@aws-sdk/client-sns";
-/**
- * Utility function for publishing SNS messages.
- * Made because using *await* with AWS APIs doesn't require calling promise() but nothing works if it isn't called.
- * Retries a single time in case of failure.
- * @param message
- * @param topicArn
- * @param sns
- */
-export async function snsPublish(message, topicArn, sns) {
-    const publishParams = {
-        Message: message,
-        TopicArn: topicArn,
-    };
-    try {
-        await sns.publish(publishParams);
-    }
-    catch (error) {
-        console.error("method=snsPublish error, retrying", error);
-        try {
-            await sns.publish(publishParams);
-        }
-        catch (e2) {
-            console.error("method=snsPublish error after retry", e2);
-        }
-    }
-}
-//# sourceMappingURL=messaging.mjs.map