@digitraffic/common 2022.11.28-1 → 2022.12.2-1

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

@@ -0,0 +1,20 @@
+export type LoggingHandler<RESPONSE> = (methodName: string, method: () => Promise<RESPONSE>) => Promise<RESPONSE>;
+export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
+/**
+ * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
+ * with the defaults:
+ * * No error handling
+ * * Execution time logging
+ *
+ * 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> {
+    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>;
+}
+export declare function createNoLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE>;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoLoggingHandler = exports.HandlerFactory = void 0;
+/**
+ * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
+ * with the defaults:
+ * * No error handling
+ * * Execution time logging
+ *
+ * You should instantiate HandlerFactory in your project with desired error handling and use the factory instance for
+ * creating handler-functions for your lambdas.
+ */
+class HandlerFactory {
+    constructor() {
+        this.loggingHandler = createDefaultLoggingHandler();
+        this.errorHandler = (error) => {
+            throw error;
+        };
+    }
+    withLoggingHandler(loggingHandler) {
+        this.loggingHandler = loggingHandler;
+        return this;
+    }
+    withErrorHandler(errorHandler) {
+        this.errorHandler = errorHandler;
+        return this;
+    }
+    createEventHandler(methodName, handler) {
+        return async (event) => {
+            return await this.loggingHandler(methodName, async () => {
+                try {
+                    return await handler(event);
+                }
+                catch (error) {
+                    return this.errorHandler(error);
+                }
+            });
+        };
+    }
+}
+exports.HandlerFactory = HandlerFactory;
+function createNoLoggingHandler() {
+    return (methodName, method) => {
+        return method();
+    };
+}
+exports.createNoLoggingHandler = createNoLoggingHandler;
+function createDefaultLoggingHandler() {
+    return (methodName, method) => {
+        const start = Date.now();
+        try {
+            return method();
+        }
+        finally {
+            console.info("method=%s tookMs=%d", methodName, Date.now() - start);
+        }
+    };
+}
+//# sourceMappingURL=handler-factory.js.map

package/dist/database/cached.d.ts

@@ -1,7 +1,12 @@
 import { DTDatabase, DTTransaction } from "./database";
+export interface CachedValue<T> {
+    content: T;
+    last_updated: Date;
+}
 export declare enum JSON_CACHE_KEY {
     NAUTICAL_WARNINGS_ACTIVE = "nautical-warnings-active",
     NAUTICAL_WARNINGS_ARCHIVED = "nautical-warnings-archived"
 }
 export declare function updateCachedJson<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY, value: T): Promise<null>;
 export declare function getJsonFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<T | null>;
+export declare function getFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<CachedValue<T> | null>;

package/dist/database/cached.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsonFromCache = exports.updateCachedJson = exports.JSON_CACHE_KEY = void 0;
+exports.getFromCache = exports.getJsonFromCache = exports.updateCachedJson = exports.JSON_CACHE_KEY = void 0;
 const pg_promise_1 = require("pg-promise");
 const SQL_UPDATE_CACHE_VALUE = `insert into cached_json(cache_id, content, last_updated)
     values ($1, $2, now())
@@ -9,11 +9,11 @@ const SQL_UPDATE_CACHE_VALUE = `insert into cached_json(cache_id, content, last_
 const SQL_GET_CACHE_VALUE = `select content, last_updated from cached_json
     where cache_id = $1`;
 const PS_UPDATE_CACHE_VALUE = new pg_promise_1.PreparedStatement({
-    name: 'update-cache-value',
+    name: "update-cache-value",
     text: SQL_UPDATE_CACHE_VALUE,
 });
 const PS_GET_CACHE_VALUE = new pg_promise_1.PreparedStatement({
-    name: 'get-cache-value',
+    name: "get-cache-value",
     text: SQL_GET_CACHE_VALUE,
 });
 var JSON_CACHE_KEY;
@@ -26,7 +26,13 @@ function updateCachedJson(db, cacheKey, value) {
 }
 exports.updateCachedJson = updateCachedJson;
 function getJsonFromCache(db, cacheKey) {
-    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]).then(value => value?.content ?? null);
+    return db
+        .oneOrNone(PS_GET_CACHE_VALUE, [cacheKey])
+        .then((value) => value?.content ?? null);
 }
 exports.getJsonFromCache = getJsonFromCache;
+function getFromCache(db, cacheKey) {
+    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]);
+}
+exports.getFromCache = getFromCache;
 //# sourceMappingURL=cached.js.map

package/package.json

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

package/src/aws/infra/api/handler-factory.ts

