@digitraffic/common 2024.4.25-1 → 2024.5.13-1

package/README.md

@@ -4,10 +4,11 @@ This is a place for common utilities and classes that can be used in other cdk-p
 
 ## How to build
 
-Use `npm` to build the code i.e.
+Use `pnpm` to build the code i.e.
 
-    npm run build
-    npm run test
+    pnpm install
+    pnpm build
+    pnpm test
 
 ## How to use
 

package/dist/__test__/imports.test.mjs

@@ -71,10 +71,6 @@ test("dbTestutils import ok?", () => {
     const dbTestutils = import("../test/db-testutils.mjs");
     return expect(dbTestutils).resolves.toBeDefined();
 });
-test("httpserver import ok?", () => {
-    const httpserver = import("../test/httpserver.mjs");
-    return expect(httpserver).resolves.toBeDefined();
-});
 test("asserter import ok?", () => {
     const asserter = import("../test/asserter.mjs");
     return expect(asserter).resolves.toBeDefined();

package/dist/aws/infra/stack/monitoredfunction.mjs

@@ -1,4 +1,4 @@
-import { Function, LoggingFormat } from "aws-cdk-lib/aws-lambda";
+import { ApplicationLogLevel, Function, LoggingFormat, SystemLogLevel } from "aws-cdk-lib/aws-lambda";
 import { Stack } from "aws-cdk-lib";
 import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
 import { ComparisonOperator, Metric } from "aws-cdk-lib/aws-cloudwatch";
@@ -75,7 +75,13 @@ export class MonitoredFunction extends Function {
      */
     constructor(scope, id, functionProps, alarmSnsTopic, warningSnsTopic, production, trafficType, props) {
         // Set default loggingFormat to JSON if not explicitly set to TEXT
-        super(scope, id, { ...{ loggingFormat: LoggingFormat.JSON }, ...functionProps });
+        super(scope, id, {
+            ...{
+                loggingFormat: LoggingFormat.JSON,
+                applicationLogLevel: ApplicationLogLevel.DEBUG,
+                systemLogLevel: SystemLogLevel.INFO
+            }, ...functionProps
+        });
         if (functionProps.functionName === undefined) {
             throw new Error("Function name not provided");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2024.4.25-1",
+  "version": "2024.05.13-1",
   "description": "",
   "type": "module",
   "repository": {

package/dist/__test__/test/httpserver.test.d.mts

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

package/dist/__test__/test/httpserver.test.mjs

@@ -1,154 +0,0 @@
-import { TestHttpServer, ERROR_NO_MATCH, ERRORCODE_NOT_FOUND, } from "../../test/httpserver.mjs";
-import { IncomingMessage } from "http";
-import { Socket } from "net";
-import { AsyncLocalStorage } from "node:async_hooks";
-import * as http from "http";
-import { expect } from "@jest/globals";
-const threadLocalPort = new AsyncLocalStorage();
-const DEFAULT_PATH = "/";
-const DEFAULT_PROPS = {
-    "/": () => "",
-};
-const findOpenPort = async (excludedPorts) => {
-    const ephemeralPorts = Array.from({ length: 65535 - 1024 + 1 }, (__, i) => 1024 + i);
-    const allSocketEvents = [
-        "close",
-        "connect",
-        "data",
-        "drain",
-        "end",
-        "error",
-        "lookup",
-        "ready",
-        "timeout",
-    ];
-    let openPort = null;
-    for (const testPort of ephemeralPorts) {
-        if (openPort !== null) {
-            break;
-        }
-        if (excludedPorts.has(testPort)) {
-            continue;
-        }
-        const portConnected = new Promise((resolve) => {
-            const socket = new Socket();
-            socket.setTimeout(500);
-            for (const socketEvent of allSocketEvents) {
-                if (socketEvent === "error") {
-                    socket.on(socketEvent, (error) => {
-                        socket.destroy();
-                        if (error.code === "ECONNREFUSED") {
-                            resolve(testPort);
-                        }
-                        else {
-                            resolve(null);
-                        }
-                    });
-                }
-                else {
-                    socket.on(socketEvent, () => {
-                        socket.destroy();
-                        resolve(null);
-                    });
-                }
-            }
-            // connect method is asynchronous. That is why we wrap this thing inside of a promise.
-            socket.connect({ port: testPort, host: "127.0.0.1" });
-        });
-        openPort = await portConnected;
-    }
-    if (openPort === null) {
-        throw Error("All ephemeral ports in use!");
-    }
-    return openPort;
-};
-const usedPorts = new Set();
-async function withServer(fn, props = DEFAULT_PROPS, statusCode = 200) {
-    const server = new TestHttpServer();
-    let openPort;
-    while (!openPort) {
-        const foundPort = await findOpenPort(usedPorts);
-        console.info(`foundPort ${foundPort}`);
-        if (!usedPorts.has(foundPort)) {
-            usedPorts.add(foundPort);
-            openPort = foundPort;
-        }
-    }
-    console.info(`Using port ${openPort} to run the test`);
-    server.listen(openPort, props, false, statusCode);
-    threadLocalPort.enterWith(openPort);
-    try {
-        await fn(server);
-    }
-    finally {
-        await server.close();
-        console.info("Server closed");
-    }
-}
-function sendGetRequest(path = DEFAULT_PATH) {
-    return sendRequest("GET", path);
-}
-function sendPostRequest(path = DEFAULT_PATH, body) {
-    return sendRequest("POST", path, body);
-}
-function sendRequest(method, path, body) {
-    return new Promise((resolve, reject) => {
-        const port = threadLocalPort.getStore();
-        const request = http.request({
-            path,
-            port,
-            method,
-        }, (response) => {
-            response.on("data", () => {
-                // do nothing
-            });
-            //the whole response has been received, so we just print it out here
-            response.on("end", () => {
-                resolve(response);
-            });
-            response.on("error", (error) => {
-                reject(error);
-            });
-        });
-        if (method === "POST") {
-            request.write(body);
-        }
-        request.end();
-    });
-}
-test("no calls", () => {
-    return withServer((server) => {
-        expect(server.getCallCount()).toEqual(0);
-    });
-});
-test("one get", async () => {
-    await withServer(async (server) => {
-        await sendGetRequest();
-        expect(server.getCallCount()).toEqual(1);
-    });
-});
-test("one get - no MATCH", async () => {
-    await withServer(async (server) => {
-        const response = await sendGetRequest("/no-match");
-        expect(server.getCallCount()).toEqual(1);
-        expect(server.getRequestBody(0)).toEqual(ERROR_NO_MATCH);
-        expect(response.statusCode).toEqual(ERRORCODE_NOT_FOUND);
-    });
-});
-test("get - error 405", async () => {
-    const ERROR_CODE = 405;
-    await withServer(async (server) => {
-        const response = await sendGetRequest();
-        expect(server.getCallCount()).toEqual(1);
-        expect(response.statusCode).toEqual(ERROR_CODE);
-    }, DEFAULT_PROPS, ERROR_CODE);
-});
-test("one post", async () => {
-    await withServer(async (server) => {
-        const testBody = "Testing123!";
-        await sendPostRequest(DEFAULT_PATH, testBody);
-        expect(server.getCallCount()).toEqual(1);
-        expect(server.getRequestBody(0)).toEqual(testBody);
-    });
-});
-//# sourceMappingURL=httpserver.test.mjs.map

package/dist/test/httpserver.d.mts

@@ -1,17 +0,0 @@
-export declare const ERROR_NO_MATCH = "NO MATCH";
-export declare const ERRORCODE_NOT_FOUND = 404;
-/**
- * A mock HTTP server created for testing connections from a Lambda to an outside integration
- */
-export declare class TestHttpServer {
-    private server?;
-    private debug;
-    private messageStack;
-    constructor();
-    getCallCount(): number;
-    getRequestBody(callNumber: number): string;
-    listen(port: number, props: ListenProperties, debug?: boolean, statusCode?: number): void;
-    close(): Promise<boolean>;
-    private debuglog;
-}
-export type ListenProperties = Record<string, (url?: string, data?: string) => string>;

package/dist/test/httpserver.mjs

@@ -1,85 +0,0 @@
-import { Server, createServer } from "http";
-import { parse } from "url";
-export const ERROR_NO_MATCH = "NO MATCH";
-export const ERRORCODE_NOT_FOUND = 404;
-/**
- * A mock HTTP server created for testing connections from a Lambda to an outside integration
- */
-export class TestHttpServer {
-    server;
-    debug;
-    messageStack;
-    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 = createServer((req, res) => {
-            this.debuglog("Mapped urls: ");
-            Object.keys(props).forEach((k) => this.debuglog(k));
-            if (!req.url) {
-                throw new Error("Missing request url!");
-            }
-            this.debuglog(`Received request to url ${req.url} ..`);
-            const path = parse(req.url).pathname;
-            if (!path) {
-                throw new Error("Missing path from request!");
-            }
-            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;
-                    const invokable = props[path];
-                    res.end(invokable(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] =
-                        ERROR_NO_MATCH;
-                    res.writeHead(ERRORCODE_NOT_FOUND);
-                    res.end(ERROR_NO_MATCH);
-                });
-            }
-        });
-        this.server.listen(port);
-    }
-    close() {
-        return new Promise((resolve, reject) => {
-            this.debuglog("Closing test server");
-            if (this.server !== undefined) {
-                this.server.close((error) => error != null ? reject(false) : resolve(true));
-            }
-            else {
-                resolve(true);
-            }
-        });
-    }
-    debuglog(str) {
-        if (this.debug) {
-            console.debug(str);
-        }
-    }
-}
-//# sourceMappingURL=httpserver.mjs.map