@digitraffic/common 2022.12.2-1 → 2022.12.22-2

package/dist/aws/infra/api/handler-factory.d.ts

@@ -1,5 +1,7 @@
-export type LoggingHandler<RESPONSE> = (methodName: string, method: () => Promise<RESPONSE>) => Promise<RESPONSE>;
-export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
+import { DtLogger } from "../../runtime/dt-logger";
+import { LambdaResponse } from "../../types/lambda-response";
+export type LoggingHandler = (method: () => Promise<LambdaResponse>, logger: DtLogger) => Promise<LambdaResponse>;
+export type ErrorHandler = (error: unknown, logger: DtLogger) => LambdaResponse;
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:
@@ -9,12 +11,12 @@ export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
  * You should instantiate HandlerFactory in your project with desired error handling and use the factory instance for
  * creating handler-functions for your lambdas.
  */
-export declare class HandlerFactory<RESPONSE> {
+export declare class HandlerFactory {
     private loggingHandler;
     private errorHandler;
     constructor();
-    withLoggingHandler(loggingHandler: LoggingHandler<RESPONSE>): this;
-    withErrorHandler(errorHandler: ErrorHandler<RESPONSE>): this;
-    createEventHandler(methodName: string, handler: (event: unknown) => Promise<RESPONSE>): (event: unknown) => Promise<RESPONSE>;
+    withLoggingHandler(loggingHandler: LoggingHandler): this;
+    withErrorHandler(errorHandler: ErrorHandler): this;
+    createEventHandler(handler: (event: unknown) => Promise<LambdaResponse>, logger: DtLogger): (event: unknown) => Promise<LambdaResponse>;
 }
-export declare function createNoLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE>;
+export declare function createJsonLoggingHandler(): LoggingHandler;

package/dist/aws/infra/api/handler-factory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNoLoggingHandler = exports.HandlerFactory = void 0;
+exports.createJsonLoggingHandler = exports.HandlerFactory = void 0;
 /**
  * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
  * with the defaults:
@@ -12,7 +12,15 @@ exports.createNoLoggingHandler = exports.HandlerFactory = void 0;
  */
 class HandlerFactory {
     constructor() {
-        this.loggingHandler = createDefaultLoggingHandler();
+        this.loggingHandler = async (method) => {
+            const start = Date.now();
+            try {
+                return await method();
+            }
+            finally {
+                console.info("method=%s.handler tookMs=%d", process.env.AWS_LAMBDA_FUNCTION_NAME, Date.now() - start);
+            }
+        };
         this.errorHandler = (error) => {
             throw error;
         };
@@ -25,35 +33,30 @@ class HandlerFactory {
         this.errorHandler = errorHandler;
         return this;
     }
-    createEventHandler(methodName, handler) {
+    createEventHandler(handler, logger) {
         return async (event) => {
-            return await this.loggingHandler(methodName, async () => {
+            return await this.loggingHandler(async () => {
                 try {
                     return await handler(event);
                 }
                 catch (error) {
-                    return this.errorHandler(error);
+                    return this.errorHandler(error, logger);
                 }
-            });
+            }, logger);
         };
     }
 }
 exports.HandlerFactory = HandlerFactory;
-function createNoLoggingHandler() {
-    return (methodName, method) => {
-        return method();
-    };
-}
-exports.createNoLoggingHandler = createNoLoggingHandler;
-function createDefaultLoggingHandler() {
-    return (methodName, method) => {
+function createJsonLoggingHandler() {
+    return async (method, logger) => {
         const start = Date.now();
         try {
-            return method();
+            return await method();
         }
         finally {
-            console.info("method=%s tookMs=%d", methodName, Date.now() - start);
+            logger.info({ tookMs: Date.now() - start });
         }
     };
 }
+exports.createJsonLoggingHandler = createJsonLoggingHandler;
 //# sourceMappingURL=handler-factory.js.map

package/dist/aws/infra/api/integration.d.ts

@@ -11,8 +11,8 @@ export declare class DigitrafficIntegration {
     readonly mediaType: MediaType;
     readonly parameters: ApiParameter[];
     constructor(lambda: IFunction, mediaType?: MediaType);
-    addPathParameter(...names: string[]): DigitrafficIntegration;
-    addQueryParameter(...names: string[]): DigitrafficIntegration;
+    addPathParameter(...names: string[]): this;
+    addQueryParameter(...names: string[]): this;
     build(): LambdaIntegration;
     createRequestParameters(): Record<string, string>;
     createRequestTemplates(): Record<string, string>;

package/dist/aws/infra/api/responses.js

@@ -37,7 +37,7 @@ function methodResponse(status, contentType, model, parameters) {
     return {
         statusCode: status,
         responseModels: (0, response_1.createResponses)(contentType, model),
-        responseParameters: parameters || {},
+        responseParameters: parameters ?? {},
     };
 }
 exports.methodResponse = methodResponse;
@@ -65,14 +65,14 @@ exports.corsMethod = corsMethod;
 function defaultIntegration(lambdaFunction, options) {
     return new aws_apigateway_1.LambdaIntegration(lambdaFunction, {
         proxy: false,
-        integrationResponses: options?.responses || [
+        integrationResponses: options?.responses ?? [
             getResponse(exports.RESPONSE_200_OK, options),
             getResponse(exports.RESPONSE_400_BAD_REQUEST, options),
             getResponse(exports.RESPONSE_404_NOT_FOUND, options),
             getResponse(exports.RESPONSE_500_SERVER_ERROR, options),
         ],
-        requestParameters: options?.requestParameters || {},
-        requestTemplates: options?.requestTemplates || {},
+        requestParameters: options?.requestParameters ?? {},
+        requestTemplates: options?.requestTemplates ?? {},
         passthroughBehavior: options?.passthroughBehavior ?? aws_apigateway_1.PassthroughBehavior.WHEN_NO_MATCH,
     });
 }

package/dist/aws/infra/canaries/canary-parameters.d.ts

@@ -1,7 +1,7 @@
 import { Schedule } from "@aws-cdk/aws-synthetics-alpha";
 /** Optional env parameters for canary */
 type CanaryEnv = Record<string, string>;
-export type CanaryParameters = {
+export interface CanaryParameters {
     readonly name: string;
     readonly schedule?: Schedule;
     readonly secret?: string;
@@ -14,5 +14,5 @@ export type CanaryParameters = {
         readonly topicArn?: string;
     };
     readonly canaryEnv?: CanaryEnv;
-};
+}
 export {};

package/dist/aws/infra/canaries/canary-role.d.ts

@@ -2,5 +2,5 @@ import { Role } from "aws-cdk-lib/aws-iam";
 import { Construct } from "constructs";
 export declare class DigitrafficCanaryRole extends Role {
     constructor(stack: Construct, canaryName: string);
-    withDatabaseAccess(): DigitrafficCanaryRole;
+    withDatabaseAccess(): this;
 }

package/dist/aws/infra/canaries/canary-role.js

@@ -13,19 +13,17 @@ const BASE_POLICY_STATEMENT_PROPS = {
     resources: ["*"],
 };
 const CLOUDWATCH_STATEMENT_PROPS = {
-    actions: [
-        "cloudwatch:PutMetricData",
-    ],
+    actions: ["cloudwatch:PutMetricData"],
     resources: ["*"],
     conditions: {
-        "StringEquals": {
+        StringEquals: {
             "cloudwatch:namespace": "CloudWatchSynthetics",
         },
     },
 };
 class DigitrafficCanaryRole extends aws_iam_1.Role {
     constructor(stack, canaryName) {
-        super(stack, 'canary-role-' + canaryName, {
+        super(stack, "canary-role-" + canaryName, {
             assumedBy: new aws_iam_1.ServicePrincipal("lambda.amazonaws.com"),
             managedPolicies: [
                 aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName("CloudWatchSyntheticsFullAccess"),

package/dist/aws/infra/documentation.d.ts

@@ -49,7 +49,7 @@ export declare class DocumentationPart {
     readonly type: string;
     readonly documentationProperties: DocumentationProperties;
     private constructor();
-    deprecated(note: string): DocumentationPart;
+    deprecated(note: string): this;
     static queryParameter(parameterName: string, description: string): DocumentationPart;
     static pathParameter(parameterName: string, description: string): DocumentationPart;
     static method(tags: string[], name: string, summary: string): DocumentationPart;

package/dist/aws/infra/documentation.js

@@ -17,7 +17,7 @@ function addQueryParameterDescription(name, description, resource, stack) {
     new aws_apigateway_1.CfnDocumentationPart(stack, `${name}Documentation`, {
         restApiId: resource.api.restApiId,
         location: {
-            type: 'QUERY_PARAMETER',
+            type: "QUERY_PARAMETER",
             name,
             path: resource.path,
         },
@@ -36,7 +36,7 @@ function addDocumentation(methodDescription, documentationProperties, resource,
     new aws_apigateway_1.CfnDocumentationPart(stack, `${methodDescription}Documentation`, {
         restApiId: resource.api.restApiId,
         location: {
-            type: 'METHOD',
+            type: "METHOD",
             path: resource.path,
         },
         properties: JSON.stringify(documentationProperties),
@@ -78,7 +78,7 @@ class DocumentationPart {
     deprecated(note) {
         // deprecated is not supported ATM: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-known-issues.html
         this.documentationProperties.deprecated = true;
-        this.documentationProperties.summary += '. ' + note;
+        this.documentationProperties.summary += ". " + note;
         return this;
     }
     static queryParameter(parameterName, description) {

package/dist/aws/infra/stack/monitoredfunction.d.ts

@@ -8,7 +8,7 @@ import { TrafficType } from "../../../types/traffictype";
 /**
  * Allows customization of CloudWatch Alarm properties
  */
-export type MonitoredFunctionAlarmProps = {
+export interface MonitoredFunctionAlarmProps {
     /**
      * Setting this to false will not create a CloudWatch alarm
      */
@@ -17,13 +17,13 @@ export type MonitoredFunctionAlarmProps = {
     readonly evaluationPeriods?: number;
     readonly datapointsToAlarm?: number;
     readonly comparisonOperator?: ComparisonOperator;
-};
-export type MonitoredFunctionProps = {
+}
+export interface MonitoredFunctionProps {
     readonly durationAlarmProps?: MonitoredFunctionAlarmProps;
     readonly durationWarningProps?: MonitoredFunctionAlarmProps;
     readonly errorAlarmProps?: MonitoredFunctionAlarmProps;
     readonly throttleAlarmProps?: MonitoredFunctionAlarmProps;
-};
+}
 /**
  * Creates a Lambda function that monitors default CloudWatch Lambda metrics with CloudWatch Alarms.
  */

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

@@ -37,7 +37,7 @@ class MonitoredFunction extends aws_lambda_1.Function {
      * @param functionParameters Lambda function parameters
      */
     static createV2(stack, name, environment, functionParameters) {
-        const functionName = functionParameters?.functionName ||
+        const functionName = functionParameters?.functionName ??
             `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
         const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, environment, functionName, name, functionParameters);
         return MonitoredFunction.create(stack, functionName, functionProps, functionParameters);
@@ -127,7 +127,7 @@ class MonitoredDBFunction {
      * @param functionParameters Lambda function parameters
      */
     static create(stack, name, environment, functionParameters) {
-        const functionName = functionParameters?.functionName ||
+        const functionName = functionParameters?.functionName ??
             `${stack.configuration.shortName}-${(0, change_case_1.pascalCase)(name)}`;
         const env = environment ? environment : stack.createLambdaEnvironment();
         const functionProps = (0, lambda_configs_1.databaseFunctionProps)(stack, env, functionName, name, functionParameters);

package/dist/aws/infra/stack/stack-checking-aspect.js

@@ -110,13 +110,11 @@ class StackCheckingAspect {
     checkBucket(node) {
         if (node instanceof aws_s3_1.CfnBucket) {
             const c = node.publicAccessBlockConfiguration;
-            if (c) {
-                if (!c.blockPublicAcls ||
-                    !c.blockPublicPolicy ||
-                    !c.ignorePublicAcls ||
-                    !c.restrictPublicBuckets) {
-                    this.addAnnotation(node, ResourceType.bucketPublicity, "Check bucket publicity");
-                }
+            if (!c.blockPublicAcls ||
+                !c.blockPublicPolicy ||
+                !c.ignorePublicAcls ||
+                !c.restrictPublicBuckets) {
+                this.addAnnotation(node, ResourceType.bucketPublicity, "Check bucket publicity");
             }
         }
     }
@@ -141,7 +139,7 @@ class StackCheckingAspect {
         }
         else if (node instanceof aws_apigateway_1.CfnMethod) {
             const integration = node.integration;
-            if (integration && integration.requestParameters) {
+            if (integration?.requestParameters) {
                 Object.keys(integration.requestParameters).forEach((key) => {
                     const split = key.split(".");
                     const type = split[2];

package/dist/aws/infra/stacks/db-stack.js

@@ -38,7 +38,8 @@ class DbStack extends aws_cdk_lib_1.Stack {
                 }),
                 parameters: {
                     "pg_stat_statements.track": "ALL",
-                    random_page_cost: "1",
+                    "random_page_cost": "1",
+                    "work_mem": "512MB"
                 },
             })
             : aws_rds_1.ParameterGroup.fromParameterGroupName(this, "ParameterGroup", `default.aurora-postgresql${configuration.dbVersion.auroraPostgresMajorVersion}`);

package/dist/aws/runtime/dt-logger.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { Writable } from "stream";
+type LOG_LEVEL = "DEBUG" | "INFO" | "ERROR";
+export interface LoggerConfiguration {
+    lambdaName?: string;
+    fileName?: string;
+    runTime?: string;
+    writeStream?: Writable;
+}
+export type LoggableType = string | number | Record<string, unknown>;
+/**
+ * Helper class for json-logging.  Logged line will include
+ * * log-level (see LOG_LEVEL)
+ * * lambdaName (taken from process environment)
+ * * runtime (taken from process environment)
+ * * the actual message (as json or as string)
+ */
+export declare class DtLogger {
+    readonly lambdaName?: string;
+    readonly fileName?: string;
+    readonly runtime?: string;
+    readonly writeStream: Writable;
+    constructor(config?: LoggerConfiguration);
+    info(message: LoggableType): void;
+    error(message: LoggableType): void;
+    log(level: LOG_LEVEL, message: LoggableType): void;
+}
+export {};

package/dist/aws/runtime/dt-logger.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtLogger = void 0;
+/**
+ * Helper class for json-logging.  Logged line will include
+ * * log-level (see LOG_LEVEL)
+ * * lambdaName (taken from process environment)
+ * * runtime (taken from process environment)
+ * * the actual message (as json or as string)
+ */
+class DtLogger {
+    constructor(config) {
+        this.lambdaName =
+            config?.lambdaName ?? process.env.AWS_LAMBDA_FUNCTION_NAME;
+        this.fileName = config?.fileName;
+        this.runtime = config?.runTime ?? process.env.AWS_EXECUTION_ENV;
+        this.writeStream = config?.writeStream ?? process.stdout;
+    }
+    info(message) {
+        this.log("INFO", message);
+    }
+    error(message) {
+        this.log("ERROR", message);
+    }
+    log(level, message) {
+        // put string/number messages into message object
+        const actualMessage = typeof message == "object" ? message : { message: message };
+        const logMessage = {
+            ...actualMessage,
+            ...{
+                level,
+                fileName: this.fileName,
+                lambdaName: this.lambdaName,
+                runtime: this.runtime,
+            },
+        };
+        this.writeStream.write(JSON.stringify(logMessage) + "\n");
+    }
+}
+exports.DtLogger = DtLogger;
+//# sourceMappingURL=dt-logger.js.map

package/dist/aws/runtime/secrets/dbsecret.d.ts

@@ -1,10 +1,10 @@
 import { GenericSecret } from "./secret";
-export type DbSecret = {
+export interface DbSecret {
     readonly username: string;
     readonly password: string;
     readonly host: string;
     readonly ro_host: string;
-};
+}
 export declare enum RdsProxySecretKey {
     username = "username",
     password = "password",
@@ -34,10 +34,10 @@ export declare enum DatabaseEnvironmentKeys {
  * The secret that is passed to the given function will not include the prefix in it's keys.
 
  */
-export type SecretOptions = {
+export interface SecretOptions {
     readonly expectedKeys?: string[];
     readonly prefix?: string;
-};
+}
 export type SecretToPromiseFunction<Secret, Response = void> = (secret: Secret) => Promise<Response> | void;
 export type SecretFunction<Secret, Response = void> = (secretId: string, fn: SecretToPromiseFunction<Secret, Response>, options?: SecretOptions) => Promise<Response | void>;
 export type EmptySecretFunction<Response = void> = SecretFunction<DbSecret, Response>;

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

@@ -88,7 +88,7 @@ exports.withDbSecret = withDbSecret;
 function checkExpectedSecretKeys(keys, secret) {
     const missingKeys = keys.filter((key) => !(key in secret));
     if (missingKeys.length) {
-        console.error(`method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys}`);
+        console.error(`method=checkExpectedSecretKeys secret didn't contain the key(s) ${missingKeys.toString()}`);
         throw new Error("Expected keys were not found");
     }
 }

package/dist/aws/types/proxytypes.d.ts

@@ -3,18 +3,18 @@
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaResponse = {
+export interface ProxyLambdaResponse {
     readonly statusCode: number;
     readonly body: string;
     readonly headers?: Record<string, string>;
     readonly multiValueHeaders?: Record<string, string[]>;
-};
+}
 /**
  * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
  *
  * Not fully described, extend if necessary.
  */
-export type ProxyLambdaRequest = {
+export interface ProxyLambdaRequest {
     readonly resource: string;
     readonly path: string;
     readonly httpMethod: string;
@@ -23,4 +23,4 @@ export type ProxyLambdaRequest = {
     readonly queryStringParameters: Record<string, string>;
     readonly multiValueQueryStringParameters: Record<string, string[]>;
     readonly body?: string;
-};
+}

package/dist/database/last-updated.js

@@ -11,17 +11,19 @@ var DataType;
     DataType["PERMIT_DATA"] = "PERMIT_DATA";
     DataType["PERMIT_DATA_CHECK"] = "PERMIT_DATA_CHECK";
 })(DataType = exports.DataType || (exports.DataType = {}));
-const UNSET_SUBTYPE = '-';
+const UNSET_SUBTYPE = "-";
 function getLastUpdated(db, datatype) {
     return db.oneOrNone("select updated from data_updated where data_type=$(datatype) and subtype=$(subtype)", {
-        datatype: datatype, subtype: UNSET_SUBTYPE,
-    }, (x) => x?.updated || null);
+        datatype: datatype,
+        subtype: UNSET_SUBTYPE,
+    }, (x) => x?.updated ?? null);
 }
 exports.getLastUpdated = getLastUpdated;
 function getLastUpdatedWithSubtype(db, datatype, subtype) {
     return db.oneOrNone("SELECT updated FROM data_updated WHERE data_type=$(datatype) AND subtype=$(subtype)", {
-        datatype: datatype, subtype: subtype,
-    }, (x) => x?.updated || null);
+        datatype: datatype,
+        subtype: subtype,
+    }, (x) => x?.updated ?? null);
 }
 exports.getLastUpdatedWithSubtype = getLastUpdatedWithSubtype;
 function updateLastUpdated(db, datatype, updated) {
@@ -41,10 +43,10 @@ exports.updateLastUpdatedWithSubtype = updateLastUpdatedWithSubtype;
 function getUpdatedTimestamp(db, datatype) {
     return db.oneOrNone("select updated_time as updated from updated_timestamp where updated_name=$(datatype)", {
         datatype: datatype,
-    }, (x) => x?.updated || null);
+    }, (x) => x?.updated ?? null);
 }
 exports.getUpdatedTimestamp = getUpdatedTimestamp;
-function updateUpdatedTimestamp(db, datatype, date, by = '') {
+function updateUpdatedTimestamp(db, datatype, date, by = "") {
     return db.none(`insert into updated_timestamp(updated_name, updated_time, updated_by)
 values($(datatype), $(date), $(by))
 on conflict (updated_name)

package/dist/marine/rtz.d.ts

@@ -1,16 +1,16 @@
-export type RtzPositionCoordinate = {
+export interface RtzPositionCoordinate {
     readonly $: {
         readonly lat: number;
         readonly lon: number;
     };
-};
-export type RtzWaypointPosition = {
+}
+export interface RtzWaypointPosition {
     readonly position: RtzPositionCoordinate[];
-};
-export type RtzWaypoint = {
+}
+export interface RtzWaypoint {
     readonly waypoint: RtzWaypointPosition[];
-};
-export type RtzScheduleElement = {
+}
+export interface RtzScheduleElement {
     readonly $: {
         /**
          * Date
@@ -21,28 +21,28 @@ export type RtzScheduleElement = {
          */
         readonly eta?: string;
     };
-};
-export type RtzSchedule = {
+}
+export interface RtzSchedule {
     readonly scheduleElement: RtzScheduleElement[];
-};
-export type RtzScheduleWrapper = {
+}
+export interface RtzScheduleWrapper {
     readonly manual?: RtzSchedule[];
     readonly calculated?: RtzSchedule[];
-};
-export type RtzSchedules = {
+}
+export interface RtzSchedules {
     readonly schedule: RtzScheduleWrapper[];
-};
-export type RtzRouteInfo = {
+}
+export interface RtzRouteInfo {
     readonly $: {
         readonly vesselMMSI: string;
         readonly vesselIMO: string;
     };
-};
-export type RtzRoute = {
+}
+export interface RtzRoute {
     readonly routeInfo: RtzRouteInfo[];
     readonly waypoints: RtzWaypoint[];
     readonly schedules: RtzSchedules[];
-};
-export type RtzVoyagePlan = {
+}
+export interface RtzVoyagePlan {
     readonly route: RtzRoute;
-};
+}

package/dist/test/asserter.d.ts

@@ -1,11 +1,13 @@
 /**
  * A simple asserter-class for writing canaries without dependency to testing-libraries.
  */
+type AssertedValue = string | number;
 export declare abstract class Asserter {
-    static assertEquals<T>(value: T, expected: T): void;
-    static assertTrue<T>(value: T): void;
-    static assertLength<T>(data: T[], expected: number): void;
-    static assertLengthGreaterThan<T>(data: T[], expected: number): void;
+    static assertEquals(value: AssertedValue, expected: AssertedValue): void;
+    static assertTrue(value: boolean): void;
+    static assertLength<T>(data: T[] | undefined, expected: number): void;
+    static assertLengthGreaterThan<T>(data: T[] | undefined, expected: number): void;
     static assertGreaterThan(value: number, expected: number): void;
     static assertToBeCloseTo(value: number, expected: number, delta: number): void;
 }
+export {};

package/dist/test/asserter.js

@@ -12,7 +12,7 @@ class Asserter {
     }
     static assertTrue(value) {
         if (!value) {
-            throw new Error(`Given value ${value} was not true`);
+            throw new Error(`Given value was not true`);
         }
     }
     static assertLength(data, expected) {

package/dist/test/httpserver.d.ts

@@ -14,6 +14,4 @@ export declare class TestHttpServer {
     close(): void;
     private debuglog;
 }
-export interface ListenProperties {
-    [key: string]: (url?: string, data?: string) => string;
-}
+export type ListenProperties = Record<string, (url?: string, data?: string) => string>;

package/dist/test/httpserver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestHttpServer = exports.ERRORCODE_NOT_FOUND = exports.ERROR_NO_MATCH = void 0;
 const http_1 = require("http");
+const url_1 = require("url");
 exports.ERROR_NO_MATCH = "NO MATCH";
 exports.ERRORCODE_NOT_FOUND = 404;
 /**
@@ -25,9 +26,14 @@ class TestHttpServer {
         this.server = (0, http_1.createServer)((req, res) => {
             this.debuglog("Mapped urls: ");
             Object.keys(props).forEach((k) => this.debuglog(k));
-            this.debuglog("Received request to url " + req.url + "..");
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            const path = require("url").parse(req.url).pathname;
+            if (!req.url) {
+                throw new Error("Missing request url!");
+            }
+            this.debuglog(`Received request to url ${req.url} ..`);
+            const path = (0, url_1.parse)(req.url).pathname;
+            if (!path) {
+                throw new Error("Missing path from request!");
+            }
             let dataStr = "";
             req.on("data", (chunk) => {
                 if (chunk) {
@@ -46,7 +52,7 @@ class TestHttpServer {
                 });
             }
             else {
-                this.debuglog("..no match for %" + path);
+                this.debuglog(`..no match for ${path}`);
                 req.on("end", () => {
                     // assume sent data is in JSON format
                     this.messageStack[this.messageStack.length] =

package/dist/types/either.d.ts

@@ -1,9 +1,9 @@
-export type EitherOk<T> = {
+export interface EitherOk<T> {
     result: "ok";
     value: T;
-};
-export type EitherError = {
+}
+export interface EitherError {
     result: "error";
     message: string;
-};
+}
 export type Either<T> = EitherOk<T> | EitherError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2022.12.02-1",
+  "version": "2022.12.22-2",
   "description": "",
   "repository": {
     "type": "git",