@@ -0,0 +1,70 @@
+export type LoggingHandler<RESPONSE> = (
+    methodName: string,
+    method: () => Promise<RESPONSE>
+) => Promise<RESPONSE>;
+export type ErrorHandler<RESPONSE> = (error: unknown) => RESPONSE;
+
+/**
+ * Factory class for creating lambda-handler functions.  You can set functionality to handle logging and error-handling,
+ * with the defaults:
+ * * No error handling
+ * * Execution time logging
+ *
+ * You should instantiate HandlerFactory in your project with desired error handling and use the factory instance for
+ * creating handler-functions for your lambdas.
+ */
+export class HandlerFactory<RESPONSE> {
+    private loggingHandler: LoggingHandler<RESPONSE>;
+    private errorHandler: ErrorHandler<RESPONSE>;
+
+    constructor() {
+        this.loggingHandler = createDefaultLoggingHandler();
+
+        this.errorHandler = (error: unknown) => {
+            throw error;
+        };
+    }
+
+    withLoggingHandler(loggingHandler: LoggingHandler<RESPONSE>) {
+        this.loggingHandler = loggingHandler;
+        return this;
+    }
+
+    withErrorHandler(errorHandler: ErrorHandler<RESPONSE>) {
+        this.errorHandler = errorHandler;
+        return this;
+    }
+
+    createEventHandler(
+        methodName: string,
+        handler: (event: unknown) => Promise<RESPONSE>
+    ) {
+        return async (event: unknown) => {
+            return await this.loggingHandler(methodName, async () => {
+                try {
+                    return await handler(event);
+                } catch (error) {
+                    return this.errorHandler(error);
+                }
+            });
+        };
+    }
+}
+
+export function createNoLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE> {
+    return (methodName: string, method: () => Promise<RESPONSE>) => {
+        return method();
+    };
+}
+
+function createDefaultLoggingHandler<RESPONSE>(): LoggingHandler<RESPONSE> {
+    return (methodName: string, method: () => Promise<RESPONSE>) => {
+        const start = Date.now();
+
+        try {
+            return method();
+        } finally {
+            console.info("method=%s tookMs=%d", methodName, Date.now() - start);
+        }
+    };
+}

package/src/database/cached.ts

@@ -1,35 +1,54 @@
-import {PreparedStatement} from "pg-promise";
-import {DTDatabase, DTTransaction} from "./database";
+import { PreparedStatement } from "pg-promise";
+import { DTDatabase, DTTransaction } from "./database";
 
-const SQL_UPDATE_CACHE_VALUE =
-    `insert into cached_json(cache_id, content, last_updated)
+export interface CachedValue<T> {
+    content: T;
+    last_updated: Date;
+}
+
+const SQL_UPDATE_CACHE_VALUE = `insert into cached_json(cache_id, content, last_updated)
     values ($1, $2, now())
     on conflict(cache_id) do
     update set content = $2, last_updated = now()`;
 
-const SQL_GET_CACHE_VALUE =
-    `select content, last_updated from cached_json
+const SQL_GET_CACHE_VALUE = `select content, last_updated from cached_json
     where cache_id = $1`;
 
 const PS_UPDATE_CACHE_VALUE = new PreparedStatement({
-    name: 'update-cache-value',
+    name: "update-cache-value",
     text: SQL_UPDATE_CACHE_VALUE,
 });
 
 const PS_GET_CACHE_VALUE = new PreparedStatement({
-    name: 'get-cache-value',
+    name: "get-cache-value",
     text: SQL_GET_CACHE_VALUE,
 });
 
 export enum JSON_CACHE_KEY {
-    NAUTICAL_WARNINGS_ACTIVE = 'nautical-warnings-active',
-    NAUTICAL_WARNINGS_ARCHIVED = 'nautical-warnings-archived'
+    NAUTICAL_WARNINGS_ACTIVE = "nautical-warnings-active",
+    NAUTICAL_WARNINGS_ARCHIVED = "nautical-warnings-archived",
 }
 
-export function updateCachedJson<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY, value: T): Promise<null> {
+export function updateCachedJson<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY,
+    value: T
+): Promise<null> {
     return db.none(PS_UPDATE_CACHE_VALUE, [cacheKey, value]);
 }
 
-export function getJsonFromCache<T>(db: DTDatabase | DTTransaction, cacheKey: JSON_CACHE_KEY): Promise<T | null> {
-    return db.oneOrNone(PS_GET_CACHE_VALUE, [cacheKey]).then(value => value?.content ?? null);
+export function getJsonFromCache<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY
+): Promise<T | null> {
+    return db
+        .oneOrNone<CachedValue<T>>(PS_GET_CACHE_VALUE, [cacheKey])
+        .then((value) => value?.content ?? null);
+}
+
+export function getFromCache<T>(
+    db: DTDatabase | DTTransaction,
+    cacheKey: JSON_CACHE_KEY
+): Promise<CachedValue<T> | null> {
+    return db.oneOrNone<CachedValue<T>>(PS_GET_CACHE_VALUE, [cacheKey]);
 }