@digitraffic/common 2024.8.16-1 → 2024.8.27-1

package/dist/{test/asserter.mjs → __test__/asserter.js}

@@ -3,7 +3,7 @@
  */
 export class Asserter {
     static assertEquals(value, expected) {
-        if (value != expected) {
+        if (value !== expected) {
             throw new Error(`Given value ${value} was not expected ${expected}`);
         }
     }
@@ -16,7 +16,7 @@ export class Asserter {
         if (!data) {
             throw new Error("Given array was not defined");
         }
-        if (data.length != expected) {
+        if (data.length !== expected) {
             throw new Error(`Given array length ${data.length} was not expected ${expected}`);
         }
     }
@@ -38,4 +38,4 @@ export class Asserter {
         expect(expected - value).toBeLessThanOrEqual(delta);
     }
 }
-//# sourceMappingURL=asserter.mjs.map
+//# sourceMappingURL=asserter.js.map

package/dist/{test/db-testutils.d.mts → __test__/db-testutils.d.ts}

@@ -1,3 +1,3 @@
-import { type DTDatabase } from "../database/database.mjs";
+import { type DTDatabase } from "../database/database.js";
 export declare function assertCount(db: DTDatabase, sql: string, count: number): Promise<void>;
 export declare function dbTestBase(fn: (db: DTDatabase) => void, truncateFn: (db: DTDatabase) => Promise<void>, dbUser: string, dbPass: string, dbUri: string): () => void;

package/dist/{test/db-testutils.mjs → __test__/db-testutils.js}

@@ -1,9 +1,10 @@
-import { DatabaseEnvironmentKeys, initDbConnection } from "../database/database.mjs";
+import { DatabaseEnvironmentKeys, initDbConnection } from "../database/database.js";
+import { getEnvVariableOrElse } from "../utils/utils.js";
 export async function assertCount(db, sql, count) {
     await db.one(sql).then((x) => expect(x.count).toEqual(count));
 }
 export function dbTestBase(fn, truncateFn, dbUser, dbPass, dbUri) {
-    const theDbUri = process.env["DB_URI"] ?? dbUri;
+    const theDbUri = getEnvVariableOrElse("DB_URI", dbUri);
     console.log(`Test database URI: ${theDbUri}`);
     return () => {
         const db = initDbConnection(dbUser, dbPass, "test", theDbUri, {
@@ -33,4 +34,4 @@ export function dbTestBase(fn, truncateFn, dbUser, dbPass, dbUri) {
         fn(db);
     };
 }
-//# sourceMappingURL=db-testutils.mjs.map
+//# sourceMappingURL=db-testutils.js.map

package/dist/__test__/{dependencies.test.mjs → dependencies.test.js}

@@ -18,4 +18,4 @@ test("circular dependencies", async () => {
     assertNoErrors(errors);
 });
 export {};
-//# sourceMappingURL=dependencies.test.mjs.map
+//# sourceMappingURL=dependencies.test.js.map

package/dist/__test__/{imports.test.mjs → imports.test.js}

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

package/dist/__test__/infra/{acl-builder.test.mjs → acl-builder.test.js}

@@ -1,4 +1,4 @@
-import { AclBuilder } from "../../aws/infra/acl-builder.mjs";
+import { AclBuilder } from "../../aws/infra/acl-builder.js";
 import { App, Stack } from "aws-cdk-lib";
 import { expect } from "@jest/globals";
 describe("acl-builder tests", () => {
@@ -46,11 +46,11 @@ describe("acl-builder tests", () => {
         for (const aclBuilder of [
             createBuilder().withThrottleDigitrafficUserIp(undefined),
             createBuilder().withThrottleDigitrafficUserIpAndUriPath(undefined),
-            createBuilder().withThrottleAnonymousUserIp(null),
-            createBuilder().withThrottleAnonymousUserIpAndUriPath(null),
+            createBuilder().withThrottleAnonymousUserIp(undefined),
+            createBuilder().withThrottleAnonymousUserIpAndUriPath(undefined),
         ]) {
             expect(() => aclBuilder.build()).toThrowError("No rules");
         }
     });
 });
-//# sourceMappingURL=acl-builder.test.mjs.map
+//# sourceMappingURL=acl-builder.test.js.map

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

@@ -1,6 +1,5 @@
-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.js";
+import { DtLogger } from "../../../aws/runtime/dt-logger.js";
 import { jest } from "@jest/globals";
 const logger = new DtLogger();
 describe("handler-factory tests", () => {
@@ -40,4 +39,4 @@ describe("handler-factory tests", () => {
         expect(eh).toHaveBeenCalledTimes(1);
     });
 });
-//# sourceMappingURL=handler-factory.test.mjs.map
+//# sourceMappingURL=handler-factory.test.js.map

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

@@ -1,6 +1,5 @@
-import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.mjs";
+import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.js";
 import etag from "etag";
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
 //const velocity = require("velocityjs");
 import velocity from "velocityjs";
 const TEST_BODY = "Hello world!";
@@ -12,11 +11,7 @@ describe("response tests", () => {
         return etag(bodyBase64);
     }
     function generateResponse(status, fileName, timestamp) {
-        // eslint-disable-next-line
-        const compile = new velocity.Compile(
-        // eslint-disable-next-line
-        velocity.parse(RESPONSE_DEFAULT_LAMBDA));
-        // eslint-disable-next-line
+        const compile = new velocity.Compile(velocity.parse(RESPONSE_DEFAULT_LAMBDA));
         const output = compile.render({
             input: {
                 path: () => ({
@@ -67,20 +62,17 @@ describe("response tests", () => {
         assertOutputAndContext(output, context);
     });
     test("test 200 - filename", () => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
         const [output, context] = generateResponse(200, "test.txt");
         assertOutputAndContext(output, context, undefined, undefined, 'attachment; filename="test.txt"');
     });
     test("test 200 - filename and timestamp", () => {
         const now = new Date();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
         const [output, context] = generateResponse(200, "test.txt", now);
         assertOutputAndContext(output, context, undefined, undefined, 'attachment; filename="test.txt"', now);
     });
     test("test 204", () => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
         const [output, context] = generateResponse(204);
         assertOutputAndContext(output, context, 204, "text/plain");
     });
 });
-//# sourceMappingURL=response.test.mjs.map
+//# sourceMappingURL=response.test.js.map

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

@@ -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.js";
+import { MediaType } from "../../../aws/types/mediatypes.js";
 describe("response tests", () => {
     it("createIntegrationResponse works", () => {
         const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse("FakeResource", MediaType.APPLICATION_JSON, { "test-header": "test-value" });
@@ -25,4 +25,4 @@ describe("response tests", () => {
         });
     });
 });
-//# sourceMappingURL=static-integration.test.mjs.map
+//# sourceMappingURL=static-integration.test.js.map

package/dist/__test__/infra/{documentation.test.mjs → documentation.test.js}

@@ -1,4 +1,4 @@
-import { DocumentationPart } from "../../aws/infra/documentation.mjs";
+import { DocumentationPart } from "../../aws/infra/documentation.js";
 const METHOD_NAME = "test";
 const SUMMARY = "summary";
 const PARAMETER_NAME = "parameter";
@@ -34,4 +34,4 @@ describe("DocumentationPart tests", () => {
         expect(part.documentationProperties.deprecated).toBeFalsy();
     });
 });
-//# sourceMappingURL=documentation.test.mjs.map
+//# sourceMappingURL=documentation.test.js.map

package/dist/__test__/infra/{scheduler.test.mjs → scheduler.test.js}

@@ -1,5 +1,5 @@
 import { App, Stack } from "aws-cdk-lib";
-import { Scheduler } from "../../aws/infra/scheduler.mjs";
+import { Scheduler } from "../../aws/infra/scheduler.js";
 import { Template } from "aws-cdk-lib/assertions";
 describe("scheduler tests", () => {
     function expectRate(createScheduler, expectedRate) {
@@ -19,4 +19,4 @@ describe("scheduler tests", () => {
     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
+//# sourceMappingURL=scheduler.test.js.map

package/dist/__test__/infra/{security-rule.test.mjs → security-rule.test.js}

@@ -1,6 +1,6 @@
 import { App, Stack } from "aws-cdk-lib";
 import { Template } from "aws-cdk-lib/assertions";
-import { DigitrafficSecurityRule } from "../../aws/infra/security-rule.mjs";
+import { DigitrafficSecurityRule } from "../../aws/infra/security-rule.js";
 import { Topic } from "aws-cdk-lib/aws-sns";
 describe("security-rule tests", () => {
     test("create", () => {
@@ -17,4 +17,4 @@ describe("security-rule tests", () => {
         });
     });
 });
-//# sourceMappingURL=security-rule.test.mjs.map
+//# sourceMappingURL=security-rule.test.js.map

package/dist/__test__/marine/{id_utils.test.mjs → id_utils.test.js}

@@ -1,5 +1,5 @@
-import * as IdUtils from "../../marine/id_utils.mjs";
-import { getRandomNumber } from "../../test/testutils.mjs";
+import * as IdUtils from "../../marine/id_utils.js";
+import { getRandomNumber } from "../../__test__/testutils.js";
 describe("IdUtils tests", () => {
     test("isValidLOCODE - success", () => {
         expect(IdUtils.isValidLOCODE("FILOL")).toBe(true);
@@ -41,4 +41,4 @@ describe("IdUtils tests", () => {
         expect(IdUtils.isValidMMSI(getRandomNumber(999999999 + 1, 9999999999))).toBe(false);
     });
 });
-//# sourceMappingURL=id_utils.test.mjs.map
+//# sourceMappingURL=id_utils.test.js.map

package/dist/{test/mock-ky.mjs → __test__/mock-ky.js}

@@ -12,4 +12,4 @@ export function mockKyResponse(status, body) {
         text: () => response.text(),
     });
 }
-//# sourceMappingURL=mock-ky.mjs.map
+//# sourceMappingURL=mock-ky.js.